POJ2279 五维线性dp

POJ2279 五维线性dp(动态规划入门)

题面
POJ2279题面

思路
从头开始系统的学dp，做题目一定要理清dp的五大因素

状态表示	用dp[$a_1,a_2,a_3,a_4,a_5$]表示第i行上已经插入了$a_i$个人的排队方法数
阶段划分	已经在各排分配了制定人数的方法数(对应一个五元组)
转移方程	写不下了^ _ ^下面单列
边界	dp[0,0,0,0,0]=1,其余均为0
目标	dp[$k_1,k_2,k_3,k_4,k_5$]

转移方程及其理解：
$$dp[a_1,a_2,a_3,a_4,a_5]=\{\begin{array}{l}dp[a_1,a_2,a_3,a_4,a_5]+dp[a_1-1,a_2,a_3,a_4,a_5](a_1\ge 1and{a}_1\le k_1)\\ dp[a_1,a_2,a_3,a_4,a_5]+dp[a_1,a_2-1,a_3,a_4,a_5](1\le a_2\le a_{1}and{a}_2\le k_2)\\ ⋮\\ dp[a_1,a_2,a_3,a_4,a_5]+dp[a_1,a_2,a_3,a_4,a_5-1](1\le a_5\le a_{4}and{a}_5\le k_5)\end{array}$$
其实状态的寻找是不好做的，对于最终目标，如何找出表示目标的维度，如何分解问题，使其在求解每个子问题的"阶段"都具有"子问题重叠性"，“无后效性"和"最优子结构性质”。

性质	解释
子问题重叠性	问题可划分成多个子问题，并且子问题具有相似性，可以归纳
无后效性	已经求解的子问题不受后续阶段的影响
最优子结构性质	下一阶段的最优解能够由前面各阶段的子问题的最优解导出

这三个性质是判断寻找的状态是否具有动态规划条件的性质。
能想到的是，对于一个人的状态肯定可以计算，用一个人算两个人的状态也可以算，而后面的状态加一个人好像也可以算，仔细想一下，如果自己打个表的话，可以从1开始人数一个一个向上推(其实就是动态规划的模拟),想到这种模拟，基本上三个性质都具备了(请读者自行思考)，如果想到人数为维度的话，为了能够表示每一排的情况，容易想到用五元组表示状态的方法。
对于初态，如果五个空都没有一个人的话，肯定默认只有一种排法，所以dp[0,0,0,0,0]=1，对于刚刚所谓的一个人一个人地向上推，其实就是对于当前状态对于五元组每一个元讨论少一个人的情况，假设我们插人是从低到高插入的，那个人排在哪一排反正是从低到高排肯定在是固定的在排首的，其实就是其他人的站位影响了照相顺序，也就是加上其他人站位的方法数即可(就是$+dp[a_1,a_2-1,a_3,a_4,a_5]$这类的原因 )，但是这保证了每一排是从低到高，但要保证每一列从低到高，那就要当第i-1排比i排少人的时候，就不能排在第i排，因为下面总有一个更高的要插在i-1排，就不是从低到高了，同时还要满足插人不多于给出的限制，那就是$(1\le a_i\le a_i-1and{a}_i\le k_i)$了呗

注意事项
1)dp一般0数组的0轴是初态，所以一般循环要<=限制，答案访问上界而不是上界-1
2)要注意数组(无向图)的遍历的范围，不要少了也不要越界
3)函数内部按大小直接声明dp数组，否则会MLE(C++14以上的编译器数组可以直接用变量声明)

代码

//这个是按照上面的转移方程写的，是在此状态访问上一次状态的情况
#include <iostream>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxn = 31;

int nk[6];

int main()
{

    int k;
    while(cin >> k && k)
    {
        memset(nk,0,sizeof(nk));
        for(int i = 0;i <k;i++)
        {
            cin >> nk[i];
        }
        ll dp[nk[0]+1][nk[1]+1][nk[2]+1][nk[3]+1][nk[4]+1];
        memset(dp,0,sizeof(dp));
        dp[0][0][0][0][0] = 1;
        for(int i = 0;i <= nk[0];i++)
        {
            for(int j = 0;j <= nk[1];j++)
            {
                for(int p = 0;p <= nk[2];p++)
                {
                    for(int l = 0;l <= nk[3];l++)
                    {
                         for(int m = 0;m <= nk[4];m++)
                        {
                            if(i)dp[i][j][p][l][m] += dp[i-1][j][p][l][m];
                            if(j && j <= i)dp[i][j][p][l][m] += dp[i][j-1][p][l][m];
                            if(p && p <= j)dp[i][j][p][l][m] += dp[i][j][p-1][l][m];
                            if(l && l <= p)dp[i][j][p][l][m] += dp[i][j][p][l-1][m];
                            if(m && m <= l)dp[i][j][p][l][m] += dp[i][j][p][l][m-1];
                        }
                    }
                }
            }
        }
        cout << dp[nk[0]][nk[1]][nk[2]][nk[3]][nk[4]]<<endl;
    }
    return 0;
}

//这个是按照令i+1->i写的，就是从此状态计算下一次状态的情况,那不是i>=1了，
//需要在i ==k[1]的时候阻止其进一步向下求，也就是要有(i < n[1])的判断
#include <cstdio>
#include <cstring>
#include <iostream>
typedef long long ll;
using namespace std;
int n[6], k;

void work() {
	for (int i = 1; i <= k; i++) cin >> n[i];
	while (k < 5) n[++k] = 0;
	ll f[n[1]+1][n[2]+1][n[3]+1][n[4]+1][n[5]+1];
	memset(f, 0, sizeof(f));
	f[0][0][0][0][0] = 1;
	for (int i = 0; i <= n[1]; i++)
		for (int j = 0; j <= n[2]; j++)
			for (int k = 0; k <= n[3]; k++)
				for (int l = 0; l <= n[4]; l++)
					for (int m = 0; m <= n[5]; m++) {
						if (i < n[1]) f[i+1][j][k][l][m] += f[i][j][k][l][m];
						if (j < n[2] && i > j) f[i][j+1][k][l][m] += f[i][j][k][l][m];
						if (k < n[3] && j > k) f[i][j][k+1][l][m] += f[i][j][k][l][m];
						if (l < n[4] && k > l) f[i][j][k][l+1][m] += f[i][j][k][l][m];
						if (m < n[5] && l > m) f[i][j][k][l][m+1] += f[i][j][k][l][m];
					}
	cout << f[n[1]][n[2]][n[3]][n[4]][n[5]] << endl;
}

int main() {
	while (cin >> k && k) work();
	return 0;
}