遲dē傳說

{
ID:fanminj1
PROG:frac1
LANG:PASCAL
}
var
  i,j,n,k,l:integer;
  m:longint;
  a:array[1..10000,1..2] of integer;
  e:array[1..10000] of real;
procedure sort(l, r: integer);
var
  y,z:integer;
  w,x:real;
begin
  i := l; j := r; x := e[(l+r) div 2];
  repeat
    while e[i]<x do inc(i);
    while x<e[j] do dec(j);
    if i <= j then begin
      y := a[i,1]; a[i,1] := a[j,1]; a[j,1] := y;
      z := a[i,2]; a[i,2] := a[j,2]; a[j,2] := z;
      w := e[i]; e[i] := e[j]; e[j] := w;
      inc(i); dec(j);
    end;
  until i > j;
  if l < j then sort(l, j);
  if i < r then sort(i, r);
end;
function gcd(c,d:byte):integer;
var
  t:byte;
begin
  while d>0 do begin
    t:=c mod d;
    c:=d;
    d:=t;
  end;
  gcd:=c;
end;
begin
  assign(input,'frac1.in');  reset(input);
  assign(output,'frac1.out');  rewrite(output);
  m:=0;
  readln(n);
  writeln('0/1');
  for i:=2 to n do
    for j:=1 to i-1 do
      if gcd(i,j)=1 then begin
        inc(m);
        a[m,1]:=i;
        a[m,2]:=j;
      end;
  for i:=1 to m do e[i]:=a[i,2]/a[i,1];
  sort(1,m);
  for i:=1 to m do writeln(a[i,2],'/',a[i,1]);
  writeln('1/1');
  close(input);  close(output);
end.
排序问题，注意必须用快排

 

种子染色法递归即可解决

程序如下：

{
ID:fanminj1
LANG:PASCAL
PROG:castle
}
var
  map:array[1..50,1..50] of
      record
        n,e,w,s:boolean;
        c:longint;
      end;
  a:array[1..2500] of longint;
  p,q,i,j,t:longint;
  s1,s2,s3,x,y:longint;
  pos:char;
procedure work(p,q:longint);
begin
  map[p,q].c:=s1;inc(a[s1]);
  if not map[p,q].n then
    if map[p-1,q].c=0 then work(p-1,q);
  if not map[p,q].e then
    if map[p,q+1].c=0 then work(p,q+1);
  if not map[p,q].w then
    if map[p,q-1].c=0 then work(p,q-1);
  if not map[p,q].s then
    if map[p+1,q].c=0 then work(p+1,q);
end;
begin
  assign(input,'castle.in');  reset(input);
  assign(output,'castle.out');  rewrite(output);
  readln(q,p);
  for i:=1 to p do
    for j:=1 to q do begin
      read(t);
      if t>=8 then begin dec(t,8);
      map[i,j].s:=true end;
      if t>=4 then begin dec(t,4);
      map[i,j].e:=true end;
      if t>=2 then begin dec(t,2);
      map[i,j].n:=true end;
      if t>=1 then begin dec(t,1);
      map[i,j].w:=true end;
    end;
  fillchar(a,sizeof(a),0);
  s1:=0;  s2:=0;  s3:=0;
  for i:=1 to p do
    for j:=1 to q do
      if map[i,j].c=0 then
      begin
        inc(s1);work(i,j);
      end;
  writeln(s1);
  for i:=1 to s1 do if a[i]>s2 then s2:=a[i];
  writeln(s2);
  for j:=1 to q do
    for i:=p downto 1 do begin
      if i>1 then
        if map[i,j].c<>map[i-1,j].c then
          if a[map[i,j].c]+a[map[i-1,j].c]>s3 then
          begin
            s3:=a[map[i,j].c]+a[map[i-1,j].c];
            x:=i;y:=j;pos:='N';
          end;
      if j<q then
        if map[i,j].c<>map[i,j+1].c then
          if a[map[i,j].c]+a[map[i,j+1].c]>s3 then
          begin
            s3:=a[map[i,j].c]+a[map[i,j+1].c];
            x:=i;y:=j;pos:='E';
          end;
    end;
  writeln(s3);
  writeln(x,' ',y,' ',pos);
  close(input);close(output);
end.

 

难题！线段数问题，据说用离散+递归

这里是某位大牛的程序：

{
ID:???
PROG:rect1
LANG:PASCAL
}
program bluewater;
const maxab=10000;maxc=2500;maxn=1000;maxl=2002;
type arr=array[1..maxl] of integer;
tpoint=^tppoint;
tppoint=record
left,right,mid,cover:integer;
nl,nr:tpoint;
end;
var
a,b,n,i,j,lx,ly,k:integer;
t:array[1..maxc] of longint;
x,y,ax,ay:arr;
ac:array[1..maxn] of integer;
haxi:array[0..maxab] of integer;
head:tpoint;
f1,f2:text;

procedure init;
var i:integer;
begin
assign(f1,'rect1.in');
reset(f1);
readln(f1,a,b,n);
for i:=1 to n do
readln(f1,ax[2*i-1],ay[2*i-1],ax[2*i],ay[2*i],ac[i]);
close(f1);
ax[2*n+1]:=0;ax[2*n+2]:=a;
ay[2*n+1]:=0;ay[2*n+2]:=b;
end;

procedure sort(x:arr;len:integer;var z:arr;var lxy:integer);
var
ab:array[0..maxab] of boolean;
i,l:integer;
begin
l:=0;
fillchar(ab,sizeof(ab),false);
for i:=1 to 2*n+2 do
ab[x[i]]:=true;
for i:=0 to len do
if ab[i] then begin inc(l);z[l]:=i end;
lxy:=l;
end;

function min(a,b:integer):integer;
begin
if a>b then min:=b else min:=a;
end;

function max(a,b:integer):integer;
begin
if a>b then max:=a else max:=b;
end;

procedure build(var p:tpoint;left,right:integer);
begin
if (left>right) then begin p:=nil;exit end;
p^.left:=left;
p^.right:=right;
p^.mid:=(p^.left+p^.right) div 2;
p^.cover:=0;
if left=right then
begin p^.nl:=nil;p^.nr:=nil; exit end;
new(p^.nl);
new(p^.nr);
build(p^.nl,left,p^.mid);
build(p^.nr,p^.mid+1,right);
end;

procedure put(p:tpoint;left,right,c,k:integer);
begin
if p=nil then exit;
if y[p^.right+1]-y[p^.left]=p^.cover then exit;
if (left=p^.left) and (right=p^.right) then
begin
t[c]:=t[c]+(y[p^.right+1]-y[p^.left]-p^.cover)*(x[k+1]-x[k]);
t[1]:=t[1]-(y[p^.right+1]-y[p^.left]-p^.cover)*(x[k+1]-x[k]);
p^.cover:=y[p^.right+1]-y[p^.left];
exit;
end;
if left>right then exit;
put(p^.nl,left,min(p^.mid,right),c,k);
put(p^.nr,max(p^.mid+1,left),right,c,k);
p^.cover:=p^.nl^.cover+p^.nr^.cover;
end;

procedure cover0(p:tpoint);
begin
if p=nil then exit;
p^.cover:=0;
cover0(p^.nl);
cover0(p^.nr);
end;

begin
init;
sort(ax,a,x,lx);
sort(ay,b,y,ly);
for i:=1 to ly do haxi[y[i]]:=i;
assign(f2,'rect1.out');
rewrite(f2);new(head);
fillchar(t,sizeof(t),0);
new(head);
build(head,1,ly-1);
t[1]:=a*b;
for i:=1 to lx-1 do
begin
for j:=n downto 1 do
if (ax[2*j-1]<=x[i]) and (x[i]<ax[2*j]) then
put(head,haxi[ay[2*j-1]],haxi[ay[2*j]]-1,ac[j],i);
cover0(head);
end;
for k:=1 to maxc do
if t[k]>0 then writeln(f2,k,' ',t[k]);
close(f2);
end.

DFS,还可以适当优化,比如首位数字只能是2,3,5,7  其他位上的数字只能是1,3,7,9.不过觉得对于本题没有很大意义.

程序如下：

{
ID:fanminj1
LANG:PASCAL
TASK:sprime
}
var
  n:byte;
function flag(i:longint):boolean;
var
  j:longint;
begin
  flag:=true;
  if i=1 then begin
    flag:=false;
    exit;
  end;
  for j:=2 to trunc(sqrt(i)) do
    if i mod j=0 then begin
      flag:=false;
      exit;
    end;
end;
procedure sub(a,b:longint);
begin
  if a=n then writeln(b)
         else begin
           if flag(b*10+1) then sub(a+1,b*10+1);
           if flag(b*10+3) then sub(a+1,b*10+3);
           if flag(b*10+7) then sub(a+1,b*10+7);
           if flag(b*10+9) then sub(a+1,b*10+9);
         end;
end;
begin
  assign(input,'sprime.in');  reset(input);
  assign(output,'sprime.out');  rewrite(output);
  readln(n);
  sub(1,2);
  sub(1,3);
  sub(1,5);
  sub(1,7);
  close(input);  close(output);
end.

最简单的DP

程序如下：

{
ID:fanminj1
LANG:PASCAL
TASK:numtri
}
var
  a:array[1..1000,1..1000] of 0..100;
  s:array[0..1000,0..1000] of longint;
  r,i,j:0..1000;
  temp:longint;
begin
  assign(input,'numtri.in');  reset(input);
  assign(output,'numtri.out');  rewrite(output);
  readln(r);
  for i:=1 to r do begin
    for j:=1 to i do read(a[i,j]);
    readln;
  end;
  s[1,1]:=a[1,1];  temp:=0;
  for i:=2 to r do
    for j:=1 to i do
     if s[i-1,j-1]>s[i-1,j] then s[i,j]:=a[i,j]+s[i-1,j-1]
                            else s[i,j]:=a[i,j]+s[i-1,j];
  for i:=1 to r do if s[r,i]>temp then temp:=s[r,i];
  writeln(temp);
  close(input);  close(output);
end.

此题可以称为usaco中的一道难题，主要是在最后一个数据卡，对称优化后一般可以通过。具体优化方法如下：

当n为偶数时，第一行只需要搜索前n div 2个格子就可以了，根据左右对称，将所得结果×2就是最后的答案。
      当n为奇数时，还是一样搜索第一行的前n div 2个格子，不过这样会漏掉中间格子的情况。根据上下对称，第一行中间格子的情况与最后一行中间格子的情况是一样的，在搜索前n div 2个格子的时候记录一下最后一行中间格子有解的个数，同样×2，将两个结果相加，就是最后的答案。

由于我的程序在优化后还是超了0.1秒，所以把jmcat大牛的程序借用了

程序如下：

{
ID:jmcat
PROG:checker
LANG:PASCAL
}
var a,b,c:array[-30..30] of boolean;
    s:array[1..13] of integer;
    n,m,i,t:longint;
procedure work(x:longint);
  var i:longint;
  begin
    if x<=n then
    begin
      for i:=1 to n do
        if a[i] and b[i+x] and c[i-x] then
        begin
          a[i]:=false;b[i+x]:=false;c[i-x]:=false;
          s[x]:=i;work(x+1);
          a[i]:=true;b[i+x]:=true;c[i-x]:=true;
        end;
    end
    else begin
      inc(m);
      if s[n]=n div 2+1 then
        inc(t);
      if m<=3 then
      begin
        for i:=1 to n-1 do
          write(s[i],' ');
        writeln(s[n]);
      end;
    end;
  end;
begin
  assign(input,'checker.in');
  assign(output,'checker.out');
  reset(input);rewrite(output);
  fillchar(a,sizeof(a),1);
  fillchar(b,sizeof(b),1);
  fillchar(c,sizeof(c),1);
  readln(n);m:=0;t:=0;
  if n<7 then
    work(1)
  else begin
    for i:=1 to n div 2 do
    begin
      a[i]:=false;b[i+1]:=false;c[i-1]:=false;
      s[1]:=i;work(2);s[1]:=0;
      a[i]:=true;b[i+1]:=true;c[i-1]:=true;
    end;
    m:=m*2;t:=t*2;
    if odd(n) then inc(m,t);
  end;
  writeln(m);
  close(input);close(output);
end.

这道题目就是麻烦，数字转英文

程序如下：

{
ID:fanminj1
LANG:PASCAL
TASK:clock
}
var
  s,t:string;
  a,b,c:integer;
procedure down(r:string);
begin
  t:=r;
  t[1]:=chr(ord(t[1])+32);
end;
function change(k:integer):string;
begin
  case k of
    1: change:='One';
    2: change:='Two';
    3: change:='Three';
    4: change:='Four';
    5: change:='Five';
    6: change:='Six';
    7: change:='Seven';
    8: change:='Eight';
    9: change:='Nine';
    10: change:='Ten';
    11: change:='Eleven';
    12: change:='Twelve';
    13: change:='thirteen';
    14: change:='fourteen';
    15: change:='fifteen';
    16: change:='sixteen';
    17: change:='seventeen';
    18: change:='eighteen';
    19: change:='nineteen';
    20: change:='twenty';
    30: change:='thirty';
    40: change:='forty';
    50: change:='fifty';
  end;
end;
begin
  assign(input,'clock.in');  reset(input);
  assign(output,'clock.out');  rewrite(output);
  readln(s);
  if s[2]=':' then begin
    a:=ord(s[1])-48;
    b:=(ord(s[3])-48)*10+ord(s[4])-48;
  end;
  if s[3]=':' then begin
    a:=(ord(s[1])-48)*10+ord(s[2])-48;
    b:=(ord(s[4])-48)*10+ord(s[5])-48;
  end;
  if b=0 then writeln(change(a),' o','''','clock');
  if b=15 then begin
    write('Quarter past ');
    down(change(a));
    writeln(t);
  end;
  if (b<45) and (b<>0) and (b<>15) then begin
    write(change(a),' ');
    c:=b div 10;
    if c=0 then begin
      down(change(b));
      writeln(t);
    end;
    if c=1 then begin
      if b>=13 then writeln(change(b));
      if b<13 then begin
        down(change(b));
        writeln(t);
      end;
    end;
    if (c<>0) and (c<>1) then begin
      write(change(c*10));
      if b mod 10<>0 then begin
        write('-');
        down(change(b mod 10));
        writeln(t);
      end;
      if b mod 10=0 then writeln;
    end;
  end;
  if b=45 then begin
    write('Quarter to ');
    c:=a+1;
    if c<=12 then begin
      down(change(c));
      writeln(t);
    end;
    if c>12 then begin
      down(change(c-12));
      writeln(t);
    end;
  end;
  if b>45 then begin
    c:=60-b;
    if c<=12 then write(change(c));
    if c>12 then begin
      t:=change(c);
      t[1]:=chr(ord(t[1])-32);
      write(t);
    end;
    write(' to ');
    c:=a+1;
    if c<=12 then begin
      down(change(c));
      writeln(t);
    end;
    if c>12 then begin
      down(change(c-12));
      writeln(t);
    end;
  end;
  close(input);  close(output);
end.

 

这道题其实也可以转化为贪心问题，就是text里面说的：假设我们的答案盖住了较大的空牛棚连续列，而不是较小的。那么我们把那部分盖空牛棚的木板锯下来，用来把较小的空牛棚连续列盖住，还会有剩余。那么锯掉它们！还给木材商！同时我们的解也变小了。也就是说，我们获得更优的解。所以，靠盖住较大空牛棚连续列的方法无法获得最优解，我们也应该尽量贪心那些距离小的木板合并。

如果仍有一个空牛棚连续列与我们的答案盖住的那个相同，我们同样使用上述的方法。会发现获得的新解与原解相同，那么不论我们选哪个，结果都将一样。

由此可见，如果我们合并的两块木板间距离最短，那么总能获得最优解。所以，在解题的每一步中，我们都只需要寻找两块距离最小的木板并合并它们。这样，我们获得的解必定最优。

程序如下:

{
ID:fanminj1
LANG:PASCAL
TASK:barn1
}
var
  m,s,c,t,temp,i,j:integer;
  a,d:array[1..200] of integer;
begin
  assign(input,'barn1.in');  reset(input);
  assign(output,'barn1.out');  rewrite(output);
  readln(m,s,c);
  for i:=1 to c do readln(a[i]);
  for i:=1 to c-1 do
    for j:=i+1 to c do
      if a[i]>a[j] then begin
        temp:=a[i];  a[i]:=a[j];  a[j]:=temp;
      end;
  for i:=1 to c-1 do d[i]:=a[i+1]-a[i]-1;
  for i:=1 to c-2 do
    for j:=i+1 to c-1 do
      if d[i]>d[j] then begin
        temp:=d[i];  d[i]:=d[j];  d[j]:=temp;
      end;
  t:=c;
  for i:=1 to c-m do t:=t+d[i];
  writeln(t);
  close(input);  close(output);
end.

典型的贪心问题

程序如下：

{
ID:fanminj1
LANG:PASCAL
TASK:milk
}
var
  n,sum,l:longint;
  m,temp,tempp,nn,i,j:integer;
  p:array[1..5000] of integer;
  a:array[1..5000] of longint;
begin
  assign(input,'milk.in');  reset(input);
  assign(output,'milk.out');  rewrite(output);
  readln(n,m);
  for i:=1 to m do readln(p[i],a[i]);
  for i:=1 to m-1 do
    for j:=i+1 to m do
      if p[i]>p[j] then begin
        temp:=p[i];
        p[i]:=p[j];
        p[j]:=temp;
        tempp:=a[i];
        a[i]:=a[j];
        a[j]:=tempp;
      end;
  sum:=0;  l:=0;  nn:=1;
  repeat
    sum:=sum+p[nn]*a[nn];
    l:=l+a[nn];
    inc(nn);
  until l>=n;
  sum:=sum-p[nn-1]*(l-n);
  writeln(sum);
  close(input);  close(output);
end.

 

这道题目在一开始的时候我走了点弯路，想去搜索判断，后来发现再怎么优化也超时。

其实应该是直接生成回文数，并且只需考虑位数是奇数的时候

程序如下：

{
ID:fanminj1
LANG:PASCAL
TASK:pprime
}
var
  a,b:longint;
function check(x:longint):boolean;
var
  c:longint;
begin
  check:=true;
  for c:=2 to trunc(sqrt(x)) do
    if x mod c=0 then begin check:=false; exit; end;
end;
procedure opa;
var
  i:byte;
begin
  for i:=5 to 11 do if ((i=5) or (i=7) or (i=11)) and ((i>=a) and (i<=b))
  then writeln(i);
end;
procedure opb;
var
  i,j:byte;
  t:integer;
begin
  for i:=1 to 9 do
    for j:=0 to 9 do begin
      t:=101*i+j*10;
      if check(t) and (t<=b) and (t>=a) then writeln(t);
    end;
end;
procedure opc;
var
  i,j,k:byte;
  t:longint;
begin
  for i:=1 to 9 do
    for j:=0 to 9 do
      for k:=0 to 9 do begin
        t:=10001*i+1010*j+100*k;
        if check(t) and (t<=b) and (t>=a) then writeln(t);
      end;
end;
procedure opd;
var
  i,j,k,l:byte;
  t:longint;
begin
  for i:=1 to 9 do
    for j:=0 to 9 do
      for k:=0 to 9 do
        for l:=0 to 9 do begin
          t:=1000001*i+100010*j+10100*k+1000*l;
          if check(t) and (t<=b) and (t>=a) then writeln(t);
        end;
end;
begin
  assign(input,'pprime.in');  reset(input);
  assign(output,'pprime.out');  rewrite(output);
  readln(a,b);
  if b>9999999 then b:=9999999;
  opa;
  opb;
  opc;
  opd;
  close(input);  close(output);
end.

 

因为数据量不大，所以可以枚举，在处理的时候仔细点就可以了

程序如下：

{
ID:fanminj1
LANG:PASCAL
TASK:beads
}
var
  n,maxpick,counter,i:integer;
  necklace:array[1..350] of char;
procedure check;
var
  lco,rco:char;
  l,r,pos:integer;
  b:boolean;
begin
  l:=0;  r:=0;
  if counter=n then pos:=1 else pos:=counter+1;
  rco:=necklace[pos];
  b:=false;
  repeat
    if (rco='w') and (necklace[pos]<>'w') then rco:=necklace[pos];
    if ((rco='r') and (necklace[pos]='b')) or ((rco='b') and (necklace[pos]='r'))
      then b:=true
      else inc(r);
    if r>=n then begin
      writeln(n); close(input); close(output); halt; end;  {全部同色}
    if pos=n then pos:=1 else inc(pos);
  until b;
  lco:=necklace[counter];
  pos:=counter;
  b:=false;
  repeat
    if (lco='w') and (necklace[pos]<>'w') then lco:=necklace[pos];
    if ((lco='r') and (necklace[pos]='b')) or ((lco='b') and (necklace[pos]='r'))
      then b:=true
      else inc(l);
    if r+l=n then begin
      writeln(n); close(input); close(output); halt; end;
    if pos=1 then pos:=n else dec(pos);
  until b;
  if l+r>maxpick then maxpick:=l+r;
end;
begin
  assign(input,'beads.in');  reset(input);
  assign(output,'beads.out');  rewrite(output);
  readln(n);
  for i:=1 to n do read(necklace[i]);
  maxpick:=0;
  for counter:=1 to n do check;  {counter代表断开点}
  writeln(maxpick);
  close(input);  close(output);
  halt;
end.

就是字符串的处理+统计，不多说了。

程序如下：

{
ID:fanminj1
LANG:PASCAL
TASK:gift1
}
var
  s,r,v:array[1..10] of string;
  m,t,a,b:array[1..10] of integer;
  i,j,k,l,n:integer;
begin
  assign(input,'gift1.in');  reset(input);
  assign(output,'gift1.out');  rewrite(output);
  readln(n);
  fillchar(a,sizeof(a),0);
  fillchar(b,sizeof(b),0);
  for i:=1 to n do readln(s[i]);
  for i:=1 to n do begin
    readln(r[i]);
    readln(m[i],t[i]);
    for l:=1 to n do if s[l]=r[i] then begin
      if t[i]<>0 then a[l]:=m[i]-(m[i] mod t[i])
                 else a[l]:=0;
      end;
    if t[i]<>0 then
      for j:=1 to t[i] do begin
        readln(v[j]);
        for k:=1 to n do if s[k]=v[j] then
          b[k]:=b[k]+m[i] div t[i];
      end;
  end;
  for i:=1 to n do writeln(s[i],' ',b[i]-a[i]);
  close(input);  close(output);
end.

{
ID:fanminj1
LANG:PASCAL
PROG:ride
}
var
  s,r:string;
  a,b,i:byte;
  c,d:longint;
begin
  assign(input,'ride.in');  reset(input);
  assign(output,'ride.out');  rewrite(output);
  readln(s);
  readln(r);
  a:=length(s);
  b:=length(r);
  c:=1;
  d:=1;
  for i:=1 to a do c:=c*(ord(s[i])-64);
  for i:=1 to b do d:=d*(ord(r[i])-64);
  if (c mod 47)=(d mod 47) then writeln('GO')
                           else writeln('STAY');
  close(input);  close(output);
end.

总体上觉得拍得太假，改编得有点过分，内容空洞

最终无非想说的就是这样一句话：尘世间最遥远的距离不是我站在你面前 却不知道我爱你 而是 明明知道彼此相爱 却不能在一起

个人认为相爱并不一定要在一起 让彼此都幸福快乐才是最重要的

计数器是比较实用的工具，你可以了解自己空间的受欢迎程度.

如果只是在日志中显示来访总数，那么申请一个简单的计数器即可，提供这种服务的网站很多，你在搜索引擎中键入“Free Web Counter”会查找到很多结果，这里我个人推荐http://www.amazingcounters.com/。这个网站提供350多种计数器，款式繁杂，花色多样，绝对满足你的需要。申请时需要注册，但过程很简单，一般只需要提供少量的个人信息即可。注册成功后你就可以选择心仪的计数器了，然后再输入你个人网站的信息，你将获得一段在线生成的HTML页面的代码。某些网站还会提供给你简单的在线编辑功能，让你进一步对计数器的外观作简单的修改，以更好的适合你的需要。将获取的代码拷贝，然后转到你需要插入计数器的MSN Space日志，进入HTML语法编辑状态，将刚才获取的代码粘贴到空白处，再退出HTML编辑状态，在日志文本处理模式下调整计数器的位置。由于MSN Space空间没有提供置顶功能，因此你必须经常调整计数器的位置，将它始终放置在首页的日志中（最好是第一篇日志）。方便起见，你可以将计数器的源代码拷贝到文本文件中，以后调整时将它简单粘贴过来就可以了。

 

 

 

 

             
                           Arizona Personals

他和她是大学的同学。四年，在一起有四年的时光。四年简简单单的光阴，四年无忧无虑的光阴。他是个高大的男孩，脸上永远挂着最灿烂的笑容。和所有的男孩一样，他粗心，会丢三落四；爱打篮球、爱睡懒觉、爱抱着吉他唱歌、爱和漂亮的师妹聊天。而她，是个平凡的细心的女孩，她爱做梦、爱幻想、爱看男生打篮球，爱远远的有些羞涩地给他们加油。  

　　他和她是最普通的朋友。见面仅仅点个头的朋友。但点头以后，她就会心跳，就会脸红。怎么了？她在心里问自己，我……喜欢他吗？她摇摇头，不承认自己的感情。她小心地封闭着自己的感情，小心地注视着自己的心里的王子。而他，丝毫也没有注意到。他有了一个漂亮的女朋友。是的，高高的他，不会注意平凡的她。  

　　故事开始在毕业前。那年的散伙饭，大家都像疯了一样；拼命地喝酒，拼命地唱歌。毕业有那么多的快乐，也有那么多的麻烦。他和女朋友终于分手了，毕业让他们分道扬镳。他不停和朋友们喝酒，为自己枯萎的恋情。她一个人，在一个角落，轻轻的为自己斟满了一杯酒。  
    她从不喝酒的，但这一次，她为自己倒了满满的一杯酒。在心里给自己鼓了鼓劲，她走向了他。“祝你前途无量”。她说的有点急促，她的心一直在跳。他可能根本没有看清眼前的她，端起酒杯就喝。酒精让他的眼睛朦胧了。他看着眼前这个平凡的模糊的影子，全乱了，世界全乱了。“是我的公主吗？”他醉了，醉意中的他一把抱住了她。而她，眼泪倾泄而出，为了这错误的拥抱。  

　　是的，是错的就是错的。大家很快就毕业了。这个热烈的拥抱，却留在了她的心里。这是她第一次倒在一个男孩的怀里，这是她暗暗爱慕了四年的王子呀。有这个就足够了，她静静地想。王子，只是经常出现在梦里。  

　　尽管在一个城市，但大家的联系机会并不多。他在IT界工作，她去了一家著名的通信公司。一年以后了，大家聚会。并不像小说里写的那样，很多同学仍然是独身。他偶然谈起自己很累。他忿忿地说资本主义剥削人，自己只是迟到一天，就被扣掉了一次FRIDAY’S的消费。  
    朋友们都说你这样的懒虫用闹钟是没有用的，闹钟会叫醒手指而不会叫醒大脑，只能有个好心人给一个MORNING CALL才行。一直默默无声的她突然说话了：让我叫你吧。他也惊异。她笑笑，我不用掏电话费而已。他释然了，好，谢谢。  

　　就这样，早上七点，他的手机就准时地响起。开始，她只是简单的说：早上好，起床吧。就这样，从夏天，到春天。他们的MORNING CALL的时间越来越长，从半分钟到十分钟。谈谈工作，谈谈天气。他总是谢她。而她刻意地躲开了。她怕他看透自己的心事。她知道他不会爱自己的，自己也没有必要认真。但她真的不认真吗？每天，六点四十她就会醒。再困她也不会睡着。因为她的心在跳个不行，就像大学时见到他一样。  

　　又一年过去了。大学的同学已经很少有联系了。而他和她，凭着MORNING CALL，竟然保持着每天一个电话的奇迹！但这个电话只是一个早上的问候，除了这个时间，他们几乎没有任何联系。可能，新年时，有了一张贺卡，他想请她吃饭，她拒绝了。保持着自己的秘密不说，  
    她觉得自己有一份骄傲。而她更加清楚，他不是自己的。就这样，他们用一个非常松懈的方法联系着。他们对彼此的生活并不了解。她病了。老是头痛。有一次她晕倒了，才知道，她得了脑瘤。万分之一的治愈可能。她在医院里。但她依然没忘自己的任务。每天，用自己的手机，拨通他的手机。听着那边的他模模糊糊的回答，她就安心了。她认真完成自己的任务，她也知道，这样的日子不多了。而他高大英俊的身影，一直是她最牵挂的东西。  

　　她的病越来越重了。她开始昏迷，她离死亡越来越近。有一种强力的针剂可以把她从昏迷中唤醒，她请求医生，在每天的清晨，给她用这种药。医生答应了，对一个垂死的人，没有什么不能答应。她依然打他的手机，用最快乐的声音，编制最可信的谎话。他好粗心，他什么都没有发觉。 

　他在IT界越做越好，人气渐旺。俨然成了中关村的知识英雄了。人们说他是个敬业守时的人。只有他的第一个老板知道，他爱迟到；只有他的同学知道，他是个懒鬼。他身边总是围绕着美丽的女孩，因为他分明是一个新贵！他会逢场作戏，但没有真心。其实他自己还不知道，每天清晨的那个手机，已经让他习惯。尽管他早就不需要那个MORNING CALL，但他没说，每天早上，他等着那个电话响起。他会问自己：我爱她吗？会娶她吗？不，他摇摇头，她实在太平凡了，没有一丝的眩目，我不要……但他也知道，他习惯了她，他不能过没有她的日子。可能，比较平凡的女孩比较遵守信约，他这样安慰自己。可是，这样的手机联络并不能持续很久。因为，因为，因为她必须走了。她昏迷的时间越来越长。她开始失约，开始没有MORNING CALL.他有些奇怪，但并没有追问，女孩，该有自己的生活。他有时还偷偷笑笑：和男朋友云雨后就给另一个男人打电话当然不好。男孩，都这么粗心吗？  

　　她的状况更差了。她在死亡的边缘。她的即将来临的死亡成了联系同学的信息；大量的同学来医院看她。他，终于也知道了这个消息。除了震惊他没有别的感觉。不是好好的吗？不是经常打MORNING CALL吗？尽管有时失约，但毕竟还是准时的呀。他认定她是急病。匆匆的买了一束黄玫瑰，赶往医院。他在心里认定她是他最好的朋友，黄玫瑰，代表友情。  


　　他去开自己的车。手机又响了。是不是她？他真的已经习惯了她。不是，这是一个美丽的娇柔的小姐给他的信息：一颗心。他打量着自己的诺基亚，这是一个可以传递图形的手机。两年来，他收到了无数的心、天使，但，没有收到她的。他突然站住了，一个从不说爱的女孩。他很轻易的就想起了她的手机号码，每天都看一遍的数字：13901120521.他念了一遍。一种晕眩的感觉在他的头顶铺开。她是统计和管理这些数字的，她可以为自己挑一个最适合的。原来，每天，她都会说521。想清楚这些，他几乎站不住了。整个世界都转了过来。每天，每天，每天。在那个固定的时刻。她温柔的声音会在这里传到他的耳边——  

　　“起床吧，别耽误了。”  

　　“要不，你再睡会，我十分钟后叫你？”  

　　“今天天冷，当心点。”  

　　后来胆子大了，她也会用开玩笑的语气说：想没想我？  
　  

　　不，不，不。他不能想了。他突然觉得自己是世界上最大的一个笨蛋。他觉得自己说什么也不能失去她。对，不能失去，这种不能失去的感觉，这种害怕失去的痛苦，原来就是爱。他什么也说不出来了。自己可以编出最简洁的程序，可以黑掉世界上任何一个网站，但却看不透一个平凡的女孩。她真的平凡吗？不，不，我要她！他没有办法自己开车了，他叫了TAXI.他要赶到她的身边去，对，带着爱去！在一家花店门口，他叫车停住。他扔下了黄玫瑰。“快，我要红玫瑰，999支！”一个小店，哪有这么多。殷勤的小姐配了99支。  

　　99支火红的热烈的欧洲来的玫瑰终于随着他来到了病房。她，在昏迷。几台机器在她身边，发出奇怪的声音，闪着奇怪的图象。他在门外，他和99朵玫瑰一起等，等待她的苏醒。她一定会活着。有我爱她，她会活着！他轻声的呼唤她，我在等你！她终于苏醒过来了。他冲了进来，还有，99朵玫瑰。他趴在了她的耳边，就像每天早上她叫他一样，让自己的声音轻轻的传如她的耳朵：我爱你。她已经完全变了样子。任何人都知道，平凡是对一个不好看的女孩比较客气的评价。是的，她不是漂亮的女孩。而病中的她，更不好看了。可对他来说，他需要什么呢？他不需要漂亮的女孩，他只要一个全心爱他的头脑！他爱她。  

　　脑瘤一直在压迫视神经，她实际上已经看不见什么了。他抓住了她的手，温柔的说：我现在没有钻戒，但我真诚地向你求婚。相信我！我只有99朵玫瑰。你是一个不平凡的女孩，你会喜欢玫瑰吗？我怕你不喜欢他们，但……在他眼里，她是那么与众不同，她会喜欢俗气的玫瑰吗？而他，曾经送给过很多人玫瑰呀。他不知道自己该说什么。这不是怜悯不是同情。他知道自己醒悟的太晚了，他知道其实自己早就爱上了她。她小小的柔软的手被握在了他纤细的冰冷的手中。“傻瓜，哪个女孩不喜欢玫瑰？”她颤抖着，说了一句。他把她的手贴在自己的脸上，喃喃的说：我们结婚时，要999朵玫瑰，不9999朵……她微笑着，又是昏迷。  

　　几天了，他一直陪在医院。他拒听了一切来电，他的手机只等着一个号码：13901120521.她有时清醒，有时沉睡。  

　　而清醒时她就说：真抱歉，我没有一直守约。  

　　他就握住她的小小的手，说我真的爱你，一直爱你，我等你。  

　　“这是我一生中最快乐的时光”“有你，我才幸福。”  

　　他不信这是最后的时光，他要把她唤回，他要她受约，他要她一辈子叫他起床。  

　　 这天她清醒的时间特长，似乎她又能看见东西了。但她几乎已经不能呼吸，她仍在清晨给了他一个微笑，一个最美的笑。但接着，就是剧烈的头痛和呕吐。仪器上显示她的颅内压已经相当高了。她快走了。而这种情形下，只有她，只有她自己可以体会这种痛苦。医生在诊断  
书上写下：“实行安乐死比较人道。”  

　　 当然不会，这是最幸福的时光，有他。  

　　好静。周围好静。已经是秋天了，树叶从枝头落下，铺满了小路。这是他们初相遇的季节。她望着他，想他们的故事。校园里的心跳，毕业时热烈的拥抱，看似无意的承诺，每天清晨让人又恨又怜的电话铃声，还有那玫瑰。她用眼神示意了一下。他从她的枕头下拿出了她的手机。他第一次见到这个每天叫他的手机。小巧的蓝色的手机，13901120521，他最喜欢的颜色，也是他最喜欢的型号——诺基亚。他掏出了自己的手机。一颗心，他郑重地传递给她一颗心。她微笑了。四周真的好静，只有手机键盘拨号的声音。她，第一次，为他打上了一颗心。  


　　她把自己的手机递到了他的面前，缓缓地闭上了眼睛。他拿过了两个手机，把他们挨在一起。屏幕上，那两颗心也靠在了一起 

柏拉图有一天问老师苏格拉到底甚么是爱情。

苏格拉底叫他到麦田走一次，不要回头地走在途中， 要摘一棵最大最好的麦穗， 

但只可以摘一次，柏拉图觉得很容易，充满信心地出去。

谁知过了半天他仍没有回去，最後，他垂头丧气出现在老师跟前诉说空手而回的原因 : 

很难得看见一株看似不错的，却不知是不是最好的，不得已，因为只可以摘一株， 

只好放弃再看看有没有更好的，到发现已经走到尽头时， 

才惊觉手上一棵麦穗也没有... 

这时，苏格拉底告诉他 : " 那就是爱情 "。