DP算法的分析（基于一个例题）_dp算法例子

1. 对于DP算法的理解

先看例题：

问题描述
　　小蓝在一个 n 行 m 列的方格图中玩一个游戏。
　　开始时，小蓝站在方格图的左上角，即第 1 行第 1 列。
　　小蓝可以在方格图上走动，走动时，如果当前在第 r 行第 c 列，他不能走到行号比 r 小的行，也不能走到列号比 c 小的列。同时，他一步走的直线距离不超过3。
　　例如，如果当前小蓝在第 3 行第 5 列，他下一步可以走到第 3 行第 6 列、第 3 行第 7 列、第 3 行第 8 列、第 4 行第 5 列、第 4 行第 6 列、第 4 行第 7 列、第 5 行第 5 列、第 5 行第 6 列、第 6 行第 5 列之一。
　　小蓝最终要走到第 n 行第 m 列。
　　在图中，有的位置有奖励，走上去即可获得，有的位置有惩罚，走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值，奖励为正，惩罚为负。
　　小蓝希望，从第 1 行第 1 列走到第 n 行第 m 列后，总的权值和最大。请问最大是多少？
输入格式
　　输入的第一行包含两个整数 n, m，表示图的大小。
　　接下来 n 行，每行 m 个整数，表示方格图中每个点的权值。
输出格式
　　输出一个整数，表示最大权值和。

样例输入
3 5
-4 -5 -10 -3 1
7 5 -9 3 -10
10 -2 6 -10 -4

样例输出
15

 1.1 问题的分析

    从“小蓝可以在方格图上走动，走动时，如果当前在第 r 行第 c 列，他不能走到行号比 r 小的行，也不能走到列号比 c 小的列。同时，他一步走的直线距离不超过3。”这句话，可以感觉到有规律可循！！

所谓的规律，就是某一点的权值 = 前一种（最佳）方法的权值 + 该点的权值。

   上述的最佳方法可以分为4类：

1. 列左移0~3 位；而行不动；

2.列左移0~2位；行确定向下移动1位；

3.列左移0~1位；行确定向下移动2位；

4. 行向下移动3位；而列不动

（注：可能这里有人问，是不是漏了“行向下移动1位，列左移1位的情况”等这类情况；

其实：这类情况全被包含在了2、3两种情况里面。希望读者仔细思考）

1.2 代码（c/c++）

#include<iostream>
#include <algorithm>
#include <math.h>
using namespace std;
 
#define N 102
int dp[N][N];
int weigh[N][N] = {0};  //存储输入的权重值
 
 
void DP(int k ,int f)  //k:行 ; f:列
{
 
    if(k == 1 && f == 1)
    {
       dp[1][1] = weigh[1][1];
    }
    else
    {
 
 
        int max_num = -20000;
 
        for(int i = 1 ; i<= 3 ; i++)  // dp[n][m - 0123]
        {
            if((f - i) > 0 )
                max_num = max(max_num,dp[k][f - i]);
        }
 
        for(int i = 0 ; i<= 2 ; i++)  // dp[n - 1][m - 012]
        {
            if((f - i) > 0 && (k - 1) >0 )
                max_num = max(max_num,dp[k- 1][f - i]);
        }
 
        for(int i = 0 ; i<= 1 ; i++)  // dp[n - 2][m - 01]
        {
            if((f - i) > 0 && (k - 2)>0 )
                max_num = max(max_num,dp[k-2][f - i]);
        }
 
        if((k - 3)>0) // dp[n - 3][m]
        {
            max_num = max(max_num,dp[k - 3][f]);
        }
 
 
        dp[k][f] = weigh[k][f] + max_num;
    }
 
}
 
 
int main()
{
    int n,m;   //确定行和列
    scanf("%d%d",&n,&m);
 
    //输入权重值
    for(int i = 1 ; i<=n ; i++)
        for(int j = 1 ; j<=m ;j++)
    {
        scanf("%d",&weigh[i][j]);
    }
 
    for(int i = 1 ; i<=n ; i++)
        for(int j = 1 ; j<=m ;j++)
        {
            DP(i,j);
        }
 
    /*
    for(int i = 1 ; i<=n ; i++)
   {
        for(int j = 1 ; j<=m ;j++)
            cout << dp[i][j]<< ' '  ;
            cout <<endl;
   }
   */
 
   cout <<dp[n][m];
 
    return 0 ;
}

1.3 总结

对于能够找到前后两个状态之间规律的情况，我们可以考虑用动态规划（DP）算法。该算法主要是寻找 ：后一状态  和 前一状态的联系，并且，前一状态是可以求得结果的。

博主也是新手，想通过这种方式加深自己的影响，如有欠缺的地方，还望读者提醒，我会及时更改！！