动态规划（线性DP）

1.斐波那契数列

int DP01() {
	int dp[n];
	dp[1] = 1;
	dp[2] = 1;
	for (int i = 3; i<n; i++) {
		dp[i] = dp[i - 1] + dp[i - 2];
	}
	return dp[n];
}

2.数字三角形

#include<bits/stdc++.h>
using namespace std;
const int N=510;
int f[N][N];
int n;
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=i;j++){
            cin>>f[i][j];
        }
    }

    
    for(int i=n;i>=1;i--){
        for(int j=n;j>=1;j--){
            f[i][j]+=max(f[i+1][j],f[i+1][j+1]);
        }
    }
    cout<<f[1][1];
    return 0;
}

注：如果从上往下循环，就要注意边界情况了 

3.最长上升子序列

 

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int a[N],f[N];
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    for(int i=1;i<=n;i++){
        f[i]=1;
        for(int j=1;j<i;j++){
            if(a[i]>a[j]){
                f[i]=max(f[i],f[j]+1);
            }
        }
    }
    int res=0;
    for(int i=1;i<=n;i++){
        res=max(res,f[i]);
    }
    cout<<res;
return 0;
}

其中，f[i]表示以a[i]结尾的上升子序列最大长度；  j∈(0,1,2,..,i-1), 

在w[i] > w[j]时，f[i] = max(f[i], f[j] + 1)。

4.最长公共子序列 

#include <bits/stdc++.h>
using namespace std;
const int N=1010;
int n,m;
char a[N],b[N];
int dp[N][N];
int main(){
    cin>>n>>m;
    scanf("%s%s",a+1,b+1);
    dp[0][0]=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(a[i]==b[j])dp[i][j]=dp[i-1][j-1]+1;
            else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
        }
    }
    cout<<dp[n][m];
    return 0;
}

 5.最短编辑距离

 

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
char a[N],b[N];
int n,m;
//int size1;
int dp[N][N];
int main(){
    cin>>n;
    scanf("%s",a+1);
    cin>>m;
    scanf("%s",b+1);
   // size1=max(n,m);
   //memset(dp,0x3f3f3f,sizeof dp);
 /*  for(register int i=1; i<=n; i++) 
        for(register int j=1; j<=m; j++) 
           dp[i][j] = 0x3f3f3f3f;*/
   for(int i=1;i<=n;i++)dp[i][0]=i;
   for(int i=1;i<=m;i++)dp[0][i]=i;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1);
            if(a[i]==b[j])dp[i][j]=dp[i-1][j-1];
            else dp[i][j]=min(dp[i][j],dp[i-1][j-1]+1);
        }
    }
  //  cout<<size1-dp[n][m];
  cout<<dp[n][m];
    return 0;
}