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):