对动态规划（Dynamic Programming）的理解：从穷举开始(转)
转自：http://janfan.cn/chinese/2015/01/21/dynamic-programming.html
动态规划（Dynamic Programming，以下简称dp）是算法设计学习中的一道槛，适用范围广，但不易掌握。
笔者也是一直不能很好地掌握dp的法门，于是这个寒假我系统地按着LRJ的《算法竞赛入门经典》来学习算法，对dp有了一个比过往都更系统＼更深入的理解，并在这里写出来与大家分享。
笔者着重描述的是从穷举到dp的算法演进，并从中获取dp解法的思路，并给出多种思考的角度，务求解决的是LRJ提出的一种现象：
“每次碰到新题自己都想不出来，但一看题解就懂”的尴尬情况。
DP与穷举
大多讲dp的文章都是以0-1背包为基础来讲解的，笔者想换个花样，以另一道题“划分硬币”（UVa-562 Dividing coins）来讲述。
现在有一袋硬币，里面最多有100个硬币，面值区间为[1, 500]，要分给两个人，并使得他们所获得的金钱总额之差最小，并给出这个最小差值。
这种问题笔者称之为二叉树选择问题。 假设袋中有N个硬币，我们从最原始的枚举法来一步步优化。
我们让其中一个人先挑硬币，挑剩的就是给另外一个人的。 第一个人对于每一个硬币，都有“选”和“不选”两种选择。 我们很容易穷举他全部的情况——全部硬币的任意大小的子集，共2N
种，并选取其中两人差值最小的解。
具体作法可以用递归法，二进制法等。 在这里给出笔者的递归解法的代码，因为它与后面的优化紧密关联。
int solve_by_brute_force(vector<int> &v, int cur, int limit, int sofar, int sum) {
if (cur == limit) { // the border of recursion
int other = sum - sofar;
return sofar>other? sofar-other : other-sofar;
}
// choose or not the current coin
int ans1 = solve_by_brute_force(v, cur+1, limit, sofar+v[cur], sum);
int ans2 = solve_by_brute_force(v, cur+1, limit, sofar, sum);
return ans1 < ans2? ans1 : ans2;
}
int main(){
int t;
cin >> t;
for (int nc= 0; nc<t; nc++) {
int m;
cin >> m;
vector<int> v(m);
int tot = 0;
for (int i= 0; i<m; i++) {
cin >> v[i];
tot += v[i];
}
int res = solve_by_brute_force(v, 0, m, 0, tot);
cout << res << endl;
}
return 0;
}
O(2N)
的指数复杂度始终是撑不过去的，我们需要优化，但从哪里开始优化呢？
我们以测试样例“2 3 5”来看看，下图是样例的穷举解答树，左树为不选当前硬币，右树为选入，叶结点为第一个人的硬币总额。
root
/ \
2 / \
/\ /\
3 / \ / \
/\ /\ /\ /\
5 / \/ \/ \/ \
0 5 5 2+3+5
可以看到，叶结点中有两个相同的值，思考一下，如果再多加一个硬币（解答树变成4层），相同的叶结点会引起无谓的重复计算，造成浪费。
我们从1到N逐个做硬币的选择决策
以树的结构来记录当前硬币的累计金钱（中间结果）是低效的，因为它允许存在值相同的结点。 我们思考，那么我们何不换一种方式来记录中间结果呢？我们何不采用数组的方式？假设一袋硬币存在int Coins[]数组中，中间结果的范围是可求的，区间为[0, Coins[0]+Coins[1]+..+Coins[cur]]，或者干脆是全部硬币的总和[0,SUM]
。
以树分叉的方式来做决策也是可以改变的。改变中间结果的记录方式后，我们可以这样来递推： 假设有一个二维数组bool mat[N+1][SUM+1]，第一维表示当前已选择到第几个硬币，第二维表示中间结果，比如mat[3][10]表示在“2, 3, 5”样例中，我们选择到第3个硬币（最后一个），并且中间结果（正好是最后的叶结点）为10的情况，如果为true，则这种情况成立，是存在的，否则不存在，比如mat[3][9]，你是拼不出和为9的情况的。 这时递推公式变为mat[cur][i] |= mat[cur-1][i-Coins[cur]]，我们只要在每个硬币（每层）把i在区间[0,SUM]
枚举一遍就可以了。
这个方法的完整代码：
const int MAX_SUM = 100000;
bool arr[MAX_SUM];
int solve_by_dp(vector<int> &v, int sum) {
fill(arr, arr+MAX_SUM, false);
arr[0] = true;
for (int i= 0; i<v.size(); i++) {
for (int j= v[i]; j<=sum; j++) {
if (arr[j-v[i]])
arr[j] = true;
}
}
int mid = sum/2;
for (int i=0; i<=mid; i++) {
int one = mid-i;
if (arr[one]) {
int other = sum - one;
return other>one? other-one : one-other;
}
}
return -1; // never been here
}
这样复杂度变为\(O(NSUM)\)，即\(O(500N^2)\)，从指数降到多项式了。 而空间复杂度，考虑到可以当前硬币的中间结果，只与上一层有关，我们使用滚动数组的方法就可以避免开一个二维数组的耗费了。
其实中间数组的每个元素，就是dp中的“状态”。 对dp的理解首先要从枚举开始，发现穷举过程中做无用功的地方，改变记录和递推的方式去优化它。 关于格举的解答树和dp的状态之间的关系，LRJ有一个很好的总结。
状态及其转移类似于回溯法听解答树。解答树中的“层数”，也就是递归函数中的“当前填充位置”cur，描述的是即将完成的决策序号，在动态规划中被称为“阶段”。
如何寻找DP的思路
在做题的时候，我有意识地注意对自己dp的思路寻找过程，而不满足于单纯地套模板。
我往往先考虑最朴素的穷举思路，并努力发现隐藏其中的“最优子结构”，寻找子问题的递推关系。 我相信这也是LRJ在书中按“穷举－分治－dp”的顺序编排章节的原因。
LCS问题（Longest Common Sequence）
比如一个典型的dp问题——LCS（Longest Common Sequence），求两个字符串的最长公共子串（不要求连续），比如这道题UVA - 10405。
假设两个字符串为a, b，最后结果为子串s，按枚举的思路，对a的每一个字符进行枚举，假设它作为公共子串的首字符，并在b中从左往右寻找与它相同的字符，假设a[i]==b[j]，这样就得出子问题——现在问题变成了求a, b匹配字符的后缀的LCS，即lcs(a+i+1, b+j+1)。 文字描述不仔细，请看看代码。
// example
// string a = “a1b2c3d4e”, b = “zz1yy2xx3ww4vv”;
// cout << lcs(a, b, 0, 0, 0);
int lcs(string &a, string &b, int ia, int ib, int cur) {
int max = cur;
for (int i= ia; i<a.length(); i++) {
char c = a[i];
int j;
for (j= ib; j<b.length(); j++) {
if (c == b[j])
break;
}
if (j == b.length()) continue;
int ans = lcs(a, b, i+1, j+1, cur+1);
if (ans > max) max = ans;
}
return max;
}
上述的代码复杂度非常大，原因在于相同的lcs(a, b, i, j, cur)可能会被多次调用，比如lcs(a, b, 3, 4, 1)和lcs(a, b, 3, 4, 2)（数据乱编的），它们的目的都是相同的——想求得lcs(a+i, b+j)。 发现穷举过程中隐藏的子模式＼子问题之后，可以把中间结果先算出来，并且它们正好可以存在一个二维表中，代码如下。 这就是LCS问题的思考过程了。
const int N = 100;
int mat[N][N];
int lcs_dp(string &a, string &b) {
fill(&mat[0][0], &mat[0][0]+N*N, 0);
for (int i= a.length()-1; i>=0; i--) {
for (int j= b.length()-1; j>=0; j--) {
int &cur = mat[i][j];
if (a[i] == b[j])
cur = 1 + mat[i+1][j+1];
else
cur = mat[i][j+1]>mat[i+1][j] ? mat[i][j+1] : mat[i+1][j];
}
}
return mat[0][0];
}
有些子问题也穷举思路中也许不明显，需要读者自己去寻找一个划分点，然后创造重叠子问题。 本节问题的划分点是公共子串的第一个字符，再如“表达式链”问题（如UVA - 348）的划分点则是“最后一次运算”，都可以从穷举的思路中发现问题子模式。
经典的0-1背包问题也是如此，本来每个物品均是两种选择——放和不放，穷举法是用一种二叉树来表示，可以用本文第一节所说的方法来解决——记录并更新全部可能重量的数组。 也可以用另一种递归思路，即从第1个物品开始，放和不放，影响的是背包的剩余容积，很容易可以构造出重叠子问题——在特定容积下，余下的物品可以放入的最大重量。
多阶段决策问题
还有一类dp问题，是多阶段决策中需要“分层”或者“分阶段”的dp问题。
比如找零钱的方案数(UVA - 357)问题。
有$50, $25, $10, $5 and $1不同面值的纸钞，现在给定一个需要找零的金额数$N，问一共有多少种不同的找零方法。
如果按照上节所说的穷举方法，我们很容易得到一个4叉树（有4种面值的纸钞），这棵树一直延伸发散，直到从根结点到叶结点的路径总和等于或大于N才停止，然后统计路径总和为N的路径数。
但这个穷举思路有问题，比如现在N=15，穷举树先伸出5再伸出10，和先伸出10再伸出5，都可以达到路径和为15，并算作两条路径，但其实它们是等价的。 这类问题需要加入一个“先后顺序”的概念，LRJ的原话是：
原来的状态转移太敌了，任何时候都允许使用任何一种物品，难以控制。为了消除这种混乱，需要让状态转移（也就是决策）有序化。
我们可以从每种硬币的个数上进行穷举，代码如下。
int coins[] = {1, 5, 10, 25, 50};
int count_ways(int n) {
int i1, i5, i10, i25, i50;
int cnt = 0;
for(i1= 0; i1<=n; i1++) {
for(i5= 0; i5*5<=n; i5++) {
for(i10= 0; i10*10<=n; i10++) {
for(i25= 0; i25*25<=n; i25++) {
for(i50= 0; i50*50<=n; i50++) {
int tmp = i1 + i5*5 + i10*10 + i25*25 + i50*50;
if (tmp == n) cnt++;
}
}
}
}
}
return cnt;
}
同样是穷举，不同之处在于第二种方案中有“顺序”＼“层”＼“阶段”的概念，各种硬币并不允许随时被加入最终的总和。 不像第一种方案，为了得到$15，可以按$5+$10和$10+$5多种顺序得到，第二种只能是$5+$10，不会重复。
反映在dp方法上，我们也得做出改变，我们要依次记录不同阶段的中间结果——用arr[N]表示N有多少种拼溱方法，只用$1硬币计算一遍，再加上$5硬币计算一遍，再加入……直到5种硬币都加入了，最终结果就出来了，而且结果不会重复。
const int N = 1000;
int arr[N];
int count_ways_dp(int n) {
fill(arr, arr+N, 0);
arr[0] = 1; // initialization
for (int i= 0; i<NCOINS; i++) {
for (int j = coins[i]; j<=n; j++) {
arr[j] += arr[j-coins[i\\);
}
}
return arr[n];
}
“阶段”只是帮助我们思考的，在动态规划的状态描述中最好避免“阶段”＼“层”这样的术语。
用这种方式来描述“阶段”这种概念，笔者也略感到勉力，希望各位看官能反馈回来更好的见解。
最后的话
笔者的算法学习经历并不多，大一的时候读了半本《算法概论》，选了一门水水的算法课（作用几可忽略＝＝），课余参加过一些Codeforces的在线比赛，最认真的，就是这个大学最后的寒假闭关在家按着LRJ的《算法竞赛入门经典》苦练一番，收获颇丰，而其中以dp为最难，故才有此一文来总结这个寒假的算法学习。
不得不说，整个算法的思考过程对我来说很不容易。以在Quora看来的一句与算法（数学）学习相关的话跟诸君共勉。
Most people simply don’t put in the time to make something intuitive.
参考资料
算法竞赛入门经典
