动态规划学习 林汝佳

                             动态规划原理解析

     当推出状态转移方程式后。将很容易写出一个三重循环；

     第一层：按一定的顺序计算每个转台；

     第二层：在计算每个状态时考虑不同的递推路径（称为决策数目）；

     最里层：进行每个单独的状态转移。

    算法复杂度 = 状态数 x 决策数目 x 转移费用。

                          动态规划常见模型分析

   线性模型      

                      线性模型是最容易导致动态规划算法的。只要把线性结构分成两部分，往往可以用递归来决解。另一个想法是每次增加一个元素，逐步扩大考虑的范围，下面我举一个典型的例子加以说明。

                                       方块的消除

            题目链接

            其中的决策方法主要有两个：

            一：马上消除，f[i][j-1][0] + (len[j]+k)^2;

           二：如果和前面的若干段一起消除，可以假设这个“若干段”中的最后一段p，则此事的得分是f[i][p][len[j]+k]+f[p+1][j-1][0];

      于是状态转移方程为：f[i][j][k] = max{ f[i][j-1][0] +（len[j] +k）^2,f[i][p][len[j]+k]+f[p+1][j-1][0] };

     其中，color[p] = color[j] (i<=p<j),边界条件是f[i,i-1,0] = 0;

      如果，不处理的话我们可以知道时间复杂度为O（n^4），所以我们可以用到条件color[p] = color[j]用到搜索的记忆化搜索。

     具体实现过程就看下面的代码吧.

 

   

#include <stdio.h>
#include <string.h>
#define max(a,b)(a>b?a:b)

const int MAX = 200 + 10;
int dp[MAX][MAX][MAX];
int block[MAX];

int DFS(int i,int j,int k)
{
    int temp,p;
    if(i > j) return 0;      //递归边界
    if(dp[i][j][k]==-1)    //查看是否搜索过
    {
        dp[i][j][k] = DFS(i,j-1,0) + (k+1)*(k+1);
        for(p = i;p < j;p++)
        {
           if(block[j] == block[p])
           {
                temp = DFS(i,p,k+1) + DFS(p+1,j-1,0);
                dp[i][j][k] = max(dp[i][j][k],temp);
           }
        }
    }
    return dp[i][j][k];
}

int main()
{
    //freopen("Input.txt","r",stdin);
    int T,i,n;
    scanf("%d",&T);
    for(int kase = 1;kase <= T;kase++)
    {
        scanf("%d",&n);
        for(i = 0;i < n;i++)
          scanf("%d",&block[i]);
        memset(dp,-1,sizeof(dp));
        printf("Case %d: %d\n",kase,DFS(0,n-1,0));
    }
    return 0;
}