SDAU训练日志第11篇----------动态规划（7）（2018年2月8日）

最新推荐文章于 2021-03-10 17:59:02 发布

SDAU_20175962

最新推荐文章于 2021-03-10 17:59:02 发布

阅读量170

点赞数

本文链接：https://blog.csdn.net/u011590573/article/details/79294328

版权

SDAU训练计划专栏收录该内容

49 篇文章 0 订阅

订阅专栏

今天在网上找了几个DP的讲解视频看，收获不小，整理一下（顺序就不管了）

一、如何判断一个题是不是用DP做：

1.出现最优，最大，最小，最长，价值最高，计数，最多方案数时要考虑是否用DP

2.问题是离散的，容易设计状态例如背包问题，单个物体占的体积等都是整数，如果是实数则一般不能用DP，数组不好表示。

3.满足最优子结构，小的问题规模可以推导出题目要求的问题规模。例如（N-1 -> N）

二、初级阶段实现DP的分析步骤：

1.设计暴力枚举、递归的算法设计问题（不考虑时间复杂度单纯找问题的推导关系，一般会TLE）找到存在冗余的地方。
2.针对冗余设计并存储决策状态（一维、二维等数组）
3.搞出状态转移方程
4.自底向上解决问题计算最优解，变递归为递推。

（搜索的自顶向下便于设计问题，然而代码繁琐，还要细心考虑边界情况）

三、后效性：

一般适合用DP的问题都有后效性，但只有无后效性才能进行运算，所以在设计状态转移方程的时候经过合适的设计使后效性消失才能继续进行使用动态规划。
例如：小偷不能偷相邻两家这个问题中
状态转移方程：
dp[i]=max(dp[i-1],dp[i-2]+value[i])
小偷偷了第i家后产生后效，导致了i-1家无法被偷，通过把子问题变成dp[i-2]，使问题变得无后效性，证明了使用DP的正确性。

注：能用贪心算法解的题天生就是无后效性的，如果小偷去掉不能偷相邻两家的条件，就用贪心。

然后放一个经典的棋盘问题：

1.N*M的棋盘上，某人要从左上走到右下，只能向右或者向下走，问有多少种走法？

//核心代码：
for(int i = 0; i <= N; i++) 
	dp[i][0] = 1;
for(intj = 0; j <= M; j++)
	dp[0][j] = 1; 
for(int i = 1; i <= N; i++) 
	for(intj = 1; j <= M; j++) 
		dp[i][j] = dp[i-1][j] + dp[i][j-1];

2.N*M的棋盘上，某人要从左上走到右下，只能向右或者向下走，其中地图上有若干点不能经过，问有多少种走法？如洛谷dp练习作业#A，P1002过河卒：

棋盘上A点有一个过河卒，需要走到目标B点。卒行走的规则：可以向下、或者向右。同时在棋盘上C点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。

棋盘用坐标表示，A点(0, 0)、B点(n, m)(n, m为不超过20的整数)，同样马的位置坐标是需要给出的。

现在要求你计算出卒从A点能够到达B点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。

//复制了一下别题解，我的这道题过了80%没A掉（5个样例过4个）。。。到现在没找出来哪里有点毛病，先用着别人的

#include<iostream>
#include<cstdio>
#define ll long long
ll a,b,n,m,l[22][22],map_flag[23][23];
using namespace std;
void bj(ll x,ll y)//标记马的控制点
{
    map_flag[x][y]=1;
    map_flag[x-1][y-2]=1;
    map_flag[x-2][y-1]=1;
    map_flag[x-2][y+1]=1;
    map_flag[x-1][y+2]=1;
    map_flag[x+1][y-2]=1;
    map_flag[x+2][y-1]=1;
    map_flag[x+2][y+1]=1;
    map_flag[x+1][y+2]=1;
}
int main()
{
    scanf("%lld%lld%lld%lld",&n,&m,&a,&b);
    bj(a,b);
    l[1][0]=1;//为了把应该有一步的一步给过去
    for(int i=1;i<=n+1;++i)
    {
        for(int j=1;j<=m+1;++j)
        {
            l[i][j]=l[i-1][j]+l[i][j-1];//一个点的路径来自左方与上方
            if(map_flag[i-1][j-1]) l[i][j]=0;//如果被马控制那么是0
        }
    }
    printf("%lld",l[n+1][m+1]);//整体向右下挪一下
    return 0;
}

3.在问题一的基础上改变条件，一次可以在同一个方向上前进2歩。

暴力递归：

int f(int x,int y)
{
	if(x==0||y==0) return 1;
	if(x==1||y==1) return 1;
	return f(x-1,y)+f(x-2,y)+f(x,y-1)+f(x,y-2);
}

动态规划：

//数组下标不能为负数，我们进行特判
for (int i = 0; i <= N; i++)
	result[i][0] = 1;//只能一条路横着过来
for (int j = 0; j <= M; j++) 
    result[0][j] = 1;//只能一条路竖着过来
result[1][1] = result[0][1] + result[1][0];//特判
for (int i = 2; i <= N; i++) 
    result[i][1] = result[i-1][1] + result[i][0] + result[i-2][1];//别忘了从上面走两步过来这种情况
for (int j = 2; j <= M; j++) 
    result[1][j] = result[1][j-1] + result[0][j] + result[1][j-2];//别忘了从左面走两步过来这种情况
for (int i = 2; i <= N; i++) 
	for (int j = 2; j <= M; j++) 
		result[i][j] = result[i-1][j] + result[i][j-1] + result[i-2][j] + result[i][j-2];//状态转移方程
cout<<result[xi][yi]<<endl;//结果输出