dp中一些的基础问题

能用动规解决的问题的特点
1)问题具有最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的,我们就称该问题具有最优子结构性质。
2)无后效性。当前的若干个状态值一旦确定,则此后过程的演变就只和这若干个状态的值有关,和之前是采取哪种手段或经过哪条路径演变到当前的这若干个状态,没有关系。

什么是无后效性，看到一个很好懂的解释；

（转）

某阶段的状态一旦确定，则此后过程的演变不再受 此前各种状态及决策的影响

百度百科是这样定义的，是不是很苦涩，难懂。并且网上对这个名词的解释大多都是理论性的，不好理解，今天我们通过一个例子来看看什么是无后效性 

现在有一个四乘四的网格，左上角有一个棋子，棋子每次只能往下走或者往右走，现在要让棋子走到右下角

假设棋子走到了第二行第三列，记为s(2,3),如下图，画了两条路线和一条不符合题意的路线，那么当前的棋子[s(2,3)位置]怎么走到右下角和之前棋子是如何走到s(2,3)这个位置无关[不管是黑色尖头的路线还是蓝色箭头的路线] 

换句话说，当位于s(2,3)的棋子要进行决策（向右或者向下走）的时候，之前棋子是如何走到s(2,3)这个位置的是不会影响我做这个决策的。之前的决策不会影响了未来的决策（之前和未来相对于现在棋子位于s(2,3)的时刻），这就是无后效性,也就是所谓的“未来与过去无关”

看完了无后效性，那我们再来看看有后效性，还是刚才的例子，只不过现在题目的条件变了，现在棋子可以上下左右走但是不能走重复的格子 

那么现在红色箭头就是一个合法的路线了，当我的棋子走到了s(2,3)这个位置的时候，要进行下一步的决策的时候，这时候的决策是受之前棋子是如何走到s(2,3)的决策的影响的，比如说红色箭头的路线，如果是红色箭头决策而形成的路线，那么我下一步决策就不能往下走了[因为题意要求不能走重复的格子]，之前的决策影响了未来的决策，”之前影响了未来”,这就叫做有后效性 。

 首先举最长上升子序列这个问题（poj百练2725）

样例输入 
7 
1 7 3 5 9 4 8 
样例输出 
4

解题思路：

寻找一个无后效性的子问题：求以a(k=1,2,3…N)为终点的最长上升子序列的
长度。

人人为我递推型

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=10100;
int a[maxn],maxlen[maxn];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		maxlen[i]=1;
	}
	for(int i=2;i<=n;i++){
		for(int j=1;j<i;j++){
			if(a[i]>a[j]){
				maxlen[i]=max(maxlen[i],maxlen[j]+1);
			}
		}
	}
	cout<<*max_element(maxlen+1,maxlen+n+1)<<endl;
}

我为人人递推型

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1010;
int a[maxn],maxlen[maxn];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		maxlen[i]=1;
	}
	for(int i=1;i<=n;i++){
		for(int j=i+1;j<=n;j++){
			if(a[j]>a[i]){
				maxlen[j]=max(maxlen[j],maxlen[i]+1)； 
			}
		}
	}
	cout<<*max_element(maxlen+1,maxlen+n+1);
	return 0;
}

最长公共子序列

#include<iostream>
#include<cstring>
using namespace std;
char s1[1010];
char s2[1010];
int maxlen[1010][1010];
int main(){
	while(cin>>s1>>s2){
		int l1=strlen(s1);
		int l2=strlen(s2);
		for(int i=0;i<=l1;i++){
			maxlen[i][0]=0;
		}
		for(int j=0;j<=l2;j++){
			maxlen[0][j]=0;
		}
		for(int i=1;i<=l1;i++){
			for(int j=1;j<=l2;j++){
				if(s1[i-1]==s2[j-1]){
					maxlen[i][j]=maxlen[i-1][j-1]+1;
				}
				else{
					maxlen[i][j]=max(maxlen[i][j-1],maxlen[i-1][j]);
				}
			}
		}
		cout<<maxlen[l1][l2]<<endl;
	}
	return 0;
}

神奇的口袋bailian2755

递归解决：枚举每个物体是选还是不选共2^20种情况

#include<iostream>
using namespace std;
int a[30];int n;
int ways(int w,int k){
	if(w==0) return 1;
	if(k<=0) return 0;
	return ways(w,k-1)+ways(w-a[k],k-1);
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	cout<<ways(40,n)<<endl;
	return 0;
}

dp解决

#include<iostream>
#include<cstring>
using namespace std;
int a[40],dp[50][50];//dp[w][k]从前k种武平中凑出体积w的方法数
int n;
int main(){
        cin>>n;
        memset(dp,0,sizeof(0));
        for(int i=1;i<=n;i++){
            cin>>a[i];
            dp[0][i]=1;
        }
        dp[0][0]=1;
        for(int w=1;w<=40;w++){
            for(int k=1;k<=n;k++){
                dp[w][k]=dp[w][k-1];
                if(w-a[k]>=0){
                    dp[w][k]+=dp[w-a[k]][k-1];
                }
            }
        }
        cout<<dp[40][n]<<endl;
}

滑雪poj1088

人人为我dp

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#include <math.h>
#define N 400
#define inf 0x3f3f3f3f
typedef int ll;
using namespace std;
int tt;
struct node
{
    int h,l,w,dp;
}q[20010];
int cmp(const void *a,const void *b)
{
    struct node *aa=(struct node *)a;
    struct node *bb=(struct node *)b;
    return aa->w-bb->w;
}
int main()
{
    int R,C,mat;
    while(scanf("%d%d",&R,&C)!=EOF)
    {
        tt=0;
        mat=1;
        for(int i=1;i<=R;i++)
        {
            for(int j=1;j<=C;j++)
            {
                scanf("%d",&q[tt].w);
                q[tt].h=i;
                q[tt].dp=1;//初始值为1
                q[tt++].l=j;
            }
        }
        qsort(q,tt,sizeof(q[0]),cmp);
        for(int i=1;i<tt;i++)
        {
            int rr=q[i].h;
            int ll=q[i].l;
            for(int j=0;j<i;j++)
            {
                int r2=q[j].h;
                int l2=q[j].l;
                if((q[i].w>q[j].w)&&((abs(r2-rr)==1&&ll==l2)||(rr==r2&&abs(ll-l2)==1)))//注意只能高度减小才能滑落，高度相等是不能滑落的
                {
                    q[i].dp=max(q[i].dp,(q[j].dp+1));
                    mat=max(mat,q[i].dp);//不一定节点大的是最大滑落值，自己想一想就知道了，所以要随时记录当前的最大滑落值。
                }
            }
        }
        printf("%d\n",mat);

    }
    return 0;
}

我为人人dp

#include<iostream>
#include<algorithm> 
using namespace std;
struct node{
	int h,i,j,dp;
}a[20010];
bool cmp(node x,node y){
	return x.h<y.h;
}
int main(){
	int n,m;
	while(cin>>n>>m){
		int flag=0;
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				cin>>a[flag].h;
				a[flag].i=i;a[flag].j=j;
				a[flag++].dp=1;
			}
		}
		sort(a,a+flag,cmp);
		for(int i=0;i<flag;i++){
			for(int j=0;j<flag;j++){
				if(a[i].h<a[j].h&&((abs(a[i].i-a[j].i)==1&&a[i].j==a[j].j)||(abs(a[i].j-a[j].j)==1&&a[i].i==a[j].i))){
					a[j].dp=max(a[j].dp,a[i].dp+1);
				}
			}
		}
		int maxx=0;
		for(int i=0;i<flag;i++){
			maxx=max(maxx,a[i].dp);
		}
		cout<<maxx<<endl;
	}
}