DP 开宝箱（简单DP）
题目：
你确定我是来开宝箱不是来比赛的吗？？艾玛，这是哪，天啊，伦家竟然穿越了。
摆在眼前的是1个n*m（0< n<=100&&0< m<=100）的宝箱矩阵，而你就在这个矩阵的左上角也就是入口处。冲啊，开宝箱去，然而脚不听话啊，你的脚失去了向左走与向上走（方向是相对于整个地图，换句话说不是通过你脸的朝向来决定方向，你只能↓和→）的能力。（你：这设定真奇怪啊 。WGX大神：让你四处走还不把我的宝箱全开了）。
不管了开宝箱要紧。假设每个宝箱有一个数字V，如果是正数那么你获得V个金币，如果是负数，哈哈，不好意思，扣去相应个金币。（哭晕在厕所）。
那么问题来了：
如果你在已知宝箱的奖励的情况下，请选择一条路线，这条路线能让你获得最多的金币，当然所有走过的宝箱必须打开，不能说因为是负数你就选择不去打开它，并且出口（左上）和入口（右下）的那两个宝箱是必经点，也必须打开。
你的任务只是求出该路线获得的金币值就行。
题解：
很明显状态转移方程为 f[i][j]=max(f[i-1][j],f[i][j-1])+b[i][j];
记得要DP数组初值赋值为无穷小
代码：
#include<stdio.h>
#include<limits.h>
int b[101][101];
int f[101][101];
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int n,m,i,j,k,kk;
scanf("%d%d",&n,&m);
for(i=0;i<=n+1;i++)
{
for(j=0;j<=m+1;j++)
f[i][j]=INT_MIN;
}
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
scanf("%d",&b[i][j]);
}
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
if(i==1 && j==1)
f[1][1]=b[1][1];
else
f[i][j]=max(f[i-1][j],f[i][j-1])+b[i][j];
}
}
printf("%d\n",f[n][m]);
}
return 0;
}
DP 最长上升子序列（板子）
#include<stdio.h>
#include <iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
using namespace std;
int a[1000050];
int ans[1000050];
int main()
{
int n,i;
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
ans[1]=a[1];
int len=1;
for(i=2;i<=n;i++)
{
if(a[i]>ans[len])
ans[++len]=a[i];
else
{
int num=upper_bound(ans+1,ans+len+1,a[i])-ans;
ans[num]=a[i];
}
}
printf("%d\n",len);
return 0;
}
DP 最长公共子序列（板子）
复杂度O（n*n）
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<map>
#define exp 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
using namespace std;
typedef pair<int,int> p;
typedef long long LL;
char s1[105],s2[105];
int dp[105][105];
int main()
{
scanf("%s",s1);
scanf("%s",s2);
int l1=strlen(s1);
int l2=strlen(s2);
for(int i=0;i<=l1;i++)
for(int j=0;j<=l2;j++)
{
if(s1[i]==s2[j])
dp[i+1][j+1]=dp[i][j]+1;
else
dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
}
printf("%d\n",dp[l1][l2]);
return 0;
}
复杂度O（n*logn）
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<map>
#define exp 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
const int maxn = 1501 ;
vector<int> location[26] ;
int c[maxn*maxn] , d[maxn*maxn] ;
inline int get_max(int a,int b) { return a > b ? a : b ; }
//nlogn 求lcs
int lcs(char a[],char b[])
{
int i , j , k , w , ans , l , r , mid ;
for( i = 0 ; i < 26 ; i++) location[i].clear() ;
for( i = strlen(b)-1 ; i >= 0 ; i--) location[b[i]-'a'].push_back(i) ;
for( i = k = 0 ; a[i] ; i++)
{
for( j = 0 ; j < location[w=a[i]-'a'].size() ; j++,k++) c[k] = location[w][j] ;
}
d[1] = c[0] ; d[0] = -1 ;
for( i = ans = 1 ; i < k ; i++)
{
l = 0 ; r = ans ;
while( l <= r )
{
mid = ( l + r ) >> 1 ;
if( d[mid] >= c[i] ) r = mid - 1 ;
else l = mid + 1 ;
}
if( r == ans ) ans++,d[r+1] = c[i] ;
else if( d[r+1] > c[i] ) d[r+1] = c[i] ;
}
return ans ;
}
int main()
{
char a[maxn] , b[maxn] ;
while (~scanf("%s%s",a,b))
{
printf("%d",lcs(a,b));
}
}
DP 最长公共子序列（板子）
复杂度O（n*n）
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<map>
#define exp 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
using namespace std;
typedef pair<int,int> p;
typedef long long LL;
char s1[105],s2[105];
int dp[105][105];
int main()
{
scanf("%s",s1);
scanf("%s",s2);
int l1=strlen(s1);
int l2=strlen(s2);
for(int i=0;i<=l1;i++)
for(int j=0;j<=l2;j++)
{
if(s1[i]==s2[j])
dp[i+1][j+1]=dp[i][j]+1;
else
dp[i+1][j+1]=max(dp[i][j+1],dp[i+1][j]);
}
printf("%d\n",dp[l1][l2]);
return 0;
}
复杂度O（n*logn）
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<map>
#define exp 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
const int maxn = 1501 ;
vector<int> location[26] ;
int c[maxn*maxn] , d[maxn*maxn] ;
inline int get_max(int a,int b) { return a > b ? a : b ; }
//nlogn 求lcs
int lcs(char a[],char b[])
{
int i , j , k , w , ans , l , r , mid ;
for( i = 0 ; i < 26 ; i++) location[i].clear() ;
for( i = strlen(b)-1 ; i >= 0 ; i--) location[b[i]-'a'].push_back(i) ;
for( i = k = 0 ; a[i] ; i++)
{
for( j = 0 ; j < location[w=a[i]-'a'].size() ; j++,k++) c[k] = location[w][j] ;
}
d[1] = c[0] ; d[0] = -1 ;
for( i = ans = 1 ; i < k ; i++)
{
l = 0 ; r = ans ;
while( l <= r )
{
mid = ( l + r ) >> 1 ;
if( d[mid] >= c[i] ) r = mid - 1 ;
else l = mid + 1 ;
}
if( r == ans ) ans++,d[r+1] = c[i] ;
else if( d[r+1] > c[i] ) d[r+1] = c[i] ;
}
return ans ;
}
int main()
{
char a[maxn] , b[maxn] ;
while (~scanf("%s%s",a,b))
{
printf("%d",lcs(a,b));
}
}
** 免费馅饼（简单DP）**
题目：
都说天上不会掉馅饼，但有一天gameboy正走在回家的小径上，忽然天上掉下大把大把的馅饼。说来gameboy的人品实在是太好了，这馅饼别处都不掉，就掉落在他身旁的10米范围内。馅饼如果掉在了地上当然就不能吃了，所以gameboy马上卸下身上的背包去接。但由于小径两侧都不能站人，所以他只能在小径上接。由于gameboy平时老呆在房间里玩游戏，虽然在游戏中是个身手敏捷的高手，但在现实中运动神经特别迟钝，每秒种只有在移动不超过一米的范围内接住坠落的馅饼。现在给这条小径如图标上坐标：
为了使问题简化，假设在接下来的一段时间里，馅饼都掉落在0-10这11个位置。开始时gameboy站在5这个位置，因此在第一秒，他只能接到4,5,6这三个位置中其中一个位置上的馅饼。问gameboy最多可能接到多少个馅饼？（假设他的背包可以容纳无穷多个馅饼）
Input
输入数据有多组。每组数据的第一行为以正整数，表示有n个馅饼掉在这条小径上。在结下来的n行中，每行有两个整数x,T(表示在第T秒有一个馅饼掉在x点上。同一秒钟在同一点上可能掉下多个馅饼。n=0时输入结束。
Output
每一组输入数据对应一行输出。输出一个整数m，表示gameboy最多可能接到m个馅饼。
提示：本题的输入数据量比较大，建议用scanf读入，用cin可能会超时。
题解：
DP[i][j]代表i时刻在j位置接到的馅饼。
因为不知道最好停留的位置，所以时间逆序DP。
特判一下0位置，不然数组会越界。
代码：
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
int dp[100005][12];
int main()
{
int n,i,j;
while(~scanf("%d",&n))
{
if(n==0)break;
int time=-1;
memset(dp,0,sizeof(dp));
for(i=0;i<n;i++)
{
int x,t;
scanf("%d%d",&x,&t);
dp[t][x]++;
time=max(time,t);
}
for(i=time-1;i>=0;i--)
{
for(j=0;j<11;j++)
{
if(j==0)
dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+dp[i][j];
else
dp[i][j] = max(max(dp[i+1][j],dp[i+1][j+1]),dp[i+1][j-1])+dp[i][j];
}
}
printf("%d\n",dp[0][5]);
}
return 0;
}
HDU 2089 不要62 （数位DP）
大神的操作 当板子用…
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
typedef long long ll;
int a[20];
int dp[20][2];
int dfs(int pos,int pre,int sta,bool limit)
{
if(pos==-1) return 1;
if(!limit && dp[pos][sta]!=-1) return dp[pos][sta];
int up=limit ? a[pos] : 9;
int tmp=0;
for(int i=0;i<=up;i++)
{
if(pre==6 && i==2)continue;
if(i==4) continue;//都是保证枚举合法性
tmp+=dfs(pos-1,i,i==6,limit && i==a[pos]);
}
if(!limit) dp[pos][sta]=tmp;
return tmp;
}
int solve(int x)
{
int pos=0;
while(x)
{
a[pos++]=x%10;
x/=10;
}
return dfs(pos-1,-1,0,true);
}
int main()
{
int le,ri;
//memset(dp,-1,sizeof dp);可优化
while(~scanf("%d%d",&le,&ri) && le+ri)
{
memset(dp,-1,sizeof dp);
printf("%d\n",solve(ri)-solve(le-1));
}
return 0;
}
状压DP
https://mp.csdn.net/mdeditor/81407630
P1280 尼克的任务（DP）
这道题虽然不难，但是这个状态方程对于我来说还是很难想到。这道题要倒着DP，因为顺序的话不知道结束的状态是什么，所以考虑的因素很多。倒着的话，就两种情况。
一：当前无任务，休息一秒
二：当前有任务，考虑做不做
直接上代码。
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<map>
#define exp 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
using namespace std;
int a[100005]; //记录开始的时间
int b[100005]; //记录结束的时间
int dp[10005];
int main()
{
int n,t,i,x,y;
scanf("%d%d",&t,&n);
for(i=1;i<=n;i++)
{
scanf("%d%d",&x,&y);
a[i]=x;
b[i]=y;
}
int num=n;
for(i=t;i>=1;i--)
{
if(a[num]!=i) dp[i]=dp[i+1]+1;
//当前没有任务，所以休息一秒
else
{
while(a[num]==i)
{
dp[i]=max(dp[i],dp[i+b[num]]);
//当前有任务，考虑要不要做。
num--;
}
}
}
printf("%d\n",dp[1]);
return 0;
}
洛谷P1006 传纸条（DP）
很经典
题目描述
小渊和小轩是好朋友也是同班同学，他们在一起总有谈不完的话题。一次素质拓展活动中，班上同学安排做成一个 m 行 n 列的矩阵，而小渊和小轩被安排在矩阵对角线的两端，因此，他们就无法直接交谈了。幸运的是，他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，坐标 (1,1 )，小轩坐在矩阵的右下角，坐标 (m,n) 。从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。
在活动进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙。反之亦然。
还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低（注意：小渊和小轩的好心程度没有定义，输入时用 0 表示），可以用一个 0-100的自然数来表示，数越大表示越好心。小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条，即找到来回两条传递路径，使得这 22 条路径上同学的好心程度之和最大。现在，请你帮助小渊和小轩找到这样的 2 条路径。
输入输出格式
输入格式：
输入文件，第一行有 2 个用空格隔开的整数 m 和 n ，表示班里有 m 行 n 列。
接下来的 m 行是一个 m×n 的矩阵，矩阵中第 i 行 j 列的整数表示坐在第 i行 j 列的学生的好心程度。每行的 n个整数之间用空格隔开。
输出格式：
输出文件共一行，包含一个整数，表示来回 2 条路上参与传递纸条的学生的好心程度之和的最大值。
输入输出样例
输入样例#1： 复制
3 3
0 3 9
2 8 5
5 7 0
输出样例#1： 复制
34
题解：
感觉很难理解…直到看到了这个题解。
因为是从上方和从下方传纸条，为了方便，我们相当于从左上角连续传两张纸条，路径不重复，效果相同。
从左上来看的话就只能向右或向下传纸条。
那么两张纸条在过程中就一定在一条斜线上，而在一条斜线上纵坐标与横坐标相加相等。
在如图的斜线中，两个点的和都为3.
首先重要的就是三维F数组。
第一维度维护的是在传的过程中纵坐标与横坐标的和。
在同一斜线上，剩下表示两个点的从坐标就可以表示这两个点的位置。
第二维度维护的是相对在左边的点的纵坐标。
第三维度维护的是相对在右边的点的纵坐标。
当查询一个情况时，只有四种情况可以到他
F[sum][i][j]=max{F[sum-1][i][j]+F[k-1][i][j-1]+F[k-1][i-1][j]+F[k-1][i-1][j-1]；
最后再加上a数组里存的两个点的好感度即可
代码：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=60;
int a[maxn][maxn];
int F[2*maxn][maxn][maxn];
int main()
{
int m,n;
scanf("%d%d",&m,&n);
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
scanf("%d",&a[i][j]);
//F[sum][i][j]=max{F[sum-1][i][j]...
memset(F,-1,sizeof(F));//赋初值为-1 (原因在后面）
F[2][1][1]=0;//最初的点，在左上角，好感度为0
for(int k=3;k<m+n;k++)
for(int i=1;i<n;i++)
for(int j=i+1;j<=n;j++)
{
int s=F[k][i][j];
if(F[k-1][i][j]>s)s=F[k-1][i][j];
if(F[k-1][i-1][j]>s)s=F[k-1][i-1][j];
if(F[k-1][i][j-1]>s)s=F[k-1][i][j-1];
if(F[k-1][i-1][j-1]>s)s=F[k-1][i-1][j-1];
if(s==-1)continue;//当s为-1时，说明四种情况都不能到该点，故不存在。
F[k][i][j]=s+a[k-i][i]+a[k-j][j];//该点的值为最大的前一个值与当前F[k][i][j]表示两点的值的和。
}
printf("%d",F[m+n-1][n-1][n]);//因为i永远小于j，所以右下角的点不会求到，
//但是到右下角只有一种情况，就是在右下角的上面和右下角的左边，直接输出就好了。
return 0;
}
P1387 最大正方形（DP）
题目：
在一个n*m的只包含0和1的矩阵里找出一个不包含0的最大正方形，输出边长。
输入输出样例
输入样例#1： 复制
4 4
0 1 1 1
1 1 1 0
0 1 1 0
1 1 0 1
输出样例#1： 复制
2
题解：
只有当前位置为1时，正方形长度才可以更大。而要使得正方形最大，左，上，左上都为一，否则为他们三个里面最小的那个加1.所以状态转移方程为：
f[i][j]=min(min(f[i-1][j],f[i][j-1]),f[i-1][j-1])+1;
代码：
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
#include<stack>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<map>
#define exp 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
int a[101][101];
int f[101][101];
int main()
{
int n,m,i,j,maxx=-1;
scanf("%d%d",&n,&m);
memset(f,0,sizeof(f));
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
{
scanf("%d",&a[i][j]);
if(a[i][j]==1)
f[i][j]=min(min(f[i-1][j],f[i][j-1]),f[i-1][j-1])+1;
maxx=max(maxx,f[i][j]);
}
printf("%d\n",maxx);
return 0;
}
P1025 数的划分(DP)
题目描述
将整数n分成k份，且每份不能为空，任意两个方案不相同(不考虑顺序)。
例如：n=7，k=3，下面三种分法被认为是相同的。
1,1,5;
1,5,1
5,1,1.
问有多少种不同的分法。
输入输出格式
输入格式：
n,k
输出格式：
1个整数，即不同的分法。
输入输出样例
输入样例#1： 复制
7 3
输出样例#1： 复制
4
说明
四种分法为：
1,1,5;
1,2,4;
1,3,3;
2,2,3.
题解
首先感叹真的是弱。这个DP题状态转移方程真的是想不出来。直到我看到了这道题的另一个题目。。
这题其实是排列组合里的题，可以把一个数值为n的数当做n个小球，划分的份数k当做k个盒子，那么本题可以转化为“将n个小球放到k个盒子中，小球之间与盒子之间没有区别，并且最后的结果不允许空盒”
将n个小球放到k个盒子中的情况总数 =
a.至少有一个盒子只有一个小球的情况数
+b.没有一个盒子只有一个小球的情况数
这样进行划分是因为这种分类可以使a和b都有能写出来的表达式：
a.因为盒子不加区分，那么1的情况数与“将n-1个小球放到k-1个盒子中”的情况数一样
b.没有一个盒子只有一个小球，那么把每个盒子中拿出来一个小球，对应的是“把(n-k)个小球放到k个盒子中的情况数”
然后将上面的思路化为动态转移方程：
设f[n,k]代表将n个小球放到k个盒子中且没有空盒的情况，那么f[n,k] = f[n-1,k-1] + f[n-k,k]
而当k=1时只有1种方法(小球全部放进1个盒子)
代码
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#define exp 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
int dp[205][10];
int main()
{
int n,k;
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
{
dp[i][1]=1;
dp[i][0]=1;
}
for(int j=2;j<=k;j++)
{
dp[1][j]=0;
dp[0][j]=0;
}
for(int i=2;i<=n;i++)
{
for(int j=2;j<=k;j++)
{
if(i>j)
dp[i][j]=dp[i-1][j-1]+dp[i-j][j];
else
dp[i][j]=dp[i-1][j-1];
}
}
printf("%d\n",dp[n][k]);
return 0;
}
洛谷P1052 过河（DP+路径压缩离散化）
题目描述
在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子，青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数，我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0,1,…,L（其中LL是桥的长度）。坐标为0的点表示桥的起点，坐标为L的点表示桥的终点。青蛙从桥的起点开始，不停的向终点方向跳跃。一次跳跃的距离是S到T之间的任意正整数（包括S,T）。当青蛙跳到或跳过坐标为L的点时，就算青蛙已经跳出了独木桥。
题目给出独木桥的长度L，青蛙跳跃的距离范围S,T，桥上石子的位置。你的任务是确定青蛙要想过河，最少需要踩到的石子数。
输入输出格式
输入格式：
第一行有1个正整数L(1 ~10^9)
)，表示独木桥的长度。
第二行有3个正整数S,T,M，分别表示青蛙一次跳跃的最小距离，最大距离及桥上石子的个数，
第三行有M个不同的正整数分别表示这M个石子在数轴上的位置（数据保证桥的起点和终点处没有石子）。所有相邻的整数之间用一个空格隔开。
输出格式：
一个整数，表示青蛙过河最少需要踩到的石子数。
输入输出样例
输入样例#1： 复制
10
2 3 5
2 3 5 6 7
输出样例#1： 复制
2
题解
首先说状态转移方程
这是一个比较简单方程式。
首先设f[i]为在i点上的最少踩石子数，则在前面(i-s)到(i-t)的点都可以改变i点的值,因此我们可以取f[i-s]-f[i-t]之中的最小值，另外如果有石头就加上1，如果没有就不加值，这里我们直接用flag[i]表示该点有无石头(有则为1，无则为0)。
因此我们可以写出状态转移方程式 f[i]=min(f[i-j]+flag[i]|s<=j<=t)
然后因为n的数据太大，数组根本存不下，所以这个时候就要考虑把数据离散化，也就是路径压缩短。
因为n为1e9，但是s，t的范围是1-10，并且m<100,所以中间其实很多点都是没有石头的。然后我们不知道每一步怎么走，所以压缩的时候，如果两石头间距大于1-10的最小公倍数即2520，就求余2520，然后把l压缩短，就可以了。
最后注意一点，最后dp的结果不是dp[l],因为走到l位置不一定是最优解，所以要取l到l+r-1直接的最优解。
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<queue>
#include<algorithm>
#include<iostream>
#define exp 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define maxn 1000500
using namespace std;
typedef unsigned long long LL;
int a[105];//地图
int d[105];//间距
int dp[500005];//dp
int dis[500005];//判断该点是否有石头
int main()
{
int l,s,t,m;
scanf("%d%d%d%d",&l,&s,&t,&m);
for(int i=1;i<=m;i++)
scanf("%d",&a[i]);
sort(a+1,a+1+m);
for(int i=1;i<=m;i++)
d[i]=(a[i]-a[i-1])%2520;//要对1~10的最小公倍数取余，压缩路径的核心
for(int i=1;i<=m;i++)
{
a[i]=a[i-1]+d[i];
dis[a[i]]=1;
}
l=a[m];
for (int i=0;i<=l+t;i++)
dp[i]=m; //f[i]表示到位置i最少能踩到的石子数
dp[0]=0;
for(int i=1;i<l+t;i++)
{
for(int j=s;j<=t;j++)
{
if(i>=j)
dp[i]=min(dp[i],dp[i-j]); //状态转移方程
}
dp[i]+=dis[i];
}
int ans=m;
for(int i=l;i<l+t;i++)
{
ans=min(ans,dp[i]);
}
printf("%d\n",ans);
return 0;
}
760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
