另一方面，写东西是为了有读者看，sina的读者大概是最多的吧（恕我孤陋寡闻）。

新地址在

http://blog.sina.com.cn/cxh757

至于这里的以后还会不会再更新，恐怕现在还没办法回答，感谢曾经的访客们的支持，再见。

无论考后考前，都没了从前的紧张与不安，下午独坐在福大赛场，闪过脑海的只有往昔的串串依恋

虽然福建并列第8在外人看起来很是好听，但我不清楚自己是否要的就是这个结局

或许它并不是个结局，而是开始

回程的公交上，看到了师大附中的男生的默默啜泣，我仿佛透视到了从前自己那颗同样脆弱的心

如果说OI除了省一和保送外还能带给你什么，那我觉得就是磨砺

或许我自出生起缺乏的就是坚强，太多的温文恭良让，太多的一帆风顺，心里少确了许多挫败后的结痂

脸上没有伤痕的剑客，大都是沽名钓誉的花花公子罢了

“十年磨一剑，霜刃未曾试，今朝把示君，谁有不平事？”

这真的是人生中一段不平凡的经历，我会永远记住它的

定义一条路径的瓶颈为该路径上的边的权值的最大值或最小值，最小最大问题就是求它的瓶颈

其一般动态模型为

Ｆ［Ｉ，Ｊ］＝ＭＩＮ（　Ｆ［Ｉ－１，Ｋ－１］+ＳＵＭ［Ｉ，Ｊ］　）

初值Ｆ［Ｉ，Ｊ］＝∞　Ｆ［０，０］＝０　ＳＵＭ［Ｉ，Ｊ］是把物品Ｉ到Ｊ分在一起的花费，它通常的时间复杂度是（Ｋ*Ｎ＾２）的

例题：

给定k个大小不同的灌木丛，它们因为霜冻需要保护。假定这些灌木丛按照大小排序，即灌木丛0是最小的，灌木丛k-1是最大的。这里把为灌木丛i制作覆盖层的花费记作ci。但是由于制造技术上的局限，最多只能制造n种不同大小的保护层，这里n＜＝k。较大的覆盖层能够保护较小的灌木丛。我们的目标是决策n个保护层的大小，使之能以最小的花费覆盖所有的灌木丛。

我们来看这样一个例子：有k = 10个灌木丛，每种大小的覆盖层的花费
为(c0; :::; c9) = 1; 4; 5; 7; 8; 12; 13; 18; 19; 21),且由于技术局限，只能制作n = 3种
大小的覆盖层。那么最佳的方案就是依次制造出大小为9,6,4的覆盖层(即使用大
小为9的覆盖层保护灌木丛9,8,7，用大小为6的覆盖层保护灌木丛6和5，用大小
为4的覆盖层保护灌木丛0至灌木丛4)，其总花费f(3; 9) = 129

program cov;
var c:array[0..10] of longint;
    f:array[0..3,0..10] of longint;
    i,j,k:longint;
begin
for i:=1 to 10 do read(c[i]);
fillchar(f,sizeof(f),$7f);
f[0,0]:=0;
for i:=1 to 3 do
for j:=i to 10 do
for k:=i to j do
if not((i=1)and(k<>1)) then
if f[i-1,k-1]+(j-k+1)*c[j]<f[i,j] then
f[i,j]:=f[i-1,k-1]+(j-k+1)*c[j];
writeln(f[3,10]) ;
end.

这类问题的花费通常定义为结点权值乘以结点所在深度

p0*level(x0)+p1*(level(x1))+…pn-1*(level(xn-1))　这里level(xi)表示数据项xi在树中对应节点的层数(深度)

它的动态模型与合并石子相当类似

Ｆ［Ｉ，Ｊ］＝ＭＩＮ（　Ｆ［Ｉ，Ｋ－１］+Ｆ［Ｋ+１，Ｊ］+ＳＵＭ［Ｉ，Ｊ］　）

初值Ｆ［Ｉ，Ｉ］＝Ａ［Ｉ］　Ｆ［Ｉ，Ｊ］＝∞（Ｉ＜Ｊ）　Ｆ［Ｉ，Ｊ］＝０　（Ｉ＞Ｊ）

ＳＵＭ［Ｉ，Ｊ］＝Ａ［Ｉ］+Ａ［Ｉ+１］+....+Ａ［Ｊ－１］+Ａ［Ｊ］..

表示中序遍历从Ｉ到Ｊ，以Ｋ为根结点的最优值，可以理解为当你决定将Ｆ［Ｉ，Ｋ－１］，Ｆ［Ｋ+１，Ｊ］两棵子树用Ｋ作根结点连起来时，子树的点都＂多了一层＂，因而花费要加上ＳＵＭ［Ｉ，Ｊ］

我们考虑这个问题的一个实例。我们有5个数据项，按字典序排列(A,B,C,D,E)其各自的搜索概率为(0.25,0.05,0.2,0.4,0.1)。这个例子的最优值是f(１,５)=1.9)，其对应的最优二叉搜索树如图所示。

    【题目描述】

    小k在遗迹探险时遇到了n个按钮，刚开始所有按钮都处于开状态，小k的经验告诉他把所有按钮都关上会有“好事”发生，可是有些按钮按下时会让其他一些已经闭合的按钮弹开。经过研究，每个按钮都对应着一个固定的弹开集合，这个按钮按下时，弹开集合中所有的按钮都会变为开状态。现在小k想知道是否能让所有的按钮变为闭状态。如果能，打印最少步数以及方案。否则，打“no solution"。

    【输入格式】

第一行一个整数n，表示n个按钮

接下来n行，表示编号为l到n个按钮 的弹开集合

    格式为mi，B1B2 B3…Bmi。

    表示编号为i的按钮按下，会让编号为B1B2 B3…Bmi 的按钮弹开(注：其中不会出现重 复)

    【输出格式】

    如果无解，输出"no solution"．

    否则，第一行输出最少步数ans，第二行输出用空格分开的ans个数，表示按顺序按下

编号为这些数的按钮就可以解决。

    如果有多种方案，输出字典序最小的方案。

    【样例输入】button.in

    6

    2 2 3

    0

    2 4 5

    0

    0

    0

    【样例输出】button.out

    6

    l 2 3 4 5 6

    【数据范围】

    l≤n≤30000

    令M=m1+m2+…+mn

    0≤M≤1000000

逆向思考，当按下最后一个按钮时，不能有任何按钮弹起

按下倒数第二个按钮时，最多让最后一个按钮弹起

按下倒数第三个按钮时，最多让后两个弹起

........................

按下第二个按钮时，不能让第一个弹起

按下第一个按钮时，可以让任何按钮弹起

明显必须按下Ｎ次按钮，且弹起的按钮必须在它之后按下

可以用拓扑排序生成序列

用堆优化，每次堆中的元素保证入度都为０，且堆首的元素编号最小

program fdfd;
var n,i,j,k,x,y:longint;
    b:array[1..30000,0..90] of longint;
    ru,ans:array[1..30000] of longint;
    vis:array[1..30000] of boolean;

    h:array[0..30000] of longint;
    size:longint;
procedure sdown;
var y,z,v:longint;
begin
     y:=1; z:=y*2; v:=h[1];
     while (z<=size) do
     begin
       if z<size then
       if h[z+1]< h[z] then z:=z+1;
       if h[z]>v then break;
       h[y]:=h[z]; y:=z; z:=y*2;
     end;
     h[y]:=v;
end;
procedure sink(p:longint);
var y,z,v:longint;
begin
    y:=p; z:=y div 2; v:=h[y] ;
    while (h[z]>v)and(z>=1) do
    begin
      h[y]:=h[z];
      y:=z; z:=y div 2;
    end;
    h[y]:=v;
end;
begin
assign(input,'button.in');assign(output,'button.out');
reset(input); rewrite(output);
fillchar(b,sizeof(b),0);
fillchar(ru,sizeof(ru),0);
readln(n);
for i:=1 to n do
begin
    read(x);
    for j:=1 to x do
    begin
       read(y);
       inc(b[i,0]) ;
       b[i,b[i,0]] :=y;
       inc(ru[y]);
    end;
    readln;
end;
size:=0;
for i:=1 to n do
if ru[i]=0 then
begin
    inc(size);
    h[size]:=i;
end;
fillchar(vis,sizeof(vis),false);
for i:=1 to n do
begin
    k:=h[1];
    if vis[k] then
      begin
        writeln('no solution');
        halt;
      end;
    vis[k]:=true;
    ans[i]:=k;
    h[1]:=h[size]; dec(size); sdown;
    for j:=1 to b[k,0] do
    if vis[b[k,j]] then
      begin
        writeln('no solution');
        halt;
      end
    else
    begin
    dec(ru[b[k,j]]);
    if ru[b[k,j]] =0 then
      begin
        inc(size) ;
        h[size]:=b[k,j];
        sink(size);
      end;
    end;
end;
writeln(n);
for i:=1 to n-1 do write(ans[i], ' ') ;
writeln(ans[n]);
close(input);
close(output);
end．

动规模型：

F[I,J]=MIN( F[I,K] + F[K+1,J] + VALUE[I,J] )

初值F[I,J]=∞ F[I,I]=0

或是

F[I,J]=MAX( F[I,K] + F[K+1,J]+VALUE[I,J] )

F[I,J]=0

I<=K<J,而VALUE是本次合并从I到J一段的值，它与之前是如何合并是无关的，且不一定是从I到J的累加（如能量项链）

循环时应从长度小的开始，比如

for i:=n-1 downto 1 do

for j:=i+1 to n do

for k:=i to j-1 do

f[i,j]=........

方程模型

F[I,J]=MIN( F[I,K]+F[K,J],F[I,J] ),初值F[I,J]=∞,F[I,J]=G[I,J](如果I,J两点读入时有直连的话)

I<>J<>K

注意K应放在最外重循环

如果F[I,J]用布尔型的话可以判断两者是否连通

这种类型的重要特征是分配价值与顺序无关

其方程模型一般是：

F[I,J]=MIN( F[ I-1, J-P[I] ]+W[I] )初值F[I,J]=∞,F[0,0]=0

F[I,J]=MAX( F[ I-1, J-P[I] ]+W[I] )初值F[I,J]=0

为防止越界J-P[I]应当>=0,P[I]为分配的花费，W[I]为分配所得的利益

而其最优值只与上一个有关，通常可在空间上优化降低维度

for i:=1 to n do

for j:=m downto 1 do

if j-p[i]>=0 then

if .........

f[j]:=f[j-p[i]]+w[i]

【问题描述】

刷完牙洗完脸，黄黄同学就要上课去了。可是黄黄同学每次去上课时总喜欢把校园里面的每条路都走一遍，当然，黄黄同学想每条路也只走一遍。我们一般人很可能对一些地图是办不到每条路走一遍且仅走一遍的，但是黄黄同学有个传送机，他可以任意地将一个、人从一个路口传送到任意一个路口。

可是，每传送一次是需要耗费巨大的内力的，黄黄同学希望可以用最少的传送次数完成游遍校园，你能帮助他吗?

因为黄黄同学只是游历校园，于是我们可以认为黄黄同学可以从任意点开始，到任意点结束。

【输入文件】

输入文件sent.in的第一行有一个整数N，表示黄黄的校园里一共有多少路口。

     第二行有一个整数M，表示路口之间有M条路。

后面M行每行两个整数a、b表示a与b之间有一条路，且路是双向的。

【输出文件】

    输出文件sent.out只包括一个整数s，表示黄黄同学最少的传送次数。

【样例输入】

    3

    2

    1     2

    2     3

【样例输出】

    0

【数据范围】

    对于100％的数据，保证N≤100000，K≤500000，1≤a，b≤N。

【时限】

    ls

题目的实质就是求最少添加几条边，使图能一笔画（欧拉路）

一个图能一笔画且最后回到起点的要求是奇点个数为０

而仅仅是一笔画，起讫点不同的要求是奇点个数为２

奇点个数一定是偶数

原先只统计奇点个数，没有考虑连通块的问题，做题还是不太认真，考虑没有全面

＂正规＂的做法是用链表存储，用ＢＦＳ统计连通块

program Jackchen;
type tree=^node;
     node=record
           val:longint;
           link:tree;
           end;
var n,m,i,j,x,y,t,v,s,cv:longint;
    c:array[1..100000] of tree;
    team,num:array[1..100000] of longint;
    vis:array[1..100000] of boolean;
    h,d:longint;
    ttree:tree;
    tot1,tot,ans:longint;
procedure insert(a,b:longint);
var ttree:tree;
begin
    new(ttree);
    ttree^.val:=b;
    ttree^.link:=c[a];
    c[a]:=ttree;
end;
begin
assign(input,'sent.in');assign(output,'sent.out') ;
reset(input); rewrite(output);
fillchar(num,sizeof(num),0) ;
readln(n); readln(m);
for i:=1 to m do
begin
    readln(x,y);
    if x=y then continue;
    insert(x,y);
    insert(y,x);
    inc(num[x]) ; inc(num[y]);
end;
fillchar(vis,sizeof(vis),true);
ans:=0; tot1:=0;
for i:=1 to n do
if vis[i] then
begin
h:=0; d:=1;
team[1]:=i; vis[i]:=false; tot:=0;
if odd(num[i]) then inc(tot);
repeat
    inc(h); v:=team[h]; ttree:=c[v];
    while ttree<>nil do
      begin
        cv:=ttree^.val;
        if vis[cv] then
          begin
            vis[cv]:=false;
            inc(d);
            team[d]:=cv;
            if odd(num[cv]) then inc(tot);
          end;
        ttree:=ttree^.link;
      end;
until h>=d;
if d<=1 then continue;
inc(tot1);
if tot>2 then ans:=ans+(tot-2)div 2;
end;
ans:=ans+tot1-1;
writeln(ans);
close(input); close(output);
end.
结果老师的评测能过，机房的celeron 1.7G超了

感谢林宇鹏大牛提供的并查集思路，原先我还担心递归会堆栈溢出（Ｎ＝１０００００），结果给出的数据全部能秒过

program fdfdf;
var n,i,j,m,x,y,f1,f2,tot1,ans:longint;
    f,num,oddn,c:array[1..100000] of longint;

function dfs(v:longint):longint;
begin
    if v<>f[v] then f[v]:=dfs(f[v]);
    dfs:=f[v];
end;

begin
assign(input,'sent.in');assign(output,'sent.out');
reset(input); rewrite(output);
readln(n);
readln(m);
fillchar(c,sizeof(c),0);
for i:=1 to n do f[i]:=i;
for i:=1 to m do
begin
readln(x,y);
if x=y then continue;
f1:=dfs(x); f2:=dfs(y);
if f1<>f2 then
f[f1]:=y;
inc(c[x]); inc(c[y]);
end;
fillchar(num,sizeof(num),0) ;
fillchar(oddn,sizeof(oddn),0);
for i:=1 to n do
begin
f1:=dfs(i);
inc(num[f1]);
if odd(c[i]) then inc(oddn[f1]);
end;
tot1:=0; ans:=0;
for i:=1 to n do
if num[i] >1 then
begin
if oddn[i]>2 then
ans:=ans+(oddn[i]-2) div 2;
inc(tot1);
end;
writeln(ans+tot1-1);

close(input); close(output);
end.

【问题描述】

    众所周知，黄黄同学早晨起来是要刷牙的。

    黄黄同学有N支牙刷，又有N个牙刷套,开始的时候，一支牙刷对应放在一个牙刷套中。可是有一天，黄黄同学把所有牙刷套里的牙刷都拿出来，玩了一会儿，他又要把所有的牙刷都放回去。可是，他忽然一想，我可不可以使得没有任何一支牙刷放回它原来的牙刷套里面呢?

    黄黄同学努力试了很久，却一直没有成功过一次。于是他断定这个要求是无法达成的，你怎么认为的呢?

【输入文件】

    输入文件put.in只包括一个整数N，表示牙刷和牙刷套的总数。

【输出文件】

    输出文件put.out，如果存在满足要求的方法，输出放法方案总数L。因为方案总数可能比较大，所以你可以将答案Mod 1206后再输出。如果不存在满足要求的方法，则输出"No Solution!”

【样例输入】

    3

【样例输出】

    2

【数据范围】

    对于40％的数据，保证N≤9

    对于100％的数据，保证N≤100000

    【时限】

    ls

很容易看出它就是错位排列，用通项公式明显不适用，应使用递推式

Ｆ［Ｉ］＝（Ｉ-１）*（Ｆ［Ｉ－１］+Ｆ［Ｉ－２］）

证明：*　　*　*　　*　*　　*....

　　　１　２　３　４　５　６....

假设现在Ｉ＝６，第６位上有５种选择（Ｉ－１），比如在第６位上放的是３，如果第３位上又被６占据，那么剩下的４位自行错位排列有Ｆ［４］种方案（Ｆ［Ｉ－２］），可以把这种情况视为３＼６原先各在其位，其余４位错位，而后３/６互换

如果如果没有出现３＼６相互占据的情况，说明３不在第３位上，３＼６互换前，前５位已错位排序讫，那么就有Ｆ［５］种情况，互换后依然满足错位，方案数也是Ｆ［Ｉ－１］

所以Ｆ［Ｉ］＝（Ｉ－１）*（Ｆ［Ｉ－１］+Ｆ［Ｉ-２］）

边界Ｆ［２］＝１　Ｆ［３］＝２

Ｎ＝０或Ｎ＝１无解

program fgdfdfd;
var n,i,j:longint;
    f:array[1..100000]of longint;
begin
assign(input,'put.in');assign(output,'put.out') ;
reset(input); rewrite(output);
fillchar(f,sizeof(f),0);
f[2]:=1 ; f[3]:=2;
readln(n);
if n in [0..1] then writeln('No Solution!')
else
begin
for i:=4 to n do
f[i]:=((i-1)*(f[i-1] +f[i-2] )) mod 1206;
writeln(f[n]) ;
end;
close(input); close(output);
end.

一些学校连接在一个计算机网络上。学校之间存在软件支援协议。每个学校都有它应支援的学校名单（学校a支援学校ｂ，并不表示学校ｂ一定支援学校a）。当某校获得一个新软件时，无论是直接得到还是网络得到，该校都应立即将这个软件通过网络传送给它应支援的学校。因此，一个新软件若想让所有连接在网络上的学校都能使用，只需将其提供给一些学校即可。

子任务a：

请编一个程序，根据学校间支援协议（各个学校的支援名单），计算最少需要将一个新软件直接提供给多少个学校，才能使软件通过网络被传送到所有学校。

子任务ｂ：

如果允许在原有支援协议上添加新的支援关系。则总可以形成一个新的协议，使得此时只需将一个新软件提供给任何一个学校，其他所有学校就都可以通过网络获得该软件。编程计算最少需要添加几条新的支援关系。

输入数据：

第一行是一个正整数ｎ（２≤ｎ≤１００），表示与网络连接的学校总数，随后ｎ行分别表示每个学校要支援的学校，即：i+1行表示第i号学校要支援的所有学校代号，最后０结束。如果一个学校不支援任何其他学校，相应行则会有一个０。一行中若有多个数字，数字之间以一个空格分隔。

输出数据：

包含两行，第一行是一个正整数，表示子任务a的解，第二行也是一个正整数，表示子任务ｂ的解。

【输入样例】network.in

5

2 4 3 0

4 5 0

0

0

1 0

【输出样例】network.out

1

2

先将强连通分量收缩成点,对于第一问,统计入度为0的点即可,第二问,分别统计入度为0的个数与出度为0的个数,取最大值即可,因为要使图全连通,入度为0的必须有入度,出度为0的必须有出度,才能使任意一个点到达其他任何点(除了全图只有1个点的特殊情况)

将强连通分量收缩成点使用两遍深搜的Kosaraju算法.

对于一个图中的连通分量来说,它的逆图中这个连通分量依然存在,第二次DFS时依然要按上次的顺序

收缩时需重新构图

program fdfdf;
var n,i,j,x,l:longint;
    a,g,a1:array[1..100,0..100] of longint;
    b,t:array[1..100] of longint;
    ans1,ans2,d1,d2:longint;

procedure dfs(v:longint);
var i1:longint;
begin
    b[v]:=1;
    for i1:=1 to a[v,0] do
    if b[a[v,i1]]=0 then
      dfs(a[v,i1]);
    inc(l);
    t[l]:=v;
end;

procedure dfs1(v:longint);
var i1:longint;
begin
    b[v]:=l;
    for i1:=1 to a1[v,0] do
    if b[a1[v,i1]]=0 then
      dfs1(a1[v,i1]);
end;

begin
assign(input,'network.in');assign(output,'network.out');
reset(input); rewrite(output);
readln(n);
fillchar(a,sizeof(a),0);
fillchar(g,sizeof(g),0);
for i:=1 to n do
begin
    read(x);
    while x<>0 do
      begin
        inc(a[i,0]);
        a[i,a[i,0]]:=x;
        inc(a1[x,0]);
        a1[x,a1[x,0]]:=i;
        read(x);
      end;
    readln;
end;
fillchar(b,sizeof(b),0); l:=0;
for i:=1 to n do
if b[i]=0 then
    dfs(i);
fillchar(b,sizeof(b),0); l:=0;
for i:=n downto 1 do
if b[t[i]]=0 then
    begin
    inc(l);
    dfs1(t[i]);
    end;
for i:=1 to n do
for j:=1 to a[i,0] do
g[ b[i] , b[a[i,j]] ]:=1;

ans1:=0;
for i:=1 to l do
begin
    d1:=0;
    for j:=1 to l do
    if i<>J then
    if g[j,i]=1 then
      begin
        d1:=1;
        break;
      end;
    if d1=0 then inc(ans1);
end;
writeln(ans1);
ans2:=0; d2:=0;
for i:=1 to l do
    begin
      d1:=0;
      for j:=1 to l do
      if i<>j then
      if g[i,j] =1 then begin d1:=1; break; end;
      if d1=0 then
      inc(d2);
    end;
ans2:=d2; d2:=0;
for i:=1 to l do
begin
    d1:=0;
    for j:=1 to l do
    if i<>j then
      if g[j,i] =1 then begin d1:=1; break; end;
    if d1=0 then
    inc(d2);
end;
if d2>ans2 then ans2:=d2;
if l=1 then writeln(0)
else writeln(ans2);
close(input); close(output);
end.

图例:
　　__
___|....|
......|....|

0    1  
在一个铺好的图形中,第i行和第i+1行的图案可以用x,y两个数表示,我们可以定义x,y相对应.y在i+1,x在i.若y的对应数是x1,x2 ,x3.....xn

则方程可以是f[i+1,y]=f[i,x1]+f[i,x2]+f[i,x3]+....+f[i,xn];

x和y的所有对应关系可以用搜索出来

program jk_domino;
var n,m,p,te,i,j:longint;
    a:array[1..1000,1..2] of longint;
    f:array[0..10000,0..32] of longint;

procedure doit(k,x,y:longint);
begin
    if k>m then exit;
    if k=m then
      begin
        inc(te);
        a[te,1]:=x; a[te,2]:=y;
        exit;
      end;
    doit(k+2,x shl 2,y shl 2);{连续在两层放上横的骨牌}
    doit(k+1,x shl 1,(y shl 1)or 1);｛一层竖着放｝
    doit(k+1,(x shl 1)or 1,y shl 1);　｛另一层竖着放｝
end;

begin
readln(n,m,p);
te:=0;
doit(0,0,0);
f[0,0]:=1;
for i:=1 to n do
for j:=1 to te do
f[i,a[j,2]]:=(f[i,a[j,2]]+f[i-1,a[j,1]]) mod p;

writeln(f[n,0] mod p);
end.

搜索构造过程中的三种情况分别是
1:
.__
|__|
|__|

0 0
0 0

y shl 2
x shl 2

2:
_____
__| .. |
__|__|

　　...0
　　...1

　　 y shl 1
　　( x shl 1 )or 1

3:....__
___| .. |
___|__|
____._|
　　
　　...1
　　...0

　　 (y shl 1)or 1
　　 x shl 1