A Za, A Za, Fighting...

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1111

思路:
其实，这是一道简单题，关键是要看透如何求周长: 连通块每格四个方向（上下左右）如果不在连通块内（超出范围或者Empty）则周长加一
DFS或者BFS都可以解决

代码:

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2244

参考:
http://baike.baidu.com/view/213217.html?fromTaglist

思路:
从这题认识了经典的约瑟夫问题:

无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较烦，而且时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。我们注意到原问题仅仅是要求出最后的胜利者的序号，而不是要读者模拟整个过程。因此如果要追求效率，就要打破常规，实施一点数学策略。
为了讨论方便，先把问题稍微改变一下，并不影响原意：

问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号。

我们知道第一个人(编号一定是m%n-1) 出列之后，剩下的n-1个人组成了一个新的约瑟夫环（以编号为k=m%n的人开始）:
  k  k+1  k+2  ... n-2, n-1, 0, 1, 2, ... k-2
并且从k开始报0。

现在我们把他们的编号做一下转换：
k     --> 0
k+1   --> 1
k+2   --> 2
...
...
k-2   --> n-2
k-1   --> n-1

变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如x是最终的胜利者，那么根据上面这个表把这个x变回去不刚好就是n个人情况的解吗？！！变回去的公式很简单，相信大家都可以推出来：x'=(x+k)%n

如何知道(n-1)个人报数的问题的解？对，只要知道(n-2)个人的解就行了。(n-2)个人的解呢？当然是先求(n-3)的情况 ---- 这显然就是一个倒推问题！好了，思路出来了，下面写递推公式：

令f[i]表示i个人玩游戏报m退出最后胜利者的编号，最后的结果自然是f[n]

递推公式
f[1]=0;
f[i]=(f[i-1]+m)%i;  (i>1)

有了这个公式，我们要做的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。因为实际生活中编号总是从1开始，我们输出f[n]+1

由于是逐级递推，不需要保存每个f[i]，程序也是异常简单：

#include <stdio.h>
int main()
{
  int n, m, i, s=0;
  printf ("N M = "); scanf("%d%d", &n, &m);
  for (i=2; i<=n; i++) s=(s+m)%i;
  printf ("The winner is %d\n", s+1);
}

这个算法的时间复杂度为O(n)，相对于模拟算法已经有了很大的提高。算n，m等于一百万，一千万的情况不是问题了。可见，适当地运用数学策略，不仅可以让编程变得简单，而且往往会成倍地提高算法执行效率。

代码:

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1260

思路:
简单DP，但是就是想不到...

代码:

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1179

思路:
这题输在了对原题目的理解和分析上，没能成功地走出第一步:
                                                      将原题解析成对于表达式的求解
把缺了一条边的多边形展开成直线就是一个表达式
注意：为了求乘法，必须同时保存最大值和最小值

f[i][j]记录表达式中从顶点i到顶点j这段子表达式的值

动态规划的思想类似于矩阵连乘

参考:
http://hi.baidu.com/xiehuixb/blog/item/575ec81e221466c1a786699e.html

代码:

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2663

思路:
参考: http://www.tkz.org.ru/2009-07/poj-2663-tri-tiling/

递推题。经典。

本题是POJ2506 Tiling的威力加强版。由两行变成了三行。

推导过程与POJ2506异曲同工。

opt[i]=3*opt[i-2]+2*opt[i-4]+2*opt[i-6]+2*opt[i-8]+……直到方括号内表达式的值为0。

解释一下，3*opt[i-2]是最右边有三行2列的三种情况。

后面的2*opt[i-X]，则是最右边有X列类似以下的结构的情况：

X=4列的情况：；X=6列的情况；等等等等

以上情况可以上下颠倒，故每种情况又有两种表示，所以需要乘以2。而以上的情况从4开始，然后每次递增2，所以递推式中这部分从i-4开始（如果大等于0的话），每次递减2。

如果i为奇数，稍微推一下，可得，奇数的列数无解，答案为0。

代码:

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<string.h>
 4 #define MAX_LEN 31
 5 long table[MAX_LEN];
 6 
 7 void
 8 build_table()
 9 {
10     int i, j, sum;
11     memset(table, 0, sizeof(table));
12     table[0] = 1;
13     table[2] = 3;
14     for(i=4; i<MAX_LEN; i=i+2) {
15         sum = 3*table[i-2];
16         for(j=4; i-j>=0; j=j+2)
17             sum += (table[i-j]<<1);
18         table[i] = sum;
19     }
20 }
21 
22 int
23 main(int argc, char **argv)
24 {
25     int n;
26     build_table();
27     while(scanf("%d", &n)!=EOF && n!=-1) {
28         printf("%ld\n", table[n]);
29     }
30 }

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1157

思路:
比较容易的动态规划，这里提供两种思路，其中第二种更优
另外，居然在写代码的时候将0xFFFFFFFF当作最小的int值，汗...

代码(方案1)

代码(方案2)

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1731

思路:
求全排列，这个问题本身挺简单，不过题目要求: a. 不能重复；b. 有序输出
记得曾经做过这题，当时偷懒用STL过的(真要自己写，估计当时也不会(*^__^*) 嘻嘻……)
现在，决心弃用C++来做题，好好锻炼基本功，所以就硬着头皮自己慢慢写
好在前段时间对于搜索题有了一定的积累，否则相信自己肯定还是不知道怎么写的
找个例子，画出递归调用树，对于理解有很大帮助

纯C递归实现如下:
代码:

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1631

思路:
题意理解清楚，其实就是找出最长上升子序列
这里采用O(nlogn)的算法，类似于贪心的原理，关键是要理解辅助数组aux[]的含义，aux[len]所代表的是组成长度为len的最长上升子序列的尾元素的最小值

下面的内容转自: http://blog.csdn.net/ottoCho/archive/2009/12/02/4927262.aspx
O(n*log n)算法分析如下：

设 A[t]表示序列中的第t个数，F[t]表示从1到t这一段中以t结尾的最长上升子序列的长度，初始时设F [t] = 0(t = 1, 2, ..., len(A))。则有动态规划方程：F[t] = max{1, F[j] + 1} (j = 1, 2, ..., t - 1, 且A[j] < A[t])。 

现在，我们仔细考虑计算F[t]时的情况。假设有两个元素A[x]和A[y]，满足 
(1)x < y < t  (这里应该错了，如果x<y<t成立，那么F[y]>=F[x]+1，不可能有(3)成立，这里应该是y<x<t) [by simplyzhao, 2010-10-19]
(2)A[x] < A[y] < A[t] 
(3)F[x] = F[y] 
此时，选择F[x]和选择F[y]都可以得到同样的F[t]值，那么，在最长上升子序列的这个位置中，应该选择A[x]还是应该选择A[y]呢？ 
很明显，选择A[x]比选择A[y]要好。因为由于条件(2)，在A[x+1] ... A[t-1]这一段中，如果存在A[z]，A[x] < A[z] < a[y]，则与选择A[y]相比，将会得到更长的上升子序列。 
再根据条件(3)，我们会得到一个启示：根据F[]的值进行分类。对于F[]的每一个取值k，我们只需要保留满足F[t] = k的所有A[t]中的最小值。设D[k]记录这个值，即D[k] = min{A[t]} (F[t] = k)。 

注意到D[]的两个特点： 
(1)　D[k]的值是在整个计算过程中是单调不上升的。 
(2)　D[]的值是有序的，即D[1] < D[2] < D[3] < ... < D[n]。 

利 用D[]，我们可以得到另外一种计算最长上升子序列长度的方法。设当前已经求出的最长上升子序列长度为len。先判断A[t]与D[len]。若A [t] > D[len]，则将A[t]接在D[len]后将得到一个更长的上升子序列，len = len + 1， D[len] = A [t]；否则，在D[1]..D[len]中，找到最大的j，满足D[j] < A[t]。令k = j + 1，则有A [t] <= D[k]，将A[t]接在D[j]后将得到一个更长的上升子序列，更新D[k] = A[t]。最后，len即为所要求的最长上 升子序列的长度。 

在 上述算法中，若使用朴素的顺序查找在D[1]..D[len]查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的 时间复杂度为O(n^2)，与原来的算法相比没有任何进步。但是由于D[]的特点(2)，我们在D[]中查找时，可以使用二分查找高效地完成，则整个算法 的时间复杂度下降为O(nlogn)，有了非常显著的提高。需要注意的是，D[]在算法结束后记录的并不是一个符合题意的最长上升子序列！

代码:

 1 /* O(nlogn) algorithm: the longest increasing sub-sequence [LIS] */
 2 #include<stdio.h>
 3 #include<stdlib.h>
 4 #include<string.h>
 5 #define MAX_LEN 40001
 6 int num[MAX_LEN];
 7 int aux[MAX_LEN];
 8 int size, rt_len;
 9 
10 int
11 dp()
12 {
13     int i, left, right, mid;
14     rt_len = 1;
15     aux[rt_len] = num[0];
16     for(i=1; i<size; i++) {
17         if(num[i] > aux[rt_len]) {
18             ++rt_len;
19             aux[rt_len] = num[i];
20         } else {
21             /* binary search: O(logn) */
22             left = 1;
23             right = rt_len;
24             while(left <= right) {
25                 mid = (left+right)/2;
26                 if(num[i]>aux[mid])
27                     left = mid+1;
28                 else
29                     right = mid-1;
30             }
31             aux[left] = num[i];
32         }
33     }
34     return rt_len;
35 }
36 
37 int
38 main(int argc, char **argv)
39 {
40     int i, tests;
41     scanf("%d", &tests);
42     while(tests--) {
43         scanf("%d", &size);
44         for(i=0; i<size; i++)
45             scanf("%d", num+i);
46         printf("%d\n", dp());
47     }
48 }

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1887
http://acm.pku.edu.cn/JudgeOnline/problem?id=2533

思路:
典型而简单的动态规划，类似于最大子段和的思想:

                             f[i]表示以num[i]结尾的最长下降(上升)子序列，那么:
                                  f[i] = max (f[j]+1, if num[j]>num[i] && 0<=j<i)
原本挺简单的代码，一会就写完了，结果却因为一个临时变量的初始化错误而WA了好多次，要细心...
上述是O(n^2)的算法，另外还有O(nlgn)的算法，下回尝试。

代码(pku 1887):