PKU 1961 http://poj.org/problem?id=1961

       题意：给定一个长度为N(N <= 10⁶)的字符串S，求它的所有前缀中能够表示成A^K的前缀，并且要求求出每个前缀对应的K。

       题解：KMP

       利用KMP求出该串的Next数组，然后枚举每个前缀，根据Next数组的定义，对于某个前缀S[1...i]，有S[1...Next[i]] = S[i-Next[i]+1...i]，假设前缀S[1...i]能够表示长A^K的形式，则A = S[Next[i]+1...i]，所以必须满足i能够被i - Next[i] 整除，满足条件后K = i/( i - Next[i])。

B. Corporative Network

       PKU 1962 http://poj.org/problem?id=1962

       题意：给定N(N <= 20000)个点和M(M <= 200000)次操作，每次操作有两种类型：

       I a b   将a的父结点设为b，并且合并距离为 |a-b| mod 1000

       E a    询问a到根结点的合并距离。

题解：并查集

利用路径压缩的思想，用dist[p]表示p和p的父结点的合并距离，每次查询的时候累加p到根结点的合并距离，并且将p到p所在树的根结点R的路径上的所有点的父结点都设为R，然后更新各自的合并距离。

合并操作O(1)，查询操作总复杂度O(N)。

C. Cave Exploration

PKU 1963 http://poj.org/problem?id=1963

题意：给出N(N <= 1000)条水平或者垂直的走廊，再给定走廊上任意一个坐标点作为起点以及方向，按照以下策略走：能够左转就左转，不能则笔直走，不能笔直走就右转，都不能就掉头。这样走最后绕一圈又会回到起点，问哪些走廊是没有经过的，只要有一个点走过就算经过。
      题解：模拟 + 哈希。

将水平线段和竖直线段分开存，分两种情况讨论：

      1、水平线段

对于任意一根水平线段，枚举所有的竖直线段，计算出交点和水平线段的端点，保存下来并且按x坐标递增排序，去掉重复点，利用双向链表将两个相邻点连接起来，由于x和y坐标范围为-32767~32767，而交点数不会超过N²，所以可以采用哈希将二维的点映射到一位数组中。每个点记录水平走廊的编号。

      2、竖直线段

同上操作，不同的是每个点记录竖直走廊的编号。

经过1和2两步操作后，走廊上的关键点已经被离散化了，并且所有点都通过四向链表串接起来，然后只需要从起点开始模拟行走即可，走到一个关键点，将关键点所在的两个走廊编号标记掉，最后统计没有标记的走廊编号就是答案了。

D. City Game

       PKU 1964 http://poj.org/problem?id=1964

       题意：给定一个M*N(M <= 1000，N <= 1000)的01矩阵，求它的一个子矩阵，满足矩阵元素全为1，并且面积最大。

题解：枚举行，对于第i行，以第i行为起点，扫描每一列j，找到第一个不是1的数所在的位置P[j]，令K[j] = P[j] - i，于是问题转化成了一个一维的问题。

L[i] 表示 K [ L[i]+1 ... i] 中的元素都大于等于K[i]，但是L[i]小于K[i]；

R[i] 表示 K [i ... R[i]-1] 中的元素都大于等于K[i],但是R[i]小于K[i]；

Max{  (R[i] - L[i] - 1) * K[i],  1 <= i <= N }就是以当前枚举行为起点的最大矩阵，枚举M次取最大值就是全局的最大子矩阵了。

E. Cube Root

       PKU 1965 http://poj.org/problem?id=1965

       题意：给定一个不超过150个数字的正整数，求它的三次方根，精确到小数点后10位。

       题解：大数模拟

将输入的数X用字符串存储，乘上10³⁰，利用二分求出最大的Y，使得Y³ <= X。然后在Y的后十位前插入一个小数点，输出即可。

F. Cable TV Network

       PKU 1966 http://poj.org/problem?id=1966

       题意：求图的点连通度。给定一个N(N <= 50)个点的图，求去掉至少多少个点能够将它变成一个非连通图。

       题解：搜索 + 剪枝 (或者 最大流)

       枚举每个点去掉或不去掉，总共2⁵⁰种状态，每次去掉点后判断当前图的连通性，一旦破坏了连通，去掉的点数即为答案；如果发现某个点去掉后，剩下点组成的图变成了一个完全图，那么不用继续搜索了，因为当前状态下不可能将剩下的图变成非连通图了；如果去掉的点数超过目前的最优解也直接剪枝。

       好吧...一定是数据弱了-_-||，正解是最大流拆点。

G. Alibaba

       PKU 1967 http://poj.org/problem?id=1967

       题意：给定N(N <= 10⁴)个整数对(P_i, D_i)表示在P_i位置有一个宝物，并且需要在D_i 时间之前取走(给出顺序为P_i递增的顺序)。起始可以任意选择一个位置，往左或者往右取宝物，问是否能够保证每个物品都在D_i时间之前取走(时间和距离关系为1:1)，如果可以，给出取完所有宝物的最少时间。

       题解：搜索 + 剪枝

       首先可以想到的是，起始位置一定是N个宝物所在位置中的其中一个，所以首先可以枚举每个宝物的起始点，比如当前位置为pos，那么在第0秒内，访问过的区间为[pos, pos]，可以选择往左走，也可以选择往右走，那么是不是只要选择某个方向走完，然后再反方向走到底如果能够满足所有点都在截止时间内完成一定是对的呢？答案是否定的，来看一组数据，如图1，起始点只能选择3号位置，并且只能选择往右走，走到4后再折回走到2，然后再折回走到5，以此类推，并且只有这一种路径才能满足所有宝物都在截至时间内取完。

图1

         按照这个思路，进行状态的划分，假设当前已经访问的区间为[L, R]，并且现在的位置处于pos位置(这里pos要么等于L，要么等于R)，所以可以用三维来表示状态DP[s][l][r](l、r表示访问过的区间的左右端点，如果当前位置在l则s = 0，如果当前位置在r，则s=1)，总共状态数目N²，状态转移的时候由大状态推小状态，即DP[s][l][r]一定是由DP[0][l-1][r]、DP[0][l][r+1]、DP[1][l-1][r]、DP[1][l][r+1]这四个状态得出。

       考虑到N比较大，所以把所有状态存储到数组中再利用动态规划进行递推，如果数据量不多的话，可以卡过，但是状态存储需要用滚动数组，否则内存吃不消，也可以采用搜索 + 剪枝，思路是沿用了动态规划的思想，假设当前已经访问的区间为[L, R]，现在的位置处于pos位置(这里pos要么等于L，要么等于R)，并且已经使用了T的时间，无论当前的pos是在左区间端点L上还是在右区间端点R上，他都可以选择走到L-1(L > 1)，或者R+1(R < N)，于是就可以递归求解了，递归出口为L=1，R=N的时候。

图2

       如图，已经访问的宝物为红色标记的点，灰色标记的为未曾访问过的，并且现在的位置在已经访问区间的左端点L上，已经使用了T的时间，我们需要判断这个状态是否合法，则需要满足以下的几个不等式。

       1、保证右边未访问的都能在截止时间内访问到：

              T + (P[R] - P[L]) +  (P[R+1] - P[R])  < D[R+1]

              T + (P[R] - P[L]) +  (P[R+2] - P[R])  < D[R+2]

              ...

              T + (P[R] - P[L]) +  (P[N] - P[R])  < D[N]

              将这些等式化简，可得：

              T - P[L]  <  D[R+1] - P[R+1]

              T - P[L]  <  D[R+2] - P[R+2]

              ...

              T - P[L]  <  D[N] - P[N]

              再进行进一步化简，得：

              T - P[L]  <  Min{ D[k] - P[k],  R < k <= N }

       2、保证左边未访问的都能在截止时间内访问到：

              同理，可以得出：

              T + P[R]  <  Min{ D[k] + P[k],  1 <= k < R }

       那么，令 POSTM[i] = Min{ D[k] - P[k],  i < k <= N }

                      PREM[i] = Min{ D[k] + P[k],  1 <= k < i }

       这两个数组可以分别通过一次逆序和顺序的线性扫描求出来，用于搜索的时候判断可行性。例如，当T - P[L] >= POSTM[R] 表示在右边未访问的宝物中有至少一个宝物不能在截止时间前被访问到，T + P[R] >= PREM [R]表示在左边未访问的宝物中有至少一个宝物不能在截止时间前被访问到，直接剪枝。

       还需要一个剪枝，就是在当前时间T加上当前状态下预计访问完所有宝物的最小时间已经比之前求出的最小时间大，直接剪枝。

H . Booklets

       PKU 1968 http://poj.org/problem?id=1968

       题意：N(N <= 3000)本小册子需要分配给S个学校，每个学校得到的是N/S的上整本册子或者N/S的下整本册子，每本册子有一个页数，并且规定分配册子的时候按照页数递增来分配，先把上整本册子分完再分下整的，对于每个学校的分书规则，按照输入的顺序进行分配。求问第T个学校分到的第一本册子的页数。

       题解：需要求出几个量：

       上整册子的数目UIP = (N+S-1) / S;

       下整册子的数目LIP = N/S;

       分到上整册子数目的学校个数UIPC = N % S;

       分到下整册子数目的学校个数LIPC = N - N % S;

       首先对所有的册子按页数递增来排序(如果页数相同按照下标递增排序)，然后减去前T-1个学校的册子总数，容易得出第T个学校分到的册子数目C，从接下来的C个册子中找到之前下标最小的册子，它对应的页数就是答案。

I. Count on Canton

       PKU 1969 http://poj.org/problem?id=1969

       题意：给定下图所示的无限分数序列，并且按照蛇形方式编号，即第一个为1/1，第二个为1/2，第三个为2/1，第四个为3/1，以此类推，问第N个分数是什么。

               1/1         1/2         1/3         1/4           1/5 ...

               2/1         2/2         2/3         2/4

               3/1         3/2         3/3

               4/1         4/2

               5/1

    题解：数学题。

    首先二分求出在第几条斜线上，即(K-1)K/2 < N的最大的K，然后求根据K的奇偶性求出蛇形在第K条斜线的行走方向，第N - (K-1)K/2 个数就是答案。

A . The Hardest Problem Ever

       PKU 1298 http://poj.org/problem?id=1298

         题意：解码题，按照如下对应关系解码：

       密文 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
       原文 V W X Y Z A B C D E F G H I J K L M N O P Q R S T U 

       题解：简单题。

B. Polar Explorer

PKU 1299 http://poj.org/problem?id=1299

题意：给定圆的半径X，求圆周上两个点A和B的距离，其中圆心角AOB的角度为Z(0 <= Z <= 360)。

题解：核心是Z如果大于180，则Z = 360 - Z，即走劣弧。而且题目求的是来回一次，所以计算的时候弧长要乘2。

C. Door Man

PKU 1300 http://poj.org/problem?id=1300

题意：给定一些边和起点s，求能否找到一条从s到0的通路，并且要求访问所有的边。

题解：欧拉回路可行解判定。

首先利用flood fill从s遍历全图，如果0点没有被访问到则必定不存在；然后判断度数不为0的点是否有未被访问到的，如果有，说明图不连通，也必定不存在解；最后统计度数为奇数的点的个数P，以及具体的点：

1)  P = 0，则必定有解；

2)  P > 2，则无解；

3)  P =2, 那么有解的前提是两个奇度数点中一个是s，另一个是0；否则无解。

D . The Umbrella Problem 2054

PKU 1301 http://poj.org/problem?id=1301

题意：给定一个10X10的地图，玩家从第一行的某一个点出发，每一步行编号+1，列编号增量有三种选择(-1, 0, 1)，图中标记为S(laser gun)的点不能走，并且S的点会发出镭射光，第0秒朝上发射，第1秒朝右，第2秒朝下，第3秒朝左，循环往复，发射长度一直到地图边缘。问能否走到最后一行标记为G(grass)的地方。

题解：广搜。

hash[4][R][C]表示状态，每走一步，利用步数 mod 4计算出镭射光的方向，然后将所有的镭射光可达区域全部标记出来，未标记的点为可达点，枚举三个方向进行搜索。

E. Blue Gene, Jr.

       PKU 1302 http://poj.org/problem?id=1302

       题意：一个长度为N(N <= 20)的病毒基因串A[1...N]进行变异，变异过程从左往右，分情况讨论：

       1) 如果第i个字符是 A-Z，则它将变异成数字n mod 10，n表示A[i+1...N]中变异基因的数目；

       2) 如果第i个字符是 1-9，则它变异成A[i] - 1，并且如果第p (p = i + A[i])个基因存在的话，从第p个基因开始变异；否则从第i+1个基因开始变异；

       题解：题意理解后就是个水题了，递归求解。

F . Byte Me!

       PKU 1303 http://poj.org/problem?id=1303

       题意：二进制二十一点(二进制黑杰克)是由两种牌组成的游戏，一种称为bytes(一个8比特的序列表示0-255之间的数)，一种称为nibbles((一个4比特的序列表示0-15之间的数)，游戏玩法如下：

       1) 游戏的目标是获得尽量接近510分，并且不能超过它；

       2) 每个玩家有两张牌，一张面朝上，一张面朝下(庄家不知道是什么牌)；

       3) 每个玩家有四次叫牌机会，可以叫bytes，也可以叫nibbles，但是如果分数超过510则不能再叫牌；

       4) 所有的叫牌都是面朝上的；

       5) 如果玩家分数超过510，立即判为输；

       5) 庄家最后一个叫牌；

       7) 平局的情况庄家胜(如果所有人都超过510分，庄家还是赢的)；

庄家的规则如下：

       1) 当看到自己和其他人面朝上的牌，判断已经必胜时不要再叫牌了；

       2) 如果总分小于382时 需要叫一次byte牌；

       3) 如果总分小于等于500时 需要叫一次nibble牌；

还有两个隐藏规则：

       1) 你是庄家；

       2) 每个非庄家的玩家面朝下的牌是11111111（但是庄家不知道），面朝上的牌给定；

       3) 非庄家不会叫牌(因为他们比较笨)；

       给定庄家的牌和其他玩家面朝上的牌，以及牌堆中的bytes牌和nibble牌，求庄家的四次叫牌能否获胜；

       题解：题目说了一大堆，最后非庄家的玩家都不会叫牌，o(╯□╰)o...所以只要根据庄家的规则进行叫牌，然后判断是否能够胜出即可；

       因为其他人都不叫牌，每个人都有两张牌，所以其他人的总分不可能超过510分，所以，如果庄家叫牌超过510分直接被判为负。

       每次叫牌前先判断所有玩家的朝上的卡片分数加上255和庄家当前得分进行比较，如果有一个玩家分数大于庄家分数，则庄家按照382和500这两个区间进行叫牌。

       四次叫牌结束，如果所有玩家分数都小于等于庄家分数，则判断庄家分数是否大于510，如果是，输出Bust!，否则输出Win!；如果小于某个玩家的分数，那么输出Lose!。

G . World's Worst Bus Schedule

       PKU 1304 http://poj.org/problem?id=1304

       题意：公交车站有N(N <= 20)辆车，每辆车的发车时间间隔为a1 a2 a3 a4... a1 a2 a3 a4... a1 a2 a3 a4...，循环发车，问某人在T时刻赶到公交车站，最少需要等待多少时间能够乘上公交车。

       题解：对于每辆公交车，设它的所有时间间隔之和为S，令T' = T mod S，然后枚举所有的发车间隔，前i个发车间隔a[i]之和减去T'中的最小正值就是等这辆公交车需要的时间，取所有公交车的最小时间就是所求。

A. Artificial Intelligence?

PKU 2256 http://poj.org/problem?id=2256

题意：功率的计算公式为P = UI，给定一句话，这句话中一定会包含三个变量中的两个，求另外一个，并且单位会有三种前缀m(毫)，k(千)，M(兆)。

题解：字符串扫描。

gets读入字符串，进行一次遍历，查找是否包含子串’P=’, ‘U=’, ‘I=’, 格式化它后面的数字，需要用double来存，然后检查单位前缀，m需要将原值除上103，k需要将原值乘上103，M需要将原值常上106。然后分三种情况计算未知的那个值即可。

B. Balancing Bank Accounts

PKU 2257 http://poj.org/problem?id=2257

题意：给定N(N <= 20)个人，以及M(M <= 1000)条关系，每条关系的描述为nameA nameB C，表示nameA这个人给了nameB这个人C块钱，为了让所有人都不亏，需要再给出至多N-1条关系，使得所有人都收支平衡。

题解：贪心。

首先将所有人分成两堆，from_set表示收入大于支出的人的集合，to_set表示支出大于收入的人的集合，并且记录他们各自的 |收入-支出|，然后对于所有的from_set的人按 |收入-支出| 进行递增排序，枚举每个from_set中的人f，去to_set中找到一个人t，满足f剩余的钱小于等于t亏损的钱，并且t是to_set中亏损最少的人，如果找不到这样的人，那么找到亏损最多的那个人，将f的钱给t，循环往复，直到f的钱给完为止。

当from_set中的所有人将钱全部给了to_set中的人后，to_set中也就没有人亏损了，所有人达到收支平衡。

C. The Settlers of Catan

PKU 2258 http://poj.org/problem?id=2258

题意：给定一个N(N <= 25)个点，M(M <= 25)条边的图，求图的最长路，点允许重复，边不允许重复。

题解：前向星 + dfs。

利用前向星存双向边，以每个点为起点深搜遍历整个图，访问过的边哈希，搜索过程更新最长路即可。

D. Team Queue

PKU 2259 http://poj.org/problem?id=2259

题意：Team Queue是这样一种queue，每个元素都有一个Team。

对于queue的push操作，被push的元素从queue中从头到尾扫描，如果扫到一个元素和它属于同一个Team，那么直接将它插入到这个元素后面；如果没有扫到，直接插到对列尾。

对于queue的pop操作，等同于普通queue的pop操作。

队伍数N小于等于1000。

题解：模拟，开1000个队列。

对于插入操作，每个Team的元素插入到对应的队列中，并且记录当前Team的最早插入时间。O(1)

对于弹出操作，枚举所有Team的队列首元素，从中找时间最早的，然后对那个队列执行弹出操作。O(N)。

E. Error Correction

PKU 2260 http://poj.org/problem?id=2260

题意：给定N*N(N < 100)的01矩阵，问是否所有 行和 和 列和 都是偶数，如果是输出OK，如果不是，是否能够通过改变一个值保证 都是偶数， 都不行输出Corrupt。

题解：扫描。

扫描所有 行和 和 列和，如果正好有其中一行R是奇数，并且其中一列C是奇数，那么改变(R, C)的值就能保证全是偶数，否则要么是OK，要么是Corrupt。

F. France '98

PKU 2261 http://poj.org/problem?id=2261

题意：给定16个国家进行淘汰赛，以及一个16*16的矩阵A，其中A[i][j]表示i号国家打败j号国家的概率，问每个国家取得冠军的概率。

题解：动态规划。

dp[0][i]   表示 1/2决赛 第i个人获胜的概率

dp[1][i]   表示 1/4决赛 第i个人获胜的概率

dp[2][i]   表示 1/8决赛 第i个人获胜的概率

dp[3][i]   表示  总决赛 第i个人获胜的概率 

1) 那么显然dp[0][i] = A[i][i^1]

2) dp[1][i]的概率取决于1/2决赛时第i个人获胜的概率乘上他打败1/4决赛中同组的那两个人的概率；

3) dp[2][i]的概率取决于1/4决赛时第i个人获胜的概率乘上他打败1/8决赛中同组的那四个人的概率；

4) dp[3][i]的概率取决于1/8决赛时第i个人获胜的概率乘上他打败 总决赛中同组的那八个人的概率；

直接递推求解，dp[3][i]就是所求。

G. Goldbach's Conjecture

PKU 2262 http://poj.org/problem?id=2262

题意：将一个数分解成两个奇素数的和。

题解：素数筛选，枚举。

H. Heavy Cargo

PKU 2263 http://poj.org/problem?id=2263

题意：给定一个有向图，边权W(u, v)表示从u到v的最大载重为W(u, v)，在给定s和t，求s到t 的最大可能载重。

题解：二分答案 + 判断连通性。

二分枚举答案T，然后从起点到终点进行连通性判定，如果边权小于T的边不可达，二分的最大值就是答案。

A. Constellations

PKU 3690 http://poj.org/problem?id=3690

题意：给定N*M(N<=1000, M <= 1000)的01矩阵S，再给定T(T <= 100)个P*Q(P <= 50, Q <= 50)的01矩阵，问P*Q的矩阵中有多少个是S的子矩阵。

题解：位压缩 + KMP

由于P <= 50，所以我们可以把所有P*Q的矩阵进行二进制位压缩，将P*Q的矩阵的每一列压缩成一个64位整数，这样P*Q的矩阵就变成了一个长度为Q的整数序列，用同样的方式对N*M的矩阵进行压缩，总共可以产生(N-P+1)个长度为M的整数序列，剩下的就是进行最多(N-P+1)次KMP匹配了。

       KMP相关算法可以参阅：

http://www.cppblog.com/menjitianya/archive/2014/06/20/207354.html

图1 ‘*’代表二进制的1, ’0’代表二进制的0

B. DNA repair

       PKU 3691 http://poj.org/problem?id=3691

       题意：给定N(N <= 50)个长度不超过20的模式串，再给定一个长度为M(M <= 1000)的目标串S，求在目标串S上最少改变多少字符，可以使得它不包含任何的模式串（所有串只有ACGT四种字符）。

       题解：AC自动机 + 动态规划

利用模式串建立trie图，trie图的每个结点(即下文讲到的状态j)维护三个结构，

Node{

              Node *next[4];   // 能够到达的四个状态 的结点指针

              int  id;         // 状态ID，用于到数组下标的映射

              int  val;        // 当前状态是否是一个非法状态 （以某些模式串结尾）

}

用DP[i][j]表示长度为i (i <= 1000)，状态为j(j <= 50*20 + 1)的字符串变成目标串S需要改变的最少字符，设初始状态j = 0，那么DP[0][0] = 0，其他均为无穷大。从长度i到i+1进行状态转移，每次转移枚举共四个字符(A、C、G、T)，如果枚举到的字符和S对应位置相同则改变值T=1，否则T=0；那么有状态转移方程 DP[i][j] = Min{ DP[i-1][ fromstate ] + T, fromstate为所有能够到达j的状态 };最后DP[n][j]中的最小值就是答案。

C. Kindergarten

       PKU 3692 http://poj.org/problem?id=3692

       题意：给定G(G <= 200)个女孩和B(B <= 200)个男孩，以及M(0 <= M <= G*B)条记录(x, y)表示x号女孩和y号男孩互相认识。并且所有的女孩互相认识，所有的男孩互相认识，求找到最大的一个集合使得所有人都认识。

题解：二分图最大匹配

一个点集中所有人都认识表示这个点集是个完全图，该问题就是求原图的一个最大团(最大完全子图)，可以转化为求补图的最大独立集，而补图恰好是个二分图。二分图的最大独立集 = 总点数 - 二分图的最大匹配。于是问题就转化成了求补图的最大匹配了。

D. Maximum repetition substring

PKU 3693 http://poj.org/problem?id=3693

题意：给定长度为N(N <= 10⁵)的字符串S，求它的一个最多重复子串(注意：最多重复子串不等于最长重复子串，即ababab和aaaa应该取后者)。

题解：后缀数组 + RMQ

枚举重复子串的长度L，如果对于某个i，有S[i*L ... N]和S[(i+1)*L ... N]的最长公共前缀大于等于L(这一步可以利用后缀数组求解height数组，然后通过RMQ查询区间最小值来完成)，那么以i*L为首，长度为L的子串至少会重复两次。

图2

如图，L=3，i=3的情况，S[3...10]和S[6...10]的最长公共前缀为3，即S[3...5]和S[6...8]完全匹配，所以S[3...5]重复了两次。反之，如果最长公共前缀小于L，必定不会重复（因为两个子串之间出现了断层）。

推广到更一般的情况，如果S[i*L ... N]和S[(i+1)*L ... N]的最长公共前缀为T，那么以S[i*L]为首的重复子串的重复次数为T / L + 1，而且我们可以发现如果以S[i*L]为首，长度为L的子串的重复次数大于等于2，那么它一定不会比以S[(i+1)*L]为首的子串的重复次数少，这个是显然的，比如L为2的时候，ababab一定比abab多重复一次，基于这个性质，我们定义一个new_flag标记，表示是否需要计算接下来匹配到的串(如ababab和abab的情况，前者计算过了，就把new_flag置为false，就不会计算abab的情况了)，得出完整算法：

1) 枚举重复子串的长度L，初始化new_flag标记为true；

2) 枚举i，计算S[i*L ... N]和S[(i+1)*L ... N]的最长公共前缀T；

a) 如果T < L，new_flag标记为true；

b) 如果T >= L，判断new_flag是不是为false，如果为false，说明以S[i*L]为首的串和S[(i-1)*L]为首的串的最长公共前缀大于等于T，跳转到2)；否则转3)；

3) 因为S[i*L, (i+1)*L]有重复子串，但是字典序不一定最小，所以还需要枚举区间 [i-L+1, i+L]，看是否存在字典序更小的子串，比较字典序这一步可以直接使用后缀数组计算出来的rank值进行比较。

       RMQ相关算法可以参阅：

       http://www.cppblog.com/menjitianya/archive/2014/06/26/207420.html

E. Network

       PKU 3694 http://poj.org/problem?id=3694

题意：给定N(N <= 10⁵)个点和M(N-1 <= M <= 2*10⁵)条边的无向连通图，进行Q(Q <= 1000)次加边，每次加入一条边要求输出当前图中有多少条割边。

       题解：无向图割边、最近公共祖先

利用tarjan求出原图的割边，由于这题数据量比较大，所以用递归可能会爆栈，需要栈模拟实现递归过程，tarjan计算的时候用parent[u]保存u的父结点，每个结点进出栈各一次，出栈时表示以它为根结点的子树访问完毕，然后判断(u, parent[u])是否为割边。每次询问u, v加入后会有多少割边，其实就是求u和v的到它们的最近公共祖先lca(u, v)的路径上有多少割边，由于在进行tarjan计算的时候保存了每个结点的最早访问时间dfn[u]，那么有这么一个性质：dfn[ parent[u] ] < dfn[u]，这是显然的(父结点的访问先于子结点)。于是当dfn[u] < dfn[v]，将parent[v]赋值给v，反之，将parent[u]赋值给u，因为是一棵树，所以进过反复迭代，一定可以出现u == v 的情况，这时候的u就是原先u和v的最近公共祖先，在迭代的时候判断路径上是否存在割边，路径上的割边经过(u, v)这条边的加入都将成为非割边，用一个变量保存割边数目，输出即可。

图3

       如图3，图中实线表示树边，虚线表示原图中的边，但是进行tarjan计算的时候7这个结点被(6, 7)这条边“捷足先登”了，于是(4, 7)成为了一条冗余边，计算完后这个图的割边为(1, 2)、(1,3)、(3, 4)、(3, 5)，分别标记bridge[2]、bridge[3]、bridge[4]、bridge[5]为true。

当插入一条边(7, 5)，那么沿着7的祖先路径和5的祖先路径最后找到的最近公共祖先为3(路径为7 -> 6 -> 4 -> 3 和 5 -> 3)，(3, 4)、(3, 5)这两条割边因为加入了(7, 5)这条边而变成了普通边，将标记bridge[4]、bridge[5]置为false。

F. Rectangles

       PKU 3695 http://poj.org/problem?id=3695

       题意：给定N(N <= 20)个矩形，以及M(M <= 10⁵)次询问，询问R(R <= N)个矩形的并。

       题解：离散化 + 暴力( 或 容斥原理 )

       离散化：由于矩形很少，所以可以将它们的XY坐标分别离散到整点，两个维度分别离散，点的总数不会超过2N，对于本次询问，利用前一次询问的结果进行面积的增减，对每个矩形进行判断，一共有两种情况：

1）这个矩形前一次询问出现，本次询问不出现，对它的所有离散块进行自减操作，如果某个离散块计数减为0，则总面积减去这个离散块的面积；

2）这个矩形前一次询问没出现，本次询问出现，对它的所有离散块进行自增操作，如果某个离散块计数累加后为1，则总面积加上这个离散块的面积；

       容斥原理：对于每个询问，利用dfs枚举每个矩形取或不取，取出来的所有矩形作相交操作，所有[奇数个矩形交]的面积和 – 所有[偶数个矩形交]的面积和 就是答案，因为是dfs枚举，所以在枚举到某次相交矩形面积为0的时候就不需要再枚举下去了，算是一个比较强的剪枝。

       如图4，红色区域为被覆盖了一次的区域，橙色区域为被覆盖了两次的区域，黄色区域为被覆盖了三次的区域，那么先将所有的三个矩形加起来，然后需要减掉重叠的部分，重叠的减掉后发现，重叠的部分多减了，即图中黄色的部分被多减了一次，需要加回来。所以容斥原理可以概括为：奇数加，偶数减。

图4

G. The Luckiest number

PKU 3696 http://poj.org/problem?id=3696

题意：给定L(L <= 2*10⁹)，求一个最小的数T，满足T仅由数字’8’组成，并且T是L的倍数。

题解：欧拉定理

首先，长度为N的仅由8组成的数字可以表示为8*(10^N-1)/9。

如果它能被L整除，则可以列出等式(1)：

8*(10^N-1)/9 = KL     (其中K为任意正整数)  (1)

将等式稍作变形得到等式(2)：

(10^N-1) = 9KL/8                            (2)

由于存在分母，所以我们需要先对分数部分进行约分，得到等式(3)：

令A = L/GCD(8, L),  B = 8/GCD(8, L)

(10^N-1) = 9K*A / B                          (3)

因为A和B已经互质，所以如果B不为1，为了保证等式右边仍为整数，K必须能被B整除，而K为任意整数，所以一定能够找到一个K正好是B的倍数，所以可以在等式两边同时模9A，得到(10^N-1) mod (9A) = 0，稍作变形，得到等式(4):

                         (4)       

于是需要引入一个定理，即欧拉定理。

欧拉定理的描述为：若n, a为正整数，且n, a互质，则：

图5

(ψ(n)表示n的欧拉函数，即小于等于n并且和n互素的数的个数)

这样一来，我们发现只要10和9A互质，只需要求9A的欧拉函数，但是求出来的欧拉函数是不是一定使得N最小呢，并不是，所以还需要枚举欧拉函数的因子，如果它的某个因子T也满足(4)的等式，那么T肯定不会比ψ(9A)大，所以T一定更优。

这里9A有可能超过32位整数，所以计算过程中遇到的乘法操作不能直接相乘(两个超过32位整数的数相乘会超过64位整数)，需要用到二分乘法，即利用二进制加法模拟乘法，思想很简单，就直接给出一段代码吧。

H. USTC campus network

PKU 3697 http://poj.org/problem?id=3697

题意：给定N, M(N <= 10⁴, M <= 10⁶)，求N个点的完全图删掉M条边后，和1这个结点相邻的点的数目。

题解：BFS

利用前向星存边(这里边的含义是反的，i和j有边表示i和j不直接连通)。然后从1开始广搜，将和1有边的点hash掉，然后枚举hash数组中没有hash掉的点(这些点是和1连通的)，如果点没有被访问过，标记已访问，入队；然后不断弹出队列首元素进行相同的处理。

这里可以加入一个小优化，将所有点分组，编号0-9的分为一组，10-19的分为一组，20-29的分为一组，然后用一个计数器来记录每个组中的点是否被访问，每次访问到一个点的时候计数器自增，当某个组的计数器为10的时候表示这个组内所有点都被访问过了，不需要再进行枚举了，这样可以把最坏复杂度控制在 O( N*N/10 ) 以下。

A . John

PKU 3480 http://poj.org/problem?id=3480

题意：N堆石子，两人轮流从其中一堆中取任意石子，最后一个取完石子的人输。

题解：博弈。

1) 当所有石子的SG值异或和不等于0时：

a) 个数大于1的堆数=0，必定是奇数个1，所以先手必输；

b) 个数大于1的堆数=1，总能想办法将局面变成奇数个1，所以先手必胜；

c) 个数大于1的堆数>1，总能取掉某些石子，使得所有石子的SG值异或和为0，并且个数大于1的堆数至少还剩两堆；

2) 当所有石子的SG值异或和等于0时：

a) 个数大于1的堆数=0，必定是偶数个1，先手必胜；

b) 个数大于1的堆数=1（不存在）；

c) 个数大于1的堆数>1，无论怎么取，SG值异或和都不可能为0。并且无论先手怎么移，后手可以要么进入偶数个1的状态，要么保持SG值和为0并且非全1的状态（该状态先手必输），所以这种情况，先手必败。

由于1) 的c)情况可以到达2的c)情况，所以1的c)情况为先手必胜点。

B . Double Queue

PKU 3481 http://poj.org/problem?id=3481

题意：给定一些数据(K,P)和一些询问，K为数据值，P为优先级，每次询问输出当前优先级最高或者最低的数据的K的值，询问完删除这个数据。

题解：平衡树。

可以用SLT的set(内部也是平衡树的实现)水过去。

C . ‘JBC’

PKU 3482 http://poj.org/problem?id=3482

题意：进制转换，数字位可以是任何的可见ASCII码，求所有可能进制下的串转换成十进制后的和。

题解：模拟进制转换，模拟大数运算。

D . Loan Scheduling

PKU 3483 http://poj.org/problem?id=3483

题意：给定N(N <= 10000)个任务，每个任务是一个二元组(Pi, Di)，表示如果在[0, Di]的某个时刻内完成则可以得到Pi的利润，每个时间点最多只能有L(L <= 100)个任务，求取一个任务子集来完成的的最大利润总和。

题解：贪心。

初始化每个时间点的可用任务数为L，初始化任务利润和S。

将所有任务按Pi从大到小排序，对于每个任务，从Di到0枚举它的完成时间t，如果t这个时间点还有可用任务，累加Pi到S，并且将t这个时间点的可用任务数减1，枚举完所有任务后S即为所求。

E . Showstopper

PKU 3484 http://poj.org/problem?id=3484

题意：给定一些三元组(X, Y, Z)，一个三元组表示满足X + K*Z <= Y (K = 0, 1, 2, 3 ... ) 的所有正整数 X + K*Z出现了一次。对于多个三元组，保证所有数中至多只有一个数出现奇数次，求这个数以及它出现的次数。

题解：二分答案。

对于出现奇数次的那个数T，那么如果小于T的所有数的和必定是偶数，大于等于T的所有数的和必定是奇数，利用这一点可以二分枚举这个T，然后利用所有小于等于T的数的个数的奇偶性进行二分判定。

对于某个三元组(X, Y, Z)，小于等于T的个数分几种情况讨论：

1) 当T >= Y，个数为 (Y-X)/Z + 1;

2) 当T < X，个数为0;

3) 当 X <= T < Y，个数为 (T-X)/Z + 1;

每次枚举T，将所有区间的数相加判断奇偶性即可。

F . Highway

PKU 3485 http://poj.org/problem?id=3485

题意：给定一条高速公路的长度L(范围为0到L)和N个村庄，要求在高速公路上建一些出口，使得每个村庄到高速公路至少有一个出口的距离不大于D，并且出口总数最少。

题解：贪心。

计算出每个村庄到高速公路距离D范围内的左右区间[Li, Ri]，对这些区间进行排序，排序规则为如果左端点一致则按照右端点递增排序，否则按照左端点递增排序。然后按左端点递增枚举每个区间（每个区间对应一个村庄），对于尚未有高速公路可达的村庄，在其右端点建立一个出口（贪心所在，因为是从左往右扫描，所以在右端点建出口肯定比左端点建更优），然后将它之后的左端点坐标小于这个出口的区间全部hash掉（因为那些村庄可以用这个出口，无须建立新的出口），直到所有区间枚举完毕，出口数也就得出了。

G . Computers

PKU 3486 http://poj.org/problem?id=3486

题意：故事背景是每年都要更换电脑或者进行一次维修，如果换电脑需要c的花费，如果不换电脑，那么第y年到第z年( 1 <= y <= z <= n)的总维修费用为m[y][z]，求经过n年的最小花费。

题解：动态规划。

DP[i]表示经过i年的总开销，假设从第j年开始买了一台新的电脑，一直用到了第i年，那么前j年的总开销为DP[j]，从第j+1年到第i年的维修开销加上购买花费c，即DP[j] + m[j+1][i] + c，DP[i]就是这些开销中的最小值，即。

DP[i] = min{ DP[j] + m[j+1][i] + c, 0 <= j < i };

H . The Stable Marriage Problem

PKU 3487 http://poj.org/problem?id=3487

题意：n(n < 27)对男女，每个男人有对所有女人的好感度，每个女人也有对所有男人的好感度，A对B的好感度记为G(A, B), 求找出一种稳定的婚配关系，使得对于任意一对夫妇X(M, W)，不存在 G(XM, YW) > G(XM, XW) 并且 G(XW, ZM) > G(XW, XM)，并且要求男士优先考虑（即男方如果能找到好的一定不会更差的）。通俗的讲，就是XM更加喜欢别人的老婆，Xw更加喜欢别人的老公，这样的婚姻是不稳定的，双方都有可能出现外遇。

题解：稳定婚姻经典算法。

由于是男士最优，所以需要模拟男士求爱的方式。

用L[i][j]表示i号男子喜欢的第j个女子的编号；

用R[i][j]表示i号女子对j号男子的评分（越大评分越高，且对于确定的i肯定互不相同）；

算法如下：

1) 将所有的男子以及他们向多少个女人求过婚的信息入队，每次弹出一个男子M，找到他下一个要求婚的对象（求婚顺序按照对女生的好感度顺序进行）。

a) 如果当前求婚对象W没有配偶，直接配对，记Match[ W ] = M;

b) 如果当前求婚对象有老公，即Match[ W ]，那么检查M 和 Match[ W ]在W的评分，如果M的评分大于W的老公，则迫使其改嫁，前夫入队，Match[ W ] = M；否则，该男子M继续入队；

2) 反复进行1)直到所有人都找到的对象。

I . Arne Saknussemm

PKU 3488 http://poj.org/problem?id=3488

题意：简单字符串模拟。

题解：根据题意做就行了。

A.Nth Largest Value
       PKU 3781 http://poj.org/problem?id=3781

水题，求10个数中第3大的数。

B.Equal Sum Partitions
       PKU 3782 http://poj.org/problem?id=3782

       题意：给定一个M(M <= 10000)个元素的序列，将它切割成K块，每块的和相等，求最大的K。

       题解：枚举。

       首先，切成K块，每块和相等，那么这个和必定是M个元素总和的一个因子，那么可以枚举第一个块的长度（M种），判断当前块的和是否能被所有数的总和整除，如果可以，顺序判断可行性，看似复杂度是O(M^2)，但是能否整除这个剪枝可以筛选掉绝大部分情况。

C.Balls
       PKU 3783 http://poj.org/problem?id=3783

题意：给定B (B <= 50) 个一样的球，从 M (M <= 1000) 层楼上一个一个往下扔，存在某个楼层K，使得低于它的楼层往下扔球，球不会碎，在第K层扔下去会碎。求最坏情况下，需要扔几次才能确定这个K。

题解：动态规划。

令DP[i][j]表示总楼层为i，持有j个球时，最坏情况需要的次数；

那么如果从k ( 1 <= k <= i) 层进行扔球，有两种情况：

1) 如果球不碎，则还需要进行DP[i-k][j]次测试（向更高的楼层进发）；

2) 如果球碎，那么还可以进行的次数为DP[k-1][j-1] （损失了一个球）；

由于要考虑最坏情况，所以每次测试必须取(1) (2)中的大者+1，每次选定一个楼层，使得这个楼层往下扔球的结果的最大值最小，也即状态转移方程为：

DP[i][j] = Min( DP[i][j],  Max(DP[i-k][j], DP[k-1][j-1]) + 1 );

Pku上有道和这题想法类似的题：http://poj.org/problem?id=1243

D.Running Median
       PKU 3784 http://poj.org/problem?id=3784

       题意：一个长度为M(M <= 9999)的序列，每次奇数位的数读入的时候计算前面整个序列的中位数。

       题解：二分 + 树状数组。

       由于数字是int32范围，所以首先需要将所有数离散到下标，枚举每一个数字读入，将对应位的数字下标插入到树状数组中，每当读到奇数个的时候，利用树状数组的成端求和的性质，如果要找第K大的数，那么就二分一个答案，然后查询树状数组，如果求和大于等于K，表示是一个候选解（因为要保证大于等于K的数最小，才是第K大的数），反复二分，直到找到最小的值V满足sum(V) >= K，时间复杂度O(2 *M * log(M) )。

E.The Next Permutation
      PKU 3785 http://poj.org/problem?id=3785

题意：给定一个可重复元素的排列A[i]，求下一个排列。

题解：从后往前扫描，对于第i个元素A[i]，如果能够找到一个j，使得A[j] > A[i]，并且满足A[j]是继第i位之后最小的数，那么将A[i]和A[j]进行交换，然后将A[i+1]到末尾的元素进行一次不降序排序，最后得到的串就是解。

F.Adjacent Bit Counts
      PKU 3786 http://poj.org/problem?id=3786

题意：求长度为n的二进制整数中，相邻两个1的对数有k对（可重复使用）的整数个数。

题解：动态规划。

令长度为n，相邻1的对数为k的数的个数为DP[n][k]，其中以0结尾的为DP[n][k][0]，以1结尾的为DP[n][k][1]，那么 DP[n][k] = DP[n][k][0] + DP[n][k][1]；

并且有如下状态转移方程：

1) 长度为n-1的二进制数在末尾加上一个0，相邻1的对数不变，所以有：

DP[n][k][0] = DP[n-1][k][0] + DP[n-1][k][1];

2) 长度为n-1的二进制数在末尾加上一个1，相邻1的对数取决于，第n-1位是0还是1，当第n-1位是1，相邻1的对数+1；当第n-1位是0，相邻1的对数不变，所以有：

DP[n][k][1] = DP[n-1][k][0] + DP[n-1][k-1][1];

并且初始状态下DP[0][0][0] = 1,  DP[0][0][1] = 0

G.Convex Hull of Lattice Points

PKU 3787 http://poj.org/problem?id=3787
     题意：凸包。

题解：Graham扫描法求解即可。

H.Interior Points of Lattice Polygons

PKU 3788 http://poj.org/problem?id=3788
     题意：给定一个凸多边形，求它内部所有的水平线段。

题解：从多边形第一个点的y坐标开始，递减枚举水平线段的y坐标，分别和多边形的n条边进行求交点；

1) 如果水平线段和多边形某条边共线，说明正好到了多边形的边缘，无须往下枚举，跳出循环。

2) 如果水平线段和多边形小于一个交点，那么当y轴再次减小的时候，必然没有交点，也无须继续枚举。

3) 否则，将左端点坐标取上整x1，右端点取下整x2，如果x1 <= x2 将它插入到解集中。

       题意：给定一个一维的棋盘，范围为[0, W] (W <= 1000,000,000)，某两个点之间有梯子或虫洞，梯子的下端点到上端点以及虫洞的上端点到下端点花费的步数为0，其它任意点之间的距离通过跳跃来计算，最多每次跳跃不超过S格（S<= 6），跳跃的过程中如果跳到梯子的下端点或者虫洞的上端点就会被直接传送到另一端，并且每次跳跃只能从小的点跳到大的点（虫洞是个例外），求从0到W的最短距离。

图A-1

       题解：

              离散化 + SPFA。

       将所有梯子和虫洞的两端点、0和W以及他们往前往后S步以内的数全部记录下来，梯子和虫洞有P（P <= 40）个，加上起点终点，总共82个点，算上前后各六步，总共82 * 13 = 1066个点，然后将这些点排序后离散化，最后就是要构建一个网络图，通过网络求0到W的最短路，最短路可以用SPFA求解。

       谈谈建图的过程，对于任意两个点，他们之间必定可以连一条边，然后有一个步数表示边的权值（这里的步数也可能是正无穷，也即永远都无法到达）。

       对于任意两个点(u, v)，他们的步数w(u, v)（边权）我们做如下讨论（这里的u、v是离散化后的点）：

       1）如果u是梯子的下端点，v是梯子的上端点 或者 u是虫洞的上端点，v是虫洞的下端点，那么w(u, v) = 0，否则进入2)的判断;

2）如果u的编号大于v，w(u, v) = inf，表示永远不可达，因为某次跳跃只能从小的点跳到大的点，否则进入3）的判断;

3）如果u的实际位置和v的实际位置差值小于等于S，则w(u, v) = 1；

4）检查u和v之间是否有虫洞的上端点或者梯子的下端点，之后将这两种点称为X点

a）如果有，判断他们是否连续，

i) 如果不连续w(u, v) = inf（这一步这么做是为了简单化，试想一下，如果X点不是全部连续，说明u可以先跳到他们中间的某个非X的点，然后再跳到v点，这一步是通过SPFA来实现迭代的，建边的时候可以不考虑）。

ii）如果连续，判断他们连续的格子的数目，如果大于等于S说明这个连续的块必定跳不过去，所以w(u, v) = inf，否则可以先跳到最先的一个X点的前面一个点，然后经过一步S跳跃将这个连续块跳过去，再跳到v。

              b）如果没有X点，那么直接从u点跳到v点。

       这里我们需要计算从a点跳到b点不考虑虫洞和梯子的最短距离，可以贪心的跳，每次往大的跳，直到剩余格子不足S格，即(b-a + S-1) / S （b-a对S求商的上整）。

       边建立完成就可以利用广搜求解0-W的最短路了。

B. Gnome Sequencing
       PKU 3913 http://poj.org/problem?id=3913

       水题，判断三个数是全递增还是全递减还是无序。

C. DuLL
       PKU 3914 http://poj.org/problem?id=3914

       题意：给定一些dll文件和它占用的内存空间，以及一些可执行程序占用的内存空间和它依赖的dll文件，程序以进程为单位，两个相同的程序可能有不同的进程，进行一些下列的操作：

       1）某个程序运行的时候需要它依赖的dll文件也加载到内存中，多个程序可以共用一个dll文件；

       2）某个程序退出的时候，如果它所依赖的dll文件没有其它程序使用，需要释放这段内存空间；

       给定一系列的运行进程，求某个时刻的最大内存占用。

       题解：HASH的简单应用。

       初始化内存占用V = 0，

       对于给定的输入进程：

       1）如果是新运行的进程，将V加上这个进程的内存占用，并将它所有依赖的dll文件检查一遍，如果引用计数为0，则将对应dll文件的内存累加到V上，引用计数+1；

       2）如果是退出进程，将V减去这个进程的内存占用，并将它所有依赖的dll文件检查一遍，如果引用计数为1，则用V减去对应dll文件的占用量，引用计数-1；

       每次操作记录最大的V就是最后的答案。

D. Black Vienna
       PKU 3915 http://poj.org/problem?id=3915

       题意：三个人，每个人五张牌，互相不知道对方的牌，还有额外的三张牌放在一边（所有牌编号为A - R）。每一轮，由 (i-1)%3+1 (1 <= i <= 15) 号玩家进行发问，问Ai  (1 <= Ai <= 3) 号玩家XYZ（代表任意三个牌号）三张牌中有多少张在他手上，然后他回答Bi (0 <= Bi <= 3)，问经过多少轮之后有某位玩家知道 额外 的那三张牌是什么。

      题解：dfs枚举 + 剪枝。

       首先枚举到某个询问i的时候玩家j能够猜出的那三张牌的情况，如果枚举完所有情况最后确定只有一个解满足条件的时候，那个询问的编号i就是答案了。

       类似IDA*的思路，先枚举询问最大深度，如果到达那个询问不能确定额外的那三张牌或者有很多种情况，那么说明还需要更多的询问，迭代深度继续枚举。

       对于某个询问i，找到询问的那三张牌中已经是Ai号选手的数量ansCnt，以及尚未确定牌的归属的牌的数量xCnt，如果已经确定位置的牌数量 大于 实际他回答的数量（ansCnt  >  Bi）或者 尚未确定位置的牌数量 + 已经确定为他的牌数量 小于 实际他回答的数量（ansCnt + xCnt < Bi）都是不合理的情况，剪枝，不用继续往下搜索；

       否则，将(Bi - ansCnt)张牌分配给Ai，(xCnt - (Bi - ansCnt))张牌分配给其它两位玩家以及额外的那一堆，这里需要用到嵌套dfs枚举，枚举完后进入下一个询问的枚举，每次询问的时候可以有几个剪枝：

       1）如果某个阶段某个人的牌数超过5张；

       2）枚举的解的数量超过2个；

       3) 对于一次完全枚举，枚举完所有询问后还是有无法确定三张额外的牌的情况；

E. Duplicate Removal
       PKU 3916 http://poj.org/problem?id=3916

       水题，对输入的元素进行连续判重输出。

F. Rock, Paper, Scissors
       PKU 3917 http://poj.org/problem?id=3917

       水题，剪刀石头布！O_o

G. A to Z Numerals
       PKU 3918 http://poj.org/problem?id=3918

       题意：复杂模拟。（没做出来，#-_-# 样例的98是怎么出来的呀！！！）

H. Cell Towers 
       PKU 3919 http://poj.org/problem?id=3919

       题意：给出一条曲折的连续线段，曲线从起点开始每经过一个长度为1的单位会放置一个守卫K，在曲线以外的某些地方会有T(T <= 10)个信号发射器，用A、B、C...来表示，每个信号发射器有它的信号强度Pi，每个信号发射器到守卫K的距离如果是D，那么它能接收到的信号值为Pi / D²的最近整数，并且对于守卫K，它只会接收最大的信号值，如果有多个发射器对于K的信号值相同，那么选择字典序最小的发射器。需要求是一些守卫集合，这些守卫分别和它的前一个守卫所接收的信号发射器不一样。

       题解：计算几何、向量的简单应用。

       对于每条射线，终点减去起点，再单位化后就可以得到这条射线的单位向量，利用这一点可以很简单的将所有守卫的坐标求出来，然后对于每个守卫判断接收的是哪个发射器，判断和之前那个守卫是否相同即可。

       需要注意的是最后一个守卫，当和上一个守卫距离小于0.5的时候不会建立新的守卫。

I. RIPOFF
       PKU 3920 http://poj.org/problem?id=3920

       题意：给定N(N <= 200)个数的一维数组A，取不大于T+2个数，每相邻两个数之间的下标不大于S，问最大的取值总和(第0个和第N+1个数必取，且权值为0)。

       题解：动态规划。

       DP[i][j] 表示第j个数取 A[i]的最大值，那么状态转移方程可以表示为：

       DP[i][j] = max{ DP[k][j-1] + A[i],  i > k > i-1-S && k >= 0};

       特殊的，DP[0][0] = 0，其他的DP[i][j] 都初始化为INF;

       最后计算出的DP[N+1][i]中的最大值就是答案了。

       题意：给定一个3X3的六面魔方（每个面有3X3个块），求经过某些旋转之后能否使得所有面的颜色都相同，旋转包括对某个面进行顺时针和逆时针旋转（共12种情况）。

图A-1

       如图1，输入数据为左图的形式，右图给对应的面编号，箭头方向为顺时针旋转方向。

+A表示对A这个面进行一次顺时针旋转，-B表示对B这个面进行一次逆时针旋转。问经过一定的+A/-B操作之后能否使得所有面的3X3个字母都相同。

       题解：模拟题

       做法很多，这里介绍一种比较容易理解的状态记录方式，考虑某次旋转，一定是旋转某个面，然后对邻接的四个面的某条边进行顺次平移。如图A-2, 2号面的旋转带动的是1、5、3、6四个面。

图A-2

       我用一个数组rotate_n来记录某个面旋转的时候带动的面的编号集合（编号为0的数据为占位符），那么有：

int rotate_n [7][4] = {

    {0, 0, 0, 0}, {4, 5, 2, 6}, {1, 5, 3, 6}, {2, 5, 4, 6}, {3, 5, 1, 6}, {1, 4, 3, 2}, {1, 2, 3, 4}

};

       光记录带动的面是哪些还不够，还需要知道带动面的对应边，对于一个魔方的一个面，我们编号如下：

（0,0）（0,1）（0,2）

（1,0）（1,1）（1,2）

（2,0）（2,1）（2,2）

       分别用1到4来代表一个面的四条边（注意，有方向）：

1 (0,2) - (0,0)

2 (2,2) - (0,2)

3 (2,0) - (2,2)

4 (0,0) - (2,0)

       那么同样用rotate_p来记录某个面旋转的时候带动的面对应的边，则有：

int rotate_p[7][4] = {

       {0, 0, 0, 0}, {2, 4, 4, 4}, {2, 3, 4, 1}, {2, 2, 4, 2}, {2, 1, 4, 3}, {1, 1, 1, 1}, {3, 3, 3, 3},

};

       这样一来，我们只需要考虑一个面的旋转，然后套用对应的数据即可，还有一个比较巧妙的是，逆时针旋转不需要特殊处理，直接将顺时针旋转执行三次即可。

B．This Sentence is False
       PKU 1291 http://poj.org/problem?id=1291

       题意：给定一些句子形如“Sentence X is true/false”的句子，X表示第几个句子，问所有的情况是否合法，如果合法，输出最大的可能为真的句子。

       题解：2-sat。

       每个句子抽象成两个结点，为真的时候为X，为假的时候为X '。

       a) 对于第X个句子，如果是 Sentence Y is true；

              则这个句子为真的时候， X ->Y连边；

              当这个句子为假的时候，X ' -> Y '连边；

       b) 对于第X个句子，如果是 Sentence Y is false；

              则这个句子为真的时候， X ->Y '连边；

              当这个句子为假的时候，X ' -> Y连边；

       然后求一次强连通，如果最后有某个点X和X ' 在同一个连通图中，说明逻辑错误，说明必然存在不合法的情况，否则对于每个连通分量，求出为真的点的个数和为假的点的个数，然后将他们之中的大者累加，最后答案除2就是最大的可能为真的句子（除2的原因是因为真假是对称的）。

C．Will Indiana Jones Get There?
       PKU 1292 http://poj.org/problem?id=1292

       题意：营救公主，营救路线要么绕着墙走，要么走两面墙的最短距离（这种情况下需要在两面墙之间搭一块木板，并且可以反复使用）。问营救过程中木板的最短长度。

图C-1

       题解：线段距离 + 二分答案

       因为木板可以反复使用，所以我们可以假设如果木板越长，能够营救公主的概率就越大，反之则越小，所以问题就是求满足两点可达的最小木板长度，可以二分枚举这个长度T，如果两面墙的最短距离大于这个T，表明两面墙不可达，将墙抽象成点，两面墙之间的最短距离可以通过线段和线段的最短距离预处理出来，然后每次二分答案后通过一次搜索就可以找出起点和终点是否可达，复杂度为O（n^2）即计算两线段距离时候的复杂度。

D. Duty Free Shop
       PKU 1293 http://poj.org/problem?id=1293

       题意：给定M(M <= 1000)个白巧克力和L(L<= 1000)个黑巧克力，然后给定N(N <= M + L)个容量为Ci的盒子，问能否找到一种方案，使得某些盒子放满白巧克力，剩下的盒子放满黑巧克力。

       题解：背包问题。

       由于需要将每个盒子都放满，于是可以利用一维背包的求法将Ci的所有小于等于M的可行组合求出来，找到最大的M ' <= M，并且M ' 能够通过某种方式被组合出来，那么所有盒子的容量Sum 减去 M ' 的差小于等于L的话，必定能将剩下的盒子填满黑巧克力，否则无解。

       这题需要记录前驱，并且注意M = 0 以及 L = 0 的情况（主要是在输入的时候判断退出条件，M+L==0退出而并非 (M&&L) == 0）。

E．Not Too Convex Hull
       PKU 1294 http://poj.org/problem?id=1294

       题意：给定N(N<=101)个点（没有三点共线的情况），要求用B(B<=50)根皮条将这N个点圈成B个部分，每个部分为一个凸多边形，并且所有凸多边形公用一个点（这个点会给出），求众多方案中满足所有多边形面积和最小的方案。图E-1表示用两根皮条圈住19个点的情况（原点共用了两次）。

图E-1

       题解：环形动态规划。

       首先将所有点按照给定的原点进行极坐标排序，那么第1个点到第N个点必定是按照极坐标严格逆时针排布的（因为没有三点共线），用DP[i][b]表示第i个点到第N个点经过b次分割后分割完的凸多边形的面积总和最小值，那么：

DP[i][b] =min{ area[i][k] +DP[k+1][b-1]   (i < k < N) }; 特殊的，DP[0][0] = 0;

     area[i][j] 表示极坐标在第i个点和第j个点之间的所有点(包含这两个点)加上原点组成的凸包的面积，可以通过初始化预处理出来；

     由于点是极坐标排列的，也就是第一个点不一定是凸包边上的点（有可能是第N-1个点到第2个点组成的凸包达到整体最优），所以需要做N次DP，可以将所有点复制一份，枚举起点i ( 1 <= i <= N)，终点即i+N, 然后分别做一次DP取最小值。

     时间复杂度O(N^2 * B)。

F．I hate SPAM, but some people love it
       PKU 1295 http://poj.org/problem?id=1295

       题意：N(N<=20)个人互发邮件，某个人收到邮件后一定会回复给他所有的好友，回复的数量决定他的称号，按顺序给定首先发起邮件的人，要求按顺序输出所有人得到的称号。

       题解：深搜枚举。

       数据量很小，对于给定的初始者作为起点进行遍历，每个人只访问一次，访问到的时候根据他的朋友数量计算他的称号即可。

G．Noise Effect
       PKU 1296 http://poj.org/problem?id=1296

       题意：给定两个正方形矩阵，求他们的最大相似度，相似度的定义为矩阵元素对应位差值小于等于100的个数占所有矩阵元素的百分比（可以进行旋转和翻转）。

       题解：模拟题。

       每个矩阵可以进行四次旋转，每次旋转可以有水平翻转、竖直翻转、水平竖直翻转、保持原样四种状态，一共十六种情况（实际小于16种，因为有些状态经过翻转和旋转之后是一样的），对每种情况模拟计算相似度取最大值即可。

H．Supermarket
       PKU 1297 http://poj.org/problem?id=1297

       题意：约翰需要买M(M<=100)件物品，超级市场上的物品都排成一排，一共N(N<=100000)件物品，他从左向右开始选物品，但是为了不麻烦，不想走回头路，而且第i个物品买的条件是，前i－1个物品必须已经买了，但是每个物品在超级市场中的价格不一样，即使同一个物品也有不同的价格，为了花费最少，他想要一个方案使得：

       1) 按顺序购买M个物品；

       2) 总价值最少，并输出这个最小值，如果方案不存在，输出Impossible。

       题解：动态规划。

       DP[i][j]表示第i个购买列表中的物品和第j个市场中的物品匹配时的最小消费（1<=i<=M,1<=j<=N）;

       Min[i][j]表示min{ DP [i][x]  x<=j };

    a)当第i个物品和第j个市场物品编号相同时，DP[i][j] = Min[i-1][j-1] +cost[j];

       b)否则DP[i][j] = inf; 计算DP数组同时更新Min数组，由于每次的状态最多和上一行有关，所以在进行状态转移的时候可以采用滚动数组。时间复杂度O(NM)。