Listen to this amusing MP3 file that explains it all for computer geeks.

看上去很熟悉对吧

下面是稍微完整一些的一个版本

It's worse than I feared.

What is it?

I'm afraid your son has ... the Knack.

The knack?

The Knack. It's a rare condition characterized by an extreme intuition about all things mechanical and electrical ... and utter social ineptitude.

Can he lead a normal life?

No. He'll be an engineer.

Oh, no! [crying]

There, there. Don't blame yourself.

BBS.oifans.cn 上找到的一部分，前面有一段听不大清楚＝ ＝BS我的英语吧 ，Knack－－a special way of doing something
再来找到的另外一个吧～

Orz Orz Orz Engineer~

相关日志

• Nothing Here 09.09.27 (10)
• 随机闲聊网站-Omegle.com (25)
• Mozilla之书 (2)
• Tux 福音 1.0 中文版 (2)
• Flash動畫的反擊 (0)

Section 1.1.1 PROB Your Ride Is Here [ANALYSIS]

这道题就是考你会不会写程序啦，还有呢，就是 ord(c) 这个Function的运用了~

Section 1.1.2 PROB Greedy Gift Givers [ANALYSIS]

这道题细心一点，名字对应好就不会错了~

Section 1.1.3 PROB Friday the Thirteenth [ANALYSIS]

这一道题的关键就是：下一个月13号的星期数就等于(这个月13号的星期数＋这个月的天数MOD 7)MOD 7

PS：我记星期天为0。

Section 1.1.4 PROB Broken Necklace [ANALYSIS]

O（N）的算法。Dynamic Programming is good method for solving this problem in O(N).

If we consider two copies of the string we easy transform cyclic configuration of the necklace to linear.

Now we can compute for each breaking point how many beads of the same color can be collected on the left and on the right from the breaking point. I show how we can compute it only for the left side.

For right side it is analogical. Let r[p] and b[p] be the number of red / blue beads that can be collected, when necklace is broken in point p. If we know this and color of next bead (c) we can compute r[p+1] and b[p+1].

r[0] = p[0] = 0 If c = 'r' then r[p+1] = r[p] + 1 and b[p+1] = 0 because the length of the blue beads is 0.

if c = 'b' then b[p+1] = b[p] + 1 and r[p+1] = 0if c = 'w' then both length of the red and length of blue beads canbe longer. so r[p+1] = r[p]+1 and b[p+1] = b[p] + 1.

The number of beads that can be collected in breaking point p is then

max(left[r[p]], left[b[p]]) + max(right[r[p]], right[b[p]]).

And themaximum from this value is answer for the problem.

PS：我是看了标程写出来的呃~做了好久，原来的烦死掉了，就重写了一个。先把珠子复制一遍~

Section 1.2.1 PROB Milking Cows [ANALYSIS]

先按起始时间进行快速排序，然后按顺序判断时间段
if t1[i]<=r then
r:=max(t2[i],r)
t1[i]，t2[i]为每一位工人的起始结束时间。
l、r为时间段的起始结束时间。
每一个连续的时间段结束后。
a1:=max(a1,r-l);
a2:=max(a2,t1[i]-r);
l:=t1[i];
r:=t2[i];
a1为最长的连续工作时间；
a2为最长的空闲时间；
最后再执行一次求最长的连续工作时间 a1:=max(a1,r-l);
完成~

Section 1.2.2 PROB Transformations [ANALYSIS]

这道题，好奇怪厄~主程序都一样，原来的就是提交不通过~呃~郁闷的~Procedure N4 为翻转Procedure N1 为顺时针90'最后再用 function bj 来判断两图案是否相同~

procedure N1(l:arr2; var m:arr2);

var i,j:integer;

begin

for i:=1 to n do

for j:=1 to n do

m[j,n-i+1]:=l[i,j];

end;

function bj(a,b:arr2):boolean;

var i,j:integer;

begin

equal:= true;

for i:=1 to n do

for j:=1 to n do

if a[i,j] <> b[i,j] then begin

equal:=false; exit;

end;

end;

Section 1.2.3 PROB Name That Number [ANALYSIS]

掌握好文件的读取写入操作，逐个读入字典中的人名，并转换成数字，与起始的数字比较，相同就输出，全部用字符串，不知道为什么我用int64和longint都不可以。厄~一开始想把数字转换成名字作但复杂度为O（3^N），太复杂，后来看了别人的报告，发觉用字典好~

s:array['A'..'Z'] of char=('2','2','2','3','3','3','4','4','4','5','5','5', '6','6','6','7','7','7','7','8','8','8','9','9','9','9');

Section 1.2.4 PROB Palindromic Squares [ANALYSIS]

最主要的是进制转换。Procedure ToB 然后倒转字符串若相等，即为回文数。输出。

procedure ToB (a:longint;var c:string);

var k,i:longint;

begin

k:=0;

c:='';

repeat inc(k);

i:=a mod b;

a:=a div b;

c:=s[i]+c;

until a=0;

end;

Section 1.2.5 PROB Dual Palindromes [ANALYSIS]

和上一道差不多 TOB +倒转字符串 轻松AC

Section 1.3.1 PROB Mixing Milk [ANALYSIS]

我先用快排Qsort把所有数据排序，每次选最小的卖牛奶的人把他“榨干”，求出钱数~ 贪心第一题

Section 1.3.2 PROB Barn Repair [ANALYSIS]

~~~好汗的~已经是第三道关于牛的了呃~
第一次数据太弱，程序完全错掉还AC3个，汗
先读入全部数据，进行快排。
然后把满牛棚之间的连续的空牛棚的数量存入数组，进行快排~
舍去最大的M-1个数字~
剩下的加上C即为最终解~ 还是贪心

Section 1.3.3 PROB Calf Flac [ANALYSIS]

三个数组~a为原文c为a中的字母，转为大写存入~b为c中字母在a中对应的位置，最后输出时使用~

Section 1.3.4 PROB Prime Cryptarithm [ANALYSIS]

厄~一开始没看清题目~以为最后输出的数为回文数~汗~USACO的题目太奇怪了~做到现在不是回文数就是COW呃~思维定势~别的就没有什么叻~枚举第一行，第二行的每一种可能性，使3，4，5行都满足条件~

Section 1.4.1 PROB Packing Rectangles [ANALYSIS]

郁闷死了,从开学做到现在,不爽 ,Copy lhyxxh1 同学的,

这道题目数据规模很小，大可枚举4个矩形的摆放方式，然后再计算大矩形的边长。
以下用width[1..4]表示矩形的长，height[1..4]表示矩形的宽。用w表示大矩形的长，h表示大矩形的宽：
方式一：
w = width[1] + width[2] + width[3] + width[4]
h = ＭＡＸ｛height[1], height[2], height[3], height[4]｝
方式二：
w = ＭＡＸ｛width[1] + width[2] + width[3], width[4]｝
h = ＭＡＸ｛height[1], height[2], height[3]｝ + height[4]
方式三：
w = ＭＡＸ｛width[1] + width[2], width[3]｝ + width[4]
h = ＭＡＸ｛ＭＡＸ｛height[1], height[2]｝ + height[3], height[4]｝
方式四：
w = width[1] + width[2] + ＭＡＸ｛width[3], width[4]｝
h = ＭＡＸ｛height[1], height[2], height[3] + height[4]｝
方式五：
同方式四。
方式六：
h = ＭＡＸ｛height[1] + height[3], height[2] + height[4]}
w = ＭＡＸ: width[1] + width[2], 一般条件
width[3], 一般条件
width[4], 一般条件
width[2] + width[3], 当height[1] < height[2]时
width[1] + width[4], 当height[1] > height[2]时
width[3] + width[4], 当height[1] + height[3] > height[2]时
注意以上是把矩形1放到左下，2放到右下，3放到右上，4放到左上为例的。

Section 1.4.2 PROB The Clocks [ANALYSIS]

枚举所有方法

还有一种Ox的

program clocks;
const
INV : array[3..12] of byte =(1, 0, 0, 2, 0, 0, 3, 0, 0, 0);

var inp, out: text;
a, b, c, d, e, f, g, h, i: integer;
ax, bx, cx, dx, ex, fx, gx, hx, ix,l: integer;
t,an: array[1..9] of integer;
begin
assign (inp, 'clocks.in'); reset (inp);
readln(inp, ax, bx, cx);
readln(inp, dx, ex, fx);
readln(inp, gx, hx, ix);
a:=inv[ax]; b:=inv[bx]; c:=inv[cx]; d:=inv[dx];
e:=inv[ex]; f:=inv[fx]; g:=inv[gx]; h:=inv[hx];
i:=inv[ix];
t[1] := ( 8 + a + 2 * b + c + 2 * d +2 * e - f + g - h ) mod 4;
t[2] := ( a + b + c + d + e + f + 2 * g + 2 * i ) mod 4;
t[3] := ( 8 + a + 2 * b + c - d + 2 * e + 2 * f -h + i ) mod 4;
t[4] := ( a + b + 2 * c + d + e + g + h + 2 * i ) mod 4;
t[5] := ( 4 + a + 2 * b + c + 2 * d - e + 2 * f + g + 2 * h+ i ) 

mod 4;
t[6] := ( 2 * a + b + c + e + f + 2 * g + h + i ) mod 4;
t[7] := ( 8 + a - b + 2 * d + 2 * e - f + g + 2 * h + i ) mod 4;
t[8] := ( 2 * a + 2 * c + d + e + f + g + h + i) mod 4;
t[9] := ( 8 - b + c - d + 2 * e + 2 * f + g + 2 * h+ i) mod 4;
assign(out, 'clocks.out'); rewrite(out);
for a := 1 to 9 do
for b := 1 to t[a] do Begin
inc(l);
an[l]:=a;
end;
for a:=1 to l-1 do
write(out,an[a],' ');
write(out,an[l]);
writeln(out); close(out)
end.

Section 1.4.3 PROB Arithmetic Progressions [ANALYSIS]

说实话，没看懂是怎么做的~

Section 1.4.4 PROB Mother's Milk [ANALYSIS]

说实话，没看懂是怎么做的~

Section 1.5.1 PROB Number Triangles [ANALYSIS]

dp[i,j]:=max(dp[i-1,j],dp[i-1,j-1])+tree[i,j];

dp为到该节点的最大权值，tree为该点权值

动规？

Section 1.5.2PROB Prime Palindromes [ANALYSIS]

判断素数

function prime(z:longint):boolean;

var

i:longint;

begin

begin

i:=2;

while (i*i<=z) and (z mod i <>0) do inc(i);

if z mod i = 0 then prime:=false else prime:=true;

end;

end;

还有就是符合条件的偶数位的数只有11（可以证明） 从三位数搜索吧（<100 的只有 5 7 11）

Section 1.5.3PROB SuperPrime Rib [ANALYSIS]

procedure sp(x,k:longint);

var

i:longint;

begin

if k<=n then

for i:=1 to 4 do begin

x:=x*10+y[i];

if prime(x) then sp(x,k+1);

x:=(x-y[i]) div 10;

end

else

writeln(x);

end;

x为当前数 k为当前数的长度 DFS 搜吧

Section 1.5.4PROB Checker Challenge [ANALYSIS]

经典的8皇后问题，小于11的我能通过，大的就TLE了~

就这样吧~先更新到这里了~

BY Wandsea 转载请注明~

相关日志

• USACO首页上的一段录音 (2)
• Flood Fill 种子染色法 (0)

样例： 相连的农场

Farmer John的农场被一次意外事故破坏了，有一些农场与其他的农场之间有道路相连，而有些道路却已被破坏。这使得Farmer John 无法了解到从一个农场能否到达另一个农场。你的任务就是帮助Farmer John来了解哪些农场是连通的。

给出：

上题实际上就是要求寻找一张无向图的所有极大连通子图。

给出一张未知连通性的图，如下图：

可知，该图的极大连通子图是：{1,4,8}， {2,5,6,7,9} 和 {3}。

算法: Flood Fill

Flood Fill 可以用深度优先搜索，广度优先搜索或广度优先扫描来实现。他的实现方式是寻找到一个未被标记的结点对它标记后扩展，将所有由它扩展出的结点标上与它相同的标号，然后再找另一个未被标号的 结点重复该过程。这样，标号相同的结点就属于同一个连通子图。

深搜：取一个结点，对其标记，然后标记它所有的邻结点。对它的每一个邻结点这么一直递归下去完成搜索。

广搜：与深搜不同的是，广搜把结点加入队列中。

广度扫描（不常见）：每个结点有两个值，一个用来记录它属于哪个连通子图（c），一个用来标记是否已经访问（v）。算法对每一个未访问而在某个连通子图当中的结点扫描，将其标记访问，然后把它的邻结点的（c）值改为当前结点的（c）值。

深搜最容易写，但它需要一个栈。搜索显式图没问题，而对于隐式图，栈可能就存不下了。

广搜稍微好一点，不过也存在问题。搜索大的图它的队列有可能存不下。深搜和广搜时间复杂度均为O(N+M)。其中，N为结点数，M为边数。

广度扫描需要的额外空间很少，或者可以说根本不要额外空间，但是它很慢。时间复杂度是O(N^2+M)。

（实际应用中，我们一般写的是DFS，因为快。空间不是问题，DFS可改用非递归的栈操作完成。但为了尊重原文，我们还是译出了广度扫描的全过程。——译者）

广度扫描的伪代码

代码中用了一个小技巧，因此无须额外空间。结点若未访问，将其归入连通子图（-2），就是代码里的component -2。这样无须额外空间来记录结点是否访问，请读者用心体会。

# component(i) denotes the
# component that node i is in
1 function flood_fill(new_component)

2 do
3 num_visited = 0
4 for all nodes i
5 if component(i) = -2
6 num_visited = num_visited + 1
7 component(i) = new_component
8 for all neighbors j of node i
9 if component(j) = nil
10 component(j) = -2
11 until num_visited = 0

12 function find_components

13 num_components = 0
14 for all nodes i
15 component(node i) = nil
16 for all nodes i
17 if component(node i) is nil
18 num_components =
num_components + 1
19 component(i) = -2
20 flood_fill(component
num_components)

算法的时间复杂度是 O(N ²)，每个结点访问一次，每条边经过两次。

实例

考虑刚才的那张图：

开始时，所有的结点都没有访问。（下例中未访问被表示为 -2)

首先从结点1开始，结点1未访问，那么先处理结点1，将它归入连通子图1。

标记完成后，对它进行第一步的扩展，由结点4和结点8与结点1连通，故它们被扩展出来。

之后，先处理结点4，将它与结点1归入相同的连通子图。现在它没有可扩展的结点了（结点1已被扩展过）

接着处理结点8。结果与结点4一样。

现在，所有与结点1连通的结点都已扩展，标号为1的连通子图产生了。那么我们将跳出扩展步骤，寻找下一个连通子图，标号为2。

与上一步相同的顺序，找到结点2。

扩展结点2，结点7与结点9出现。

下一步，扩展结点7，结点5出现。

然后是结点9。

扩展结点5。结点6出现。

很遗憾，结点6没有可供扩展的结点。至此连通子图2产生。

结点	连通子图
1	1
2	2
4	1
5	2
6	2
7	2
8	1
9	2

之后寻找连通子图3，至此，仅有结点3未被扩展。

结点	连通子图
1	1
2	2
3	-2
4	1
5	2
6	2
7	2
8	1
9	2

结点3没有可供扩展的结点，这样，结点3就构成了仅有一个结点的连通子图3。

结点	连通子图
1	1
2	2
3	3
4	1
5	2
6	2
7	2
8	1
9	2

结点3处理结束后，整个图的所有9个结点就都被归入相应的3个连通子图。Flood Fill 结束。

问题提示

这类问题一般很清晰，求解关于“连通”的问题会用到 Flood Fill。它也很经常用作某些算法的预处理。

扩展与延伸

有向图的连通性比较复杂。

同样的填充算法可以找出从一个结点能够到达的所有结点。每一层递归时，若一个结点未访问，就将其标记为已访问（表示他可以从源结点到达)，然后对它所有能到达且为访问的结点进行下一层递归。

若要求出可以到达某个结点的所有结点，你可以对后向弧做相同的操作。

例题

控制公司 [有删节, IOI 93]

已知一个带权有向图，权值在0-100之间。

如果满足下列条件，那么结点A“拥有”结点B：

• A = B

• 从A到B有一条权值大于50的有向弧。

• 存在一系列结点 C ₁ 到 C _k 满足 A 拥有 C ₁ 到 C _k, 每个节点都有一条弧到B，记作x ₁ ，x ₂ ...x _k，并且 x ₁ + x ₂ + ... + x _k > 50。

找出所有的（A，B）对，满足A拥有B。

分析：这题可以用上面提到的“给出一个源，在有向图中找出它能够到达的结点”算法的改进版解决。要计算A拥有的结点，要对每个结点计算其“控股百分比”。 把它们全部设为0。现在，

相关日志

• USACO首页上的一段录音 (2)
• USACO Chapter1报告 (0)