格式
EXAMPLE

考虑下面的方格，它表示农夫约翰的农场，‘.'表示没有树的方格，‘#'表示有树的方格

          1 2 3 4 5 6 7 8
       1 . . . . . . . .
       2 . # . . . # . .
       3 . . . . . . . .
       4 . . . . . . . .
       5 . . . . . . . .
       6 . . # . . . . .
       7 . . . . . . . .
       8 . . . . . . . .

最大的牛棚是 5 x 5 的，可以建造在方格右下角的两个位置其中一个。

PROGRAM NAME: bigbrn
INPUT FORMAT
Line 1: 两个整数： N （1 <= N <= 1000），农场的大小，和 T （1 <= T <= 10，000）有树的方格的数量

Lines 2..T+1: 两个整数（1 <= 整数 <= N), 有树格子的横纵坐标

OUTPUT FORMAT
输出文件只由一行组成，约翰的牛棚的最大边长。

SAMPLE INPUT (file bigbrn.in)
8 3
2 2
2 6
6 3

SAMPLE OUTPUT (file bigbrn.out)
5

【参考程序】：

你要写一个程序计算，根据协议，为了让网络中所有的学校都用上新软件，必须接受新软件副本的最少学校数目（子任务 A）。更进一步，我们想要确定通过给任意一个学校发送新软件，这个软件就会分发到网络中的所有学校。为了完成这个任务，我们可能必须扩展接收学校列表，使其加入新成员。计算最少需要增加几个扩展，使得不论我们给哪个学校发送新软件，它都会到达其余所有的学校（子任务 B）。一个扩展就是在一个学校的接收学校列表中引入一个新成员。

格式
PROGRAM NAME: schlnet
INPUT FORMAT输入文件的第一行包括一个整数 N：网络中的学校数目（2 <= N <= 100）。学校用前 N 个正整数标识。接下来 N 行中每行都表示一个接收学校列表（分发列表）。第 i+1 行包括学校 i 的接收学校的标识符。每个列表用 0 结束。空列表只用一个 0 表示。

OUTPUT FORMAT
你的程序应该在输出文件中输出两行。第一行应该包括一个正整数：子任务 A 的解。第二行应该包括子任务 B 的解。

SAMPLE INPUT (file schlnet.in)
5
2 4 3 0
4 5 0
0
0
1 0

SAMPLE OUTPUT (file schlnet.out)
1
2

分析：(转byvoid)

  这是一道收缩强连通分量的题。

该题描述的是一个有向图。我们都知道，在一个有向图强连通分量中从任意一个顶点开始，可以到达强连通分量的每个顶点。由此可以把该题中所有强连通分量收缩成分别一个顶点，则入度为0的顶点就是最少要接受新软件副本的学校。

第二问就是，问至少添加多少条边，才能使原图强连通。也就问在收缩后的图至少添加多少条边，才能使之强连通。

可以知道，当存在一个顶点入度为0或者出度为0的时候，该图一定不是强连通的。为了使添加的边最少，则应该把入度为0顶点和出度为0的顶点每个顶点添加1条边，使图中不存在入度为0顶点和出度为0的顶点。

当入度为0的顶点多于出度为0的顶点，则应添加的边数应为入度为0的顶点的个数。当出度为0的顶点多于出入度为0的顶点，则应添加的边数应为出度为0的顶点的个数。

这样就可以解决问题了。但是不要忘了还有特殊的情况，当原图本身就是强连通分量时，收缩成一个顶点，该顶点入度和出度都为0，但第一问应为1，第二问应为0。

求强连通分量，我用的两遍深搜的Kosaraju算法，时间复杂度为O(n)。把找到的每个强连通分量收缩为一的顶点，组成新图。设r(x)为x所在的强连同分量的代表节点，如果原图中存在边e(x,y)，那么新图中有边e(r(x),r(y)) 。然后根据点的邻接关系统计出度和入度即可。

【参考程序】：

创建一个新窗体
将窗体置顶
将窗体置底
删除一个窗体
输出窗体可见部分的百分比（就是，不被其它窗体覆盖的部分）。

在输入文件中，操作以如下的格式出现。

创建一个新窗体：w(I,x,y,X,Y)
将窗体置顶： t(I)
将窗体置底： b(I)
删除一个窗体：d(I)
输出窗体可见部分的百分比：s(I)

I 是每个窗体唯一的标识符，标识符可以是 'a'..'z', 'A'..'Z' 和 '0'..'9' 中的任何一个。输入文件中没有多余的空格。

（x,y）和（X,Y）是窗体的对角。当你创建一个窗体的时候，它自动被“置顶”。你不能用已经存在的标识符来创建窗体，但是你可以删除一个窗体后再用已删除窗体的标识符来创建窗体。坐标用正整数来表示，并且所有的窗体面积都不为 0（x <> X 且 y <> Y）。x 坐标和 y 坐标在 1 —— 32767 的范围内。

格式
PROGRAM NAME: window
INPUT FORMAT
输入文件包含给你的解释程序的一系列命令，每行一个。当输入文件结束时，停止程序。

OUTPUT FORMAT
只对于 s() 命令进行输出。当然，输入文件可能有许多 s() 命令(不超过500次)，所以输出文件应该是一个百分比的序列，每行一个，百分比是窗体可见部分的百分比。百分比应该四舍五入到三位小数。

SAMPLE INPUT (file window.in)
w(a,10,132,20,12)
w(b,8,76,124,15)
s(a)

SAMPLE OUTPUT (file window.out)
49.167

【参考程序】：

农夫约翰总是很节约。他现在在奶牛五金商店购买一些桶，用来从他的巨大的牛奶池中量出 Q 夸脱的牛奶。每个桶的价格一样。你的任务是计算出一个农夫约翰可以购买的最少的桶的集合，使得能够刚好用这些桶量出 Q 夸脱的牛奶。另外，由于农夫约翰必须把这些桶搬回家，对于给出的两个极小桶集合，他会选择“更小的”一个，即：把这两个集合按升序排序，比较第一个桶，选择第一个桶容积较小的一个。如果第一个桶相同，比较第二个桶，也按上面的方法选择。否则继续这样的工作，直到相比较的两个桶不一致为止。例如，集合 {3，5，7，100} 比集合 {3，6，7，8} 要好。

为了量出牛奶，农夫约翰可以从牛奶池把桶装满，然后倒进瓶子。他决不把瓶子里的牛奶倒出来或者把桶里的牛奶倒到别处。用一个容积为 1 夸脱的桶，农夫约翰可以只用这个桶量出所有可能的夸脱数。其它的桶的组合没有这么方便。

计算需要购买的最佳桶集，保证所有的测试数据都至少有一个解。

格式
PROGRAM NAME: milk4
INPUT FORMAT
Line 1: 一个整数 Q

Line 2: 一个整数P（1 <= P <= 100），表示商店里桶的数量

Lines 3..P+2: 每行包括一个桶的容积（1 <= 桶的容积 <= 10000）

OUTPUT FORMAT
输出文件只有一行，由空格分开的整数组成：

为了量出想要的夸脱数，需要购买的最少的桶的数量，接着是：

一个排好序的列表（从小到大），表示需要购买的每个桶的容积

SAMPLE INPUT (file milk4.in)
16
3
3
5
7

SAMPLE OUTPUT (file milk4.out)
2 3 5

分析：
   此题用的是DFSID的解法，对于每次DFSID我们都找出组合为1个桶，2个，3个.....P个，每次用前面选的一层层的叠上去，对于每次找出的组合我们都去Judge，再用一个完全背包(原话：每个桶至少用一次)来判断每次组合是否完成Q的量取,answer就是达到Q那组----因为在读入数据时我就加了一个从小到大的快排，所以DFS出来的顺序已经是达到了题目要求，所以直接输出即可。

    背包的状态方程：bo[j]=bo[j] or bo[j-v[used[i]]](1<=i<=V,v[used[i]]<=j<=Q)
                   used[i]:第i个桶的容积。
    初始化：bo全部都是false，bo[0]=true

   此处的背包循环了很多没有用到的冗余次数，如果不加优化有一组过不了，所以背包有一些优化。
   优化：对于每次的组合都有i=1......Q/v[used[1]],则bo[i*v[used[1]]]=true,其它的状态都可以有前面的推出。

【参考程序】：

农夫约翰的牧场上有五种奶牛（括号内的是缩写）：格恩西奶牛（A），泽西奶牛（B），赫里福奶牛（C），黑安格斯奶牛（D），朗赫恩奶牛（E）。这些奶牛群放养在一片 16 英亩的牧场上，每英亩上都有一小群奶牛，像下面这样排列成 4 x 4 的格子（用行和列标号）：

  1 2 3 4
+-------
1|A B A C
2|D C D E
3|B E B C
4|C A D E

最初，牧场上的奶牛群总共有 3 群 A，3 群 B，4 群 C，3 群 D，3 群 E。今年的 D 种小奶牛比去年多一群 ，C 种少一群，共有 3 群 A，3 群 B，3 群 C，4 群 D，3 群 E。

农夫约翰对于他牧场上的奶牛群的布局非常小心。这是因为如果同一种类型的奶牛群靠得太近，她们就乱来：她们聚集在栅栏边上抽烟，喝牛奶。如果她们在相同的格子上或者在临近的 8 个格子上，就是靠得太近了。

农夫约翰得用他的棕色旧福特皮卡把他的大奶牛群运出牧场，并把他的小奶牛群运进牧场，皮卡一次只能运一群奶牛。他装上一群小奶牛，开车到小牧场的一个方格中，卸下这群小奶牛，再装上这个格子上的那群大奶牛，开到北纬 40 度的大牧场卸下来。他重复这样的操作 16 次，然后开车去杰克商店办理低脂酸奶的交易和家居装修。

帮助农夫约翰。他必须选择正确的顺序来替换他的奶牛群，使得他从不把一群小奶牛放入当前被同样类型奶牛占有的方格或者当前被同样类型奶牛占据的方格的临近方格。当然，一旦大奶牛走了，小奶牛就被安置好（in place），他必须小心以后的情况，要根据新的排列把奶牛群分开。

非常重要的提示：农夫约翰从过去的经验知道，他必须先移动 D 种奶牛群。

找出农夫约翰将他的小奶牛搬迁到她们的新牧场上的办法。输出 16 个连续的 奶牛群类型/行/列 的信息，使得这样的安排能够符合安全经验。

计算 4 x 4 牧场的最终排列总数和产生那些排列的方式的总数。

格式
PROGRAM NAME: wissqu
INPUT FORMAT
四行，每行四个字母，表示奶牛群。

OUTPUT FORMAT
16 行，每行分别由奶牛群类型/行/列组成。如果有多解（一定有），那么你应该输出奶牛群类型按照字典序排列在最前面的那个解。如果不只一个解满足条件，那么你应该输出行信息按照字典需排列在最前面的那个解。如果仍然不只一个解满足条件，那么你应该输出列信息按照字典序排列在最前面的那个解。

最后多输出一行，包含能够由这个排列方式产生的排列的总数。

SAMPLE INPUT (file wissqu.in)
ABAC
DCDE
BEBC
CADE

SAMPLE OUTPUT (file wissqu.out)
D 4 1
C 4 2
A 3 1
A 3 3
B 2 4
B 3 2
B 4 4
E 2 1
E 2 3
D 1 4
D 2 2
C 1 1
C 1 3
A 1 2
E 4 3
D 3 4
14925

对于每段电网都必须从电源拉出一条电线。电线可以穿过其他电网或者跨过其他电线。电线能够以任意角度铺设，从电源连接到一段电网的任意一点上（也就是，这段电网的端点上或者在其之间的任意一点上）。这里所说的“一段电网”指的是呈一条线段状的电网，并不是连在一起的几段电网。若几段电网连在一起，那么也要分别给这些电网提供电力。

已知所有的 F（1 <= F <= 150）段电网的位置（电网总是和坐标轴平行，并且端点的坐标总是整数，0 <= X,Y <= 100）。你的程序要计算连接电源和每段电网所需的电线的最小总长度，还有电源的最佳坐标。

电源的最佳坐标可能在农夫约翰的农田中的任何一个位置，并不一定是整数。

格式
PROGRAM NAME: fence3
INPUT FORMAT
第一行包括 F ——电网的数量。下面的 F 行每行包括两个 X，Y 对，表示这段电网的两个端点。

OUTPUT FORMAT
只有一行，输出三个浮点数，相邻两个之间留一个空格。假定你的电脑的输出库会正确地对小数进行四舍五入。

这三个数是：
电源最佳坐标的 X 值，电源最佳坐标的 Y 值，和需要的电线的总长度（要最小）。

SAMPLE INPUT (file fence3.in)
3
0 0 0 1
2 0 2 1
0 3 2 3

SAMPLE OUTPUT (file fence3.out)
1.0 1.6 3.7

【参考程序】：

  A B C D E F G H
1 S . . . . . # .
2 . . . . # . . .
3 . . . . . . . .
4 . . . . . . . .
5 . . . . . # . .
6 # . . . . . . .
7 . . . . . . . .
8 . . . . . . . .

萨丽总是垂直（向上或者向下）或水平（向左或者向右）地走。她可以从出发地（总是记作 A1 ）向下或者向右走。一旦萨丽选定了一个方向，她就会一直走下去。如果她遇到棋盘边缘或者路障，她就停下来，并且转过 90 度。她不可能离开棋盘，或者走进路障当中。并且，萨丽从不跨过她已经经过的格子。当她再也不能走的时候，她就停止散步。

这里是上面的棋盘上的一次散步路线图示：

A B C D E F G H
1 S---------+ # .
2 . . . . # | . .
3 . . . . . | . .
4 . . . . . +---+
5 . . . . . # . |
6 # . . . . . . |
7 +-----------+ |
8 +-------------+

萨丽向右走，再向下，向右，向下，然后向左，再向上，最后向右走。这时她遇到了一个她已经走过的格子，她就停下来了。但是，如果她在 F5 格遇到路障后选择另外一条路——向我们看来是左边的方向转弯，情况就不一样了。

你的任务是计算并输出，如果萨丽聪明地选择她的路线的话，她所能够经过的最多格子数。

格式
PROGRAM NAME: snail
INPUT FORMAT
输入的第一行包括 N ——棋盘的大小，和 B ——路障的数量（1 <= B <= 200）。接下来的 B 行包含着路障的位置信息。下面的样例输入对应着上面的示例棋盘。下面的输出文件表示问题的解答。注意，当 N 〉26 时，输入文件就不能表示 Z 列以后的路障了。

OUTPUT FORMAT
输出文件应该只由一行组成，即萨丽能够经过的最多格子数。

SAMPLE INPUT (file snail.in)
8 4
E2
A6
G1
F5

SAMPLE OUTPUT (file snail.out)
33

样例说明

A B C D E F G H
1 S . . . . . # .
2 | . . . # . . .
3 | . . . +-----+
4 | . . . | . . |
5 +-------+ # . |
6 # . . . . . . |
7 +------------ |
8 +-------------+

【参考程序】：

许多作曲家围绕一个重复出现的“主题”来构建乐曲。在我们的乐曲表示法中，“主题”是整个音符序列的一个子串，它需要满足如下条件：

⒈长度至少为5个音符

⒉在乐曲中重复出现(可能经过转调，见下)

⒊重复出现的同一主题不能有公共部分。

“转调”的意思是主题序列中每个音符都被加上或减去了同一个整数值。给定一段乐曲，计算其中最长主题的长度(即音符数)。

本题时限为1秒钟!

格式
PROGRAM NAME: theme
INPUT FORMAT
输出文件的第一行包含整数N。下面的每一行(最后一行可能除外)包含20个整数，表示音符序列。最后一行可能少于20个音符。

OUTPUT FORMAT
输出文件应只含一个整数，即最长主题的长度。如果乐曲中没有主题，那么输出0。

SAMPLE INPUT (file theme.in)
30
25 27 30 34 39 45 52 60 69 79 69 60 52 45 39 34 30 26 22 18
82 78 74 70 66 67 64 60 65 80

SAMPLE OUTPUT (file theme.out)
5

(这个长度为5的主题是输入文件中第一行的最后5个音符和第二行开头5个音符)

分析：
   时间复杂度也只有O(n2)。但是要在对第一种算法比较深入分析的基础上才可以得出。显然，一个序列最多只需要一个匹配序列即可，所以我们只需找到这样两个序列。两层循环，外层循环枚举两个序列开头的位置差（其实也就是每个元素与另一个序列对应元素的位置差），内层循环枚举第一个序列的第一个元素的位置。如果当前位匹配则当前长度加1，否则赋为1。这样，我们可以直接找出合法的序列，并记录最大长度。这种算法抓住了问题的本质，比第一种算法无论在时间上还是编程复杂度上都降低了不少。

或者动态规划

令theme(i,j)表示第一个主题开头为i，第二个主题开头为j所能构成的重复主题的长度

那么有转移方程：

如果note(i+1)-note(i)=note(j+1)-note(j)，则theme(i,j)=them(i+1,j+1)+1,否则theme(i,j)=1(深刻啊)

【参考程序】：

图1 相似的八个星座

夜空可以表示为一份天体图(sky map)，它是一个由字符0和1组成的二维矩阵，字符1表示所在的位置有一颗星；字符0表示该位置上没有星。任务给定一份天体图，用同一个小写英文标识(mark)相似的所有星座。相似的星座必须用相同的字母标识，不同的星座表示为不同的字母。标识一个星座，就是将其中各星体对应的字符1替换为相应的小写字母。

INPUT FORMAT
文件的前两行分别记录了天体图的宽度W、深度H。而天体图则是由接下来的H行表示，每行包括W个字符。

OUTPUT FORMAT
输出文件记录了天体图与文件STARRY.IN相似，不同之处在于，各个星座按照“任务”中的要求进行了标识(mark)。
SAMPLE INPUT (file starry.in)
23
15
10001000000000010000000
01111100011111000101101
01000000010001000111111
00000000010101000101111
00000111010001000000000
00001001011111000000000
10000001000000000000000
00101000000111110010000
00001000000100010011111
00000001110101010100010
00000100110100010000000
00010001110111110000000
00100001110000000100000
00001000100001000100101
00000001110001000111000

SAMPLE OUTPUT (file starry.out)
a000a0000000000b0000000
0aaaaa000ccccc000d0dd0d
0a0000000c000c000dddddd
000000000c0b0c000d0dddd
00000eee0c000c000000000
0000e00e0ccccc000000000
b000000e000000000000000
00b0f000000ccccc00a0000
0000f000000c000c00aaaaa
0000000ddd0c0b0c0a000a0
00000b00dd0c000c0000000
000g000ddd0ccccc0000000
00g0000ddd0000000e00000
0000b000d0000f000e00e0b
0000000ddd000f000eee000

这是上述输入实例的一个可能的结果。请注意，该输出文件对应于下面的天空景象。

Constraints
0 <= W (天体图的宽度) <= 100
0 <= H (天体图的深度) <= 100
0 <= 星座的数目 <= 500
0 <= 不相似的星座数目 <= 26 (a..z)
1 <= 各星座包含的星体数目 <= 160


【参考程序】：

格式
PROGRAM NAME: fc
INPUT FORMAT

输入数据的第一行包括一个整数 N。N（0 <= N <= 10,000）表示农夫约翰想要围住的放牧点的数目。接下来 N 行，每行由两个实数组成，Xi 和 Yi,对应平面上的放牧点坐标（-1,000,000 <= Xi,Yi <= 1,000,000）。数字用小数表示。

OUTPUT FORMAT
输出必须包括一个实数，表示必须的围栏的长度。答案保留两位小数。

SAMPLE INPUT (file fc.in)
4
4 8
4 12
5 9.3
7 8

SAMPLE OUTPUT (file fc.out)
12.00

分析：赤裸裸的凸包问题。参考资料

【参考程序】：

........   ........   ........   ........   .CCC....
EEEEEE..   ........   ........   ..BBBB..   .C.C....
E....E..   DDDDDD..   ........   ..B..B..   .C.C....
E....E..   D....D..   ........   ..B..B..   .CCC....
E....E..   D....D..   ....AAAA   ..B..B..   ........
E....E..   D....D..   ....A..A   ..BBBB..   ........
E....E..   DDDDDD..   ....A..A   ........   ........
E....E..   ........   ....AAAA   ........   ........
EEEEEE..   ........   ........   ........   ........

  1          2           3          4          5

现在，把这些图像按照 1—5 的编号从下到上重叠，第 1 张在最下面，第 5 张在最顶端。如果一张图像覆盖了另外一张图像，那么底下的图像的一部分就变得不可见了。我们得到下面的图像：

             .CCC....
             ECBCBB..
             DCBCDB..
             DCCC.B..
             D.B.ABAA
             D.BBBB.A
             DDDDAD.A
             E...AAAA
             EEEEEE..
对于这样一张图像，计算构成这张图像的矩形图像从底部到顶端堆叠的顺序。

下面是这道题目的规则：

    * 矩形的边的宽度为 1 ，每条边的长度都不小于 3 。
    * 矩形的每条边中，至少有一部分是可见的。注意，一个角同时属于两条边。
    * 矩形用大写字母表示，并且每个矩形的表示符号都不相同。

格式
PROGRAM NAME：frameup
INPUT FORMAT：(file frameup.in)

第一行 两个用空格分开的整数：图像高 H (3 <= H <=30) 和图像宽 W (3 <= W <= 30) 。

第二行到第 H+1 行 H 行，每行 W 个字母。

OUTPUT FORMAT：(file frameup.out)

按照自底向上的顺序输出字母。如果有不止一种情况，按照字典顺序输出每一种情况（至少会有一种合法的顺序）。

SAMPLE INPUT
9 8
.CCC....
ECBCBB..
DCBCDB..
DCCC.B..
D.B.ABAA
D.BBBB.A
DDDDAD.A
E...AAAA
EEEEEE..

SAMPLE OUTPUT
EDABC

分析： 
   首先，把每个矩形的上下左右边界统统记录下来。这样，沿每一个矩形的边走一遍，就可以知道谁压着它了。用一个数组cover记录谁压着谁。其实就是个有向无回路图。
   然后，拓扑排序。因为是要的所有解，所以要回溯法全找出来。
   计算拓扑序列时有两种方法：
   1.“删点法”，每次删去一个入度为0的点和它出发的所有边。删点的顺序就是一个拓扑序列。
   2.把有向图中所有的边反过来，再DFS，遍历完一个结点的子树后输出这个点。不过有个缺点，就是题目要求按字母顺序输出所有解，但这种方法最后还要排序。(我选择的第一种)

【参考程序】：

{批注：先前不知是哪个写了一个要不得的翻译，这才是正常的翻译，读起来也觉得比较健康——Cow-Tsc} {修改下，更现实——pyh119}

格式
PROGRAM NAME: milk6
INPUT FORMAT:(file milk6.in)

  第一行: 两个整数N(2<=N<=32)、M(0<=M<=1000), N表示仓库的数目，M表示运输卡车的数量。仓库1代 表发货工厂，仓库N代表有三聚氰胺的牛奶要发往的零售商。 第2..M+1行: 每行3个整数Si,Ei,Ci。其中Si,Ei表示这 辆卡车的出发仓库，目的仓库。Ci(0 <= C i <= 2,000,000) 表示让这辆卡车停止运输的损失。

OUTPUT FORMAT:(file milk6.out)

  第1行两个整数c、t,c表示最小的损失，T表示要停止的最少卡车数。接下来t 行表示你要停止哪几条线路。如果有多种方案使损失最小，输出停止的线路最少的方案。如果仍然还有相同的方案，请选择开始输入顺序最小的。

SAMPLE INPUT
4 5
1 3 100
3 2 50
2 4 60
1 2 40
2 3 80

SAMPLE OUTPUT
60 1
3

分析：
     要用到最小割最大流定理。
 首先求出最大流，那么最小割的容量就是最大流的流量。然后找有没有容量=最小割容量的“桥”（这里的桥就是去掉这条边后，由源点出发无法到达汇点），如果有那么这个桥就是答案。然后对每条容量不大于最小割的边，去掉后求一次最大流（估计这里我的算法太麻烦了）。如果流量的减少量=这条边的容量，那么这条边一定属于最小割。找出这样所有的边后，如果这些边的容量和=最小割容量，那么符合题目条件的最小割已求出。剩下的工作就是搜索了。我用的是枚举每一条满足上述的边。

对于*1001+1的解释：orz P〇〇н
         对于一个网络，已知它的弧的数量不超过1000，那么经过一定的技术处理，直接用基本的网络流算法就能实现了。
         在读入每条弧c[i,j]时，将其容量c[i,j]乘以1001加1存到f[i,j]中，即f[i,j]=c[i,j]*1001+1(这里不考虑两条弧连接相同两个结点的情况)，然后就用朴素的方法在f上求最大流得到maxflow。那么真实的最大流就是maxflow div 1001，元素最少最小割的元素个数就是maxflow mod 1001。为什么呢？我试试看能不能稍微讲清楚一点：
        首先，为什么maxflow div 1001就是原最大流呢？回想一下，每次我们求到一条增广轨后，进行track_back操作时，必然会由已求得的路径上的某条弧的容量，确定这个可行流的流量flow，假设这条弧为<i,j>。那么这条可行流的流量flow1=f[i1,j1]=c[i1,j1]*1001+1。依此类推，会得到flow2=f[i2,j2]=c[i2,j2]*1001+1、flow3=f[i3,j3]=c[i3,j3]*1001+1……最后找到了k条增广轨，得到的最大流maxflow=flow1+flow2+flow3……+flowk=(c[i1,j1]+c[i2,j2]+c[i3,c3]+……+c[ik,jk])*1001+1*k。 （其实，这段叙述很不准确，因为f[i,j]的值在前面找增广轨的过程中，有可能改变，这里只能算是孤立起来辅助理解吧）
        显然，k<=1000，当取maxflow div 1001时，得到的就是最大流，因为k在div过程中必然被忽略
        另一方面，每找到一条增广轨，必然比原有流量*1001多加上一个1（因为flow=f[i,j]=c[i,j]*1001+1，但回过头看看第一行红字，如果两条弧连接了相同两个结点，这里多加的就不是一个1，而是两个1了）。对于每个多加上的1，都是由一条增广轨的某条弧决定的，只要删除这条弧后，这个流就不通了。于是，maxflow mod 1001就是需要删的弧的个数。
       那么为什么这样求到的割集元素最少呢？因为，如果原图存在一个最大流量相等，但割集元素多一个 的情况时，那么在新图中，如果多找了一次增广轨，那么就多加了一个1，会超出已知最大流上限了（不能理解？尽量想象一下嘛，感觉是这样），这样的最大流是求不出来的。求到的自然而然的就是最少的那一个了。

【参考程序】：

格式
PROGRAM NAME: lgame
INPUT FORMAT:(file lgame.in)

输入文件lgame.in中有一行由小写字母(`a'到`z')组成的字符串， 这就是收集到字母(就是可以使用的字母)，字符串由至少3个字母至多7个字母(以任意顺序) 组成。

(file lgame.dict)

词典文件lgame.dict由至多40，000行组成，文件的最后一行有'.' 表示文件的结束。其它各行每一行都是由至少3个小写字母，至多7 个小写字母组成的字符串。文件中的词已按字典顺序排序。

OUTPUT FORMAT:(file lgame.out)

在文件lgame.out的第一行，你的程序应写上最高得分(子任务A).使用上面图形中给出的字母-值对应表。

随后的每一行是由文件lgame.dict中查到的具有这个得分的所有的词和或词对(word pairs)(子任务B)。要利用图中给定的字母的值。

当两个词能够形成 一个组合(具有给定的字母)时，这两个词应该打印到同一行，两个词中间用一个空格隔开。不许重复表示词对，例如'rag prom'和'prom rag'是同样的词对，只输出字典顺序较小的那个。

输出要按照字典顺序排序，如果两个词对第一个单词的顺序相同，则按照第二个单词。

SAMPLE INPUT(file lgame.in)
prmgroa

SAMPLE INPUT(file lgame.dict)
profile
program
prom
rag
ram
rom
.

SAMPLE OUTPUT
24
program
prom rag

【参考程序】：

图一：有 10 个路口的街道 一个良好的跑道具有如下几个特点：

    * 每一个路口都可以由起点到达。
    * 从任意一个路口都可以到达终点。
    * 终点不通往任何路口。
    * 运动员不必经过所有的路口来完成比赛。有些路口却是选择任意一条路线都必须到达的（称为“不可避免”的）。在上面的例子中，这些路口是 0，3，6，9。对于给出的良好的跑道，你的程序要确定“不可避免”的路口的集合，不包括起点和终点。

假设比赛要分两天进行。为了达到这个目的，原来的跑道必须分为两个跑道，每天使用一个跑道。第一天，起点为路口 0，终点为一个“中间路口”；第二天，起点是那个中间路口，而终点为路口 N。对于给出的良好的跑道，你的程序要确定“中间路口”的集合。如果良好的跑道 C 可以被路口 S 分成两部分，这两部分都是良好的，并且 S 不同于起点也不同于终点，同时被分割的两个部分满足下列条件：（1）它们之间没有共同的街道（2）S 为它们唯一的公共点，并且 S 作为其中一个的终点和另外一个的起点。那么我们称 S 为“中间路口 ”。在例子中只有路口 3 是中间路口。

格式
PROGRAM NAME: race3
INPUT FORMAT:(file race3.in)

输入文件包括一个良好的跑道，最多有 50 个路口，100 条单行道。

一共有 N+2 行，前面 N+1 行中第 i 行表示以编号为(i-1)的路口作为起点的街道，每个数字表示一个终点。行末用 -2 作为结束。最后一行只有一个数字 -1。

OUTPUT FORMAT:(file race3.out)

你的程序要有两行输出：

第一行包括：跑道中“不可避免的”路口的数量，接着是这些路口的序号，序号按照升序排列。

第二行包括：跑道中“中间路口”的数量，接着是这些路口的序号，序号按照升序排列。

SAMPLE INPUT
1 2 -2
3 -2
3 -2
5 4 -2
6 4 -2
6 -2
7 8 -2
9 -2
5 9 -2
-2
-1

SAMPLE OUTPUT
2 3 6
1 3

分析(nocow)：

    1.一道基础的连通分量的图论题。这个题默认了0为起点，N为终点。(如果不放心可以再读入的时候判断起点和终点，即入度为0的点为起点，出度为0的点为终点。)

    2.该题有两问，第一问很简单，可以尝试去掉每一个点，判断从起点到终点是否有通路，如果没有则该点为“必经点”。

    3.第二问重点在于理解题意。首先可以确定第二问的解集是第一问的子集，所以我们可以第一问得出的每个点深搜，记录下可以到达的点。然后去掉该点，从起点深搜。如果不存在两次深搜皆可到达的点，就说明它是分割点。

【参考程序】：

"逢低吸纳,越低越买"

这句话的意思是：每次你购买股票时的股价一定要比你上次购买时的股价低.按照这个规则购买股票的次数越多越好，看看你最多能按这个规则买几次。

给定连续的N天中每天的股价。你可以在任何一天购买一次股票，但是购买时的股价一定要比你上次购买时的股价低。写一个程序，求出最多能买几次股票。

以下面这个表为例, 某几天的股价是:

天数 1  2  3  4  5  6  7  8  9  10 11 12
股价 68 69 54 64 68 64 70 67 78 62 98 87

这个例子中, 聪明的投资者(按上面的定义)，如果每次买股票时的股价都比上一次买时低，那么他最多能买4次股票。一种买法如下(可能有其他的买法):

天数 2  5  6  10
股价 69 68 64 62

格式
PROGRAM NAME: buylow
INPUT FORMAT:(file buylow.in)

第1行: N (1 <= N <= 5000), 表示能买股票的天数。

第2行以下: N个正整数 (可能分多行) ，第i个正整数表示第i天的股价. 这些正整数大小不会超过longint(pascal)/long(c++).

OUTPUT FORMAT:(file buylow.out)

只有一行，输出两个整数：

能够买进股票的天数 长度达到这个值的股票购买方案数量

在计算解的数量的时候，如果两个解所组成的字符串相同，那么这样的两个解被认为是相同的（只能算做一个解）。因此，两个不同的购买方案可能产生同一个字符串，这样只能计算一次。

SAMPLE INPUT
12
68 69 54 64 68 64 70 67
78 62 98 87

SAMPLE OUTPUT
4 2

分析：(借鉴于leokan大牛)

首先是第一个输出，求"能够买进股票的天数"也就是子序列长度啦，用O(n^2)就可以求出，很容易：

  a表示读入的数据。

  对于f(i)=前i个数中最长不下降子序列长度，则f(i)=max{f(1),f(2),f(3),..,f(i-1)}+1,其中被选中的f(j)满足ai<aj,显然，它满足最优子结构。所以得到状态转移方程f(i)=max{f(j)+1}(j<i,aj>ai)

下界：第1个数的最长下降子序列就是它本身，则f(1)=1。

难就在第二个问题：
  原话：“在计算解的数量的时候，如果两个解所组成的字符串相同，那么这样的两个解被认为是相同的（只能算做一个解）。因此，两个不同的购买方案可能产生同一个字符串，这样只能计算一次。”

也就是对于数据2 1 1 这种数据它会重复计算2 1（第一个1） 1（第二个1）。

求总数：
  对于c(i)=前i个数中最长不下降子序列的个数，可以这样考虑，除去i不谈，那么之前满足最长下降子序列的c(j)=c(i)-1(因为c(j)在c(i)这个序列中，它加上i就是i的最长不下降子序列)所以得到状态转移方程：c(i)=sum(c(j)) (j<i,aj>ai,f(i)=f(j)+1)

如何判重：
  观察可能重复的发生情况，对于每一个可能重复的长度为3下降的子序列，它一定是i,j,j(i>j)这种情况，所以可以开一个boolean数组vis记录j是否出现过，若出现了，就不再计算。
最终状态转移方程：c(i)=sum(c(j)) (j<i,aj>ai,f(i)=f(j)+1，vis[j]=false)。

最后，开个高精做加法就行了


【参考程序】：