34道DP

1、方格取数Ⅰ

设有 n×m 的方格图，每个方格中都有一个整数。
现有一只小熊，想从图的左上角走到右下角，每一步只能向上、向下或向右走一格，并且不能重复经过已经走过的方格，也不能走出边界。
小熊会取走所有经过的方格中的整数，求它能取到的整数之和的最大值。

#include <iostream>
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;
int s[N][N];
int f[N][N];
int n,m;

int sum(int j,int x,int y)
{
    if(x>y) swap(x,y);
    return s[y][j]-s[x-1][j];    
}

int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            cin >> s[i][j];
            s[i][j]+=s[i-1][j];
        }
    
    memset(f,-0x3f3f,sizeof f);
    f[1][0]=0;
    for(int j=1;j<=m;j++)
        for(int i=1;i<=n;i++)
            for(int k=1;k<=n;k++)
                f[i][j]=max(f[i][j],f[k][j-1]+sum(j,i,k));
                
    cout<<f[n][m];
    return 0;
}

2、走方格

给定一个 n×m 的方格阵，沿着方格的边线走，从左上角 (0,0) 开始，每次只能往右或者往下走一个单位距离，问走到右下角 (n,m) 一共有多少种不同的走法。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 1010;
int f[N][N];
int n,m;

int main()
{
    f[1][1]=1;
    cin >> n >> m;
    n++,m++;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            if(i==1 && j==1) continue;
            
            f[i][j]=f[i-1][j]+f[i][j-1];
        }    
    
    cout<<f[n][m];
    return 0;
}

3、摘花生

只能向东或向南走，不能向西或向北走。
问从西北角到东南角，最多能够摘到多少颗花生（每个网格上有一定数量的花生）。

#include <iostream>
using namespace std;

const int N = 110;
int w[N][N];
int f[N][N];
int n,m;

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

4、最低通行费

一个商人穿过一个N×N的正方形的网格，去参加一个非常重要的商务活动。
他要从网格的左上角进，右下角出。
每穿越中间1个小方格，都要花费1个单位时间。
商人必须在(2N-1)个单位时间穿越出去。
而在经过中间的每个小方格时，都需要缴纳一定的费用。
这个商人期望在规定时间内用最少费用穿越出去。
请问至少需要多少费用？
注意：不能对角穿越各个小方格（即，只能向上下左右四个方向移动且不能离开网格）。

#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

const int N = 1010;
int w[N][N];
int f[N][N];
int n;

int main()
{
    cin >> n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            cin >> w[i][j];
           
    memset(f,0x3f3f,sizeof f);
    f[1][0]=0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            f[i][j]=min(f[i-1][j],f[i][j-1])+w[i][j];
  
    cout<<f[n][n];
    return 0;
}

5、方格取数Ⅱ

某人从图中的左上角 A 出发，可以向下行走，也可以向右行走，直到到达右下角的 B 点。
在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字0）。
此人从 A 点到 B 点共走了两次，试找出两条这样的路径，使得取得的数字和为最大。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 110;
int w[N][N];
int f[N*2][N][N];
int n;

int main()
{
    cin >> n;
    int a,b,c;
    while(cin>>a>>b>>c,a||b||c) w[a][b]=c;
    
    for(int k=2;k<=2*n;k++)
        for(int a=1;a<=n;a++)
            for(int x=1;x<=n;x++)
            {
                int b=k-a,y=k-x;
                if(b>=1&&b<=n&&y>=1&&y<=n)
                {
                    int t=w[a][b];
                    if(a!=x) t+=w[x][y];
                    int &v=f[k][a][x];
                    v=max(v,f[k-1][a-1][x-1]+t);
                    v=max(v,f[k-1][a-1][x]+t);
                    v=max(v,f[k-1][a][x-1]+t);
                    v=max(v,f[k-1][a][x]+t);
                }
            }
    // f[k][a][x] 表示所有从(1,1)走到(a,b),(x,y)的路径的最大值,其中k=a+b=x+y
    cout<<f[n*2][n][n];
    return 0;
}

6、最长上升子序列(LIS)

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。

$O(n^2):$

#include <iostream>
using namespace std;

const int N = 1010;
int a[N],f[N];
int n;
int res;

int main()
{
    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);
        res=max(res,f[i]);
    }
    cout<<res;
    return 0;
}

$O(nlogn):$

#include <iostream>
using namespace std;

const int N = 100010;
int a[N],q[N];
int n;

int main()
{
    cin >> n;
    for(int i=0;i<n;i++) cin >> a[i];
    
    int len=0;
    q[0]=-2e9;
    for(int i=0;i<n;i++)
    {
        int l=0,r=len;
        while(l<r)
        {
            int mid=l+r+1>>1;
            if(q[mid]<a[i]) l=mid;
            else r=mid-1;
        }
        
        len=max(len,r+1);
        q[r+1]=a[i];
    }
    
    cout<<len;
    return 0;
}

$O(nlogn):$

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

int main()
{
    int n;
    cin >> n;
    vector<int> a,b;
    for(int i=0;i<n;i++) 
    {
        int x;
        cin >> x;
        a.push_back(x);
    }
    
    b.push_back(a[0]);
    for(int i=1;i<n;i++)
        if(a[i] > b.back()) 
            b.push_back(a[i]);
        else 
            *lower_bound(b.begin(),b.end(),a[i]) = a[i];
    cout<<b.size();
    return 0;
}

7、怪盗基德的滑翔翼

找到数组中以某个元素结束的上升序列 或 以某个元素开始的下降序列 的长度最大值。

#include <iostream>
using namespace std;

const int N = 1010;
int a[N],f[N];
int n;
int res;

int main()
{
    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);
        res=max(res,f[i]);
    }
    
    for(int i=n;i;i--)
    {
        f[i]=1;
        for(int j=n;j>i;j--)
            if(a[i]>a[j])
                f[i]=max(f[i],f[j]+1);
        res=max(res,f[i]);
    }
    cout<<res;
    return 0;
}

8、登山

五一到了，ACM队组织大家去登山观光，队员们发现山上一个有N个景点，并且决定按照顺序来浏览这些景点，即每次所浏览景点的编号都要大于前一个浏览景点的编号。
同时队员们还有另一个登山习惯，就是不连续浏览海拔相同的两个景点，并且一旦开始下山，就不再向上走了。
队员们希望在满足上面条件的同时，尽可能多的浏览景点，你能帮他们找出最多可能浏览的景点数么？
Tip:找到数组中形如下图的序列最大长度。

#include <iostream>
using namespace std;

const int N = 1010;
int a[N],f[N],g[N];
int n;
int res;

int main()
{
    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);
    }
    
    for(int i=n;i;i--)
    {
        g[i]=1;
        for(int j=n;j>i;j--)
            if(a[i]>a[j])
                g[i]=max(g[i],g[j]+1);
    }
    
    for(int i=1;i<=n;i++) res=max(res,f[i]+g[i]-1);
    
    cout<<res;
    return 0;
}

9、合唱队形

N 位同学站成一排，音乐老师要请其中的 (N−K) 位同学出列，使得剩下的 K 位同学排成合唱队形。     
合唱队形是指这样的一种队形：设 K 位同学从左到右依次编号为 1，2…，K，他们的身高分别为 T1，T2，…，TK，  则他们的身高满足 T1<…Ti+1>…>TK(1≤i≤K)。     
你的任务是，已知所有 N 位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

#include <iostream>
using namespace std;

const int N = 1010;
int a[N],f[N],g[N];
int n;
int res;

int main()
{
    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);
    }
    
    for(int i=n;i;i--)
    {
        g[i]=1;
        for(int j=n;j>i;j--)
            if(a[i]>a[j])
                g[i]=max(g[i],g[j]+1);
    }
    
    for(int i=1;i<=n;i++) res=max(res,f[i]+g[i]-1);
    
    cout<<n-res;
    return 0;
}

10、友好城市

Palmia国有一条横贯东西的大河，河有笔直的南北两岸，岸上各有位置各不相同的N个城市。
北岸的每个城市有且仅有一个友好城市在南岸，而且不同城市的友好城市不相同。
每对友好城市都向政府申请在河上开辟一条直线航道连接两个城市，但是由于河上雾太大，政府决定避免任意两条航道交叉，以避免事故。
编程帮助政府做出一些批准和拒绝申请的决定，使得在保证任意两条航线不相交的情况下，被批准的申请尽量多。
Tip:给定n条边，求最多能选多少边？前提是边与边不相交.

# include <iostream>
# include <algorithm>
using namespace std;
const int N = 5010;

pair<int,int> h[N];
int f[N];

int n;

int main()
{
    cin >> n;
    for(int i = 1 ; i <= n ; i++)
    {
        int a,b;
        cin >> a >> b;
        h[i]={a,b};
    }

    sort(h + 1 , h + n + 1);

    for(int i = 1 ; i <= n ; i++)
    {
        f[i] = 1;  
        for(int j = 1 ; j < i ; j++)
            if(h[j].second < h[i].second)
                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;
}

11、最长公共子序列(LCS)

#include <iostream>
using namespace std;

const int N = 10010;
int f[N][N]; // 考虑a1,...,ai和b1,...,bi的集合的最长公共序列的最大值
int a[N],b[N];
int n;

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

12、导弹拦截

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。
但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。
某天，雷达捕捉到敌国的导弹来袭。
计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

#include <iostream>
using namespace std;

const int N = 1010;
int a[N],f[N],g[N];
int n;
int res,cnt;

int main()
{
    while(cin>>a[n]) n++;
    
    for(int i=0;i<n;i++)
    {
        f[i]=1;
        for(int j=0;j<i;j++)    
            if(a[j]>=a[i])
                f[i]=max(f[i],f[j]+1);
        res=max(res,f[i]);
    }
    cout<<res<<endl;
    
    for(int i=0;i<n;i++)
    {
        int k=0;
        while(k<cnt && g[k]<a[i]) k++;
        
        if(k==cnt) g[cnt++]=a[i];
        else g[k]=a[i];
    }
    
    cout<<cnt;
    
    return 0;
}

13、导弹防御系统

为了对抗附近恶意国家的威胁，R 国更新了他们的导弹防御系统。
一套防御系统的导弹拦截高度要么一直 严格单调 上升要么一直 严格单调 下降。
例如，一套系统先后拦截了高度为 3 和高度为 4 的两发导弹，那么接下来该系统就只能拦截高度大于 4 的导弹。
给定即将袭来的一系列导弹的高度，请你求出至少需要多少套防御系统，就可以将它们全部击落。

#include<iostream>

using namespace std;
const int N=55;
int q[N];
int down[N],up[N];
int ans;
int n;

void dfs(int u,int su,int sd)
{
    if(su+sd>=ans) return;
    if(u==n)
    {
        ans=su+sd;
        return;
    }

    //情况1：当该数字插入到上升序列中
    //上升序列结尾的数组是单调上升的，可以使用二分进行查找
    int k=0;
    while(k<su && up[k]>q[u]) k++;
    //结尾的数组可以更新，不用开新的上升序列
    if(k<su)
    {
        int t=up[k];//为了恢复现场
        up[k]=q[u];
        dfs(u+1,su,sd);
        up[k]=t;
    }
    //结尾的数组不可以更新,需要开新的上升序列
    else 
    {
        up[k]=q[u];
        dfs(u+1,su+1,sd);
    }

    //情况2：当改数字插入到下降序列中
    //与上升序列的情况基本相同
    k=0;
    while(k<sd && down[k]<q[u]) k++;
    if(k<sd)
    {
        int t=down[k];
        down[k]=q[u];
        dfs(u+1,su,sd);
        down[k]=t;
    }
    else 
    {
        down[k]=q[u];
        dfs(u+1,su,sd+1);
    }
}

int main()
{
    while(cin>>n,n)
    {
        for(int i=0;i<n;i++) cin >> q[i];
        ans=n;
        dfs(0,0,0);
        cout<<ans<<endl;
    }    
    return 0;
}

14、1的个数

给定一个数字 N，请你计算 1∼N 中一共出现了多少个数字 1。
例如，N=12 时，一共出现了 5 个数字 1，分别出现在 1,10,11,12 中。

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;

int exp(int a, int k)
{
    int res = 1;
    while (k)
    {
        if (k & 1) res *= a;
        a *= a;
        k >>= 1;
    }
    return res;
}

// 返回nums[l..r]的数值.
int get(vector<int> &nums, int l, int r)
{
    int res = 0;
    for (int i = l; i >= r; --i) res = res * 10 + nums[i];
    return res;
}

int main()
{
    int n;
    scanf("%d", &n);
    vector<int> nums;
    while (n) nums.push_back(n%10), n /= 10;
    int res = 0;
    for (int i = nums.size()-1; i >= 0; --i)
    {
         res += get(nums, nums.size()-1, i+1) * exp(10, i);
    
        if (nums[i] > 1) res += exp(10, i);
        else if (nums[i] == 1) res += get(nums, i-1, 0) + 1;
    }
    printf("%d", res);
    return 0;
}

15、01背包

每件物品最多只用一次，求最大价值.

#include <iostream>
using namespace std;

const int N = 1010;
int f[N];
int v[N],w[N];
int n,m;

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

16、完全背包

每种物品可以用无限次，求最大价值.

#include <iostream>
using namespace std;

const int N = 1010;
int f[N];
int v[N],w[N];
int n,m;

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

17、多重背包Ⅰ

每种物品只能用有限次，求最大价值.

#include <iostream>
using namespace std;

const int N = 110;
int f[N];
int v[N],w[N],s[N];
int n,m;

int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++) cin >> v[i] >> w[i] >> s[i];
    
    for(int i=1;i<=n;i++)
        for(int j=m;j>=v[i];j--)
            for(int k=0;k<=s[i] && k*v[i]<=j;k++)
                f[j]=max(f[j],f[j-k*v[i]]+k*w[i]);
                
    cout<<f[m];
    return 0;
}

18、多重背包Ⅱ（二进制优化）

每种物品只能用有限次，求最大价值.

#include <iostream>
using namespace std;

const int N = 25000;
int f[N];
int v[N],w[N];
int n,m;

int main()
{
    cin >> n >> m;
    int cnt=0;
    for(int i=0;i<n;i++)
    {
        int a,b,s;
        cin >> a >> b >> s;
        int k=1;
        
        while(k<=s)
        {
            cnt++;
            v[cnt] = a*k;
            w[cnt] = b*k;
            s -= k;
            k*=2;
        }
        
        if(s>0)
        {
            cnt++;
            v[cnt] = s*a;
            w[cnt] = s*b;
        }
    }
    
    n=cnt;
    
    for(int i=1;i<=n;i++)
        for(int j=m;j>=v[i];j--)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
            
    cout<<f[m];
    return 0;
    
    
}

19、分组背包

每组物品最多只能用一个，求最大价值.

#include <iostream>
using namespace std;

const int N = 110;
int f[N];
int v[N][N],w[N][N],s[N];
int n,m;

int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++)
    {
        cin >>s[i];
        for(int j=0;j<s[i];j++)
            cin >> v[i][j] >> w[i][j];
    }
    
    for(int i=1;i<=n;i++)
        for(int j=m;j>=0;j--)
            for(int k=0;k<s[i];k++)
                if(j>=v[i][k])   
                    f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
            
    cout<<f[m];
    return 0;
}

20、数字三角形Ⅰ

#include <iostream>
using namespace std;

const int N = 110;
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-1;i;i--)
        for(int j=1;j<=i;j++)
            f[i][j]=max(f[i][j]+f[i+1][j+1],f[i][j]+f[i+1][j]);
            
    cout<<f[1][1];
    return 0;
}

21、数字三角形Ⅱ

此外，向左下走的次数与向右下走的次数相差不能超过 1。

在Ⅰ的基础上选择性输出即可

#include <iostream>
#include <cstring>
using namespace std;

const int N = 110;
int f[N][N];  
int n,res;

int main()
{
    cin >> n;
    memset(f,-0x3f3f,sizeof f);
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            cin >> f[i][j];
            
    for(int i=2;i<=n;i++)
        for(int j=1;j<=i;j++)
            f[i][j] += max(f[i-1][j-1],f[i-1][j]);
    
    if(n%2) res=f[n][n/2+1];
    else res=max(f[n][n/2],f[n][n/2+1]);
    
    cout<<res;
    return 0;
}

22、石子合并

每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和。
合并n堆石子，求合并的最小代价

#include <iostream>
using namespace std;

const int N = 310;
int s[N];
int f[N][N];
int n;

int main()
{
    cin >> n;
    for(int i=1;i<=n;i++)
    {
        cin >> s[i];
        s[i] += s[i-1];
    }
    
    for(int len=2;len<=n;len++)
        for(int i=1;i+len-1<=n;i++)
        {
            int j=i+len-1;
            
            f[i][j]=1e9; // 默认合并需要代价为无穷
            
            for(int k=i;k<j;k++)
                f[i][j]=min(f[i][j],f[i][k]+f[k+1][j]+s[j]-s[i-1]);
        }
        
    cout<<f[1][n];
    return 0;
}

23、最短编辑距离

给定两个字符串 A 和 B，现在要将 A 经过若干操作变为 B，可进行的操作有：

删除–将字符串 A 中的某个字符删除。
插入–在字符串 A 的某个位置插入某个字符。
替换–将字符串 A 中的某个字符替换为另一个字符。
现在请你求出，将 A 变为 B 至少需要进行多少次操作。

#include <iostream>
using namespace std;

const int N = 1010;
string a,b;
int n,m;
int f[N][N];

int main()
{
    cin >> n >> a;
    cin >> m >> b;
    a=' '+a;
    b=' '+b;

    for(int i=0;i<=m;i++) f[0][i]=i;
    for(int i=0;i<=n;i++) f[i][0]=i;
    
    for(int i=1;i<=n;i++) 
        for(int j=1;j<=m;j++)
        {
            f[i][j]=min(f[i-1][j],f[i][j-1])+1;
            f[i][j]=min(f[i][j],f[i-1][j-1]+(a[i]!=b[j]));
        }
        
    cout<<f[n][m];
    return 0;
}

24、编辑距离

给定 n 个长度不超过 10 的字符串以及 m 次询问，每次询问给出一个字符串和一个操作次数上限。
对于每次询问，请你求出给定的 n 个字符串中有多少个字符串可以在上限操作次数内经过操作变成询问给出的字符串。

#include <iostream>
#include <cstring>
using namespace std;

const int N = 1010;
string str[N];
int f[N][N];

int distance(string a,string b)
{
    int n=a.size();
    int m=b.size();
    a=' '+a;
    b=' '+b;
    
    for(int i=0;i<=m;i++) f[0][i]=i;
    for(int i=0;i<=n;i++) f[i][0]=i;
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            f[i][j]=min(f[i-1][j],f[i][j-1])+1;
            f[i][j]=min(f[i][j],f[i-1][j-1]+(a[i]!=b[j]));
        }
    
    return f[n][m];
}

int main()
{
    int n,m;
    cin >> n >> m;
    for(int i=0;i<n;i++) cin >> str[i];

    
    while(m--)
    {
        string s;
        int limits;
        cin >> s >> limits;
        
        int cnt=0;
        for(int i=0;i<n;i++)
            if(distance(s,str[i])<=limits) cnt++;
        cout<<cnt<<endl;
    }
    
    return 0;
}

25、整数划分

一个正整数 n 可以表示成若干个正整数之和，形如：n=n1+n2+…+nk，其中 n1≥n2≥…≥nk,k≥1。
我们将这样的一种表示称为正整数 n 的一种划分。
现在给定一个正整数 n，请你求出 n 共有多少种不同的划分方法。

#include <iostream>
using namespace std;

const int N = 1010, MOD = 1e9+7;
int f[N]; // f[i][j]f[i][j]  表示前i个整数（1,2…,i）恰好拼成j的方案数
// 抽象成：完全背包
// 数值对应体积，数值也对应价值
// 背包容量m，每个数的值即为其体积
int main()
{
    int n;
    cin >> n;
    int m=n;
    f[0]=1;
    for(int i=1;i<=n;i++)
        for(int j=i;j<=m;j++)
            f[j]=(f[j]+f[j-i])%MOD; // 因为这是求个数，不是求最大价值，所以不用减了后在加
 
    cout<<f[m];
    return 0;
} 

26、零钱兑换

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
你可以认为每种硬币的数量是无限的。
抽象成：完全背包 n个物品，每个物品的体积为面额，价值为1.

class Solution {
public:
    int coinChange(vector<int>& coins, int m) {
        vector<int> f(m+1,1e9);
        f[0]=0;
        for(auto v:coins)
            for(int j=v;j<=m;j++)
                f[j]=min(f[j],f[j-v]+1);

        if(f[m]==1e9) return -1;
        return f[m];
    }
};

27、采药

辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。
为此，他想拜附近最有威望的医师为师。
医师为了判断他的资质，给他出了一个难题。
医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

#include <iostream>
using namespace std;

const int N = 1010;
int f[N];

int main()
{
    int n,m;
    cin >> m >> n;
    for(int i=0;i<n;i++)
    {
        int v,w;
        cin >> v >> w;
        for(int j=m;j>=v;j--) f[j]=max(f[j],f[j-v]+w);
    }
    
    cout<<f[m];
    return 0;
}

28、装箱问题

有一个箱子容量为 V，同时有 n 个物品，每个物品有一个体积（正整数）。
要求 n 个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。
输入格式:
第一行是一个整数 V，表示箱子容量。
第二行是一个整数 n，表示物品数。
接下来 n 行，每行一个正整数（不超过10000），分别表示这 n 个物品的各自体积。

#include <iostream>
using namespace std;

const int N = 20010;
int f[N];

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

29、宠物小精灵之收服

输入格式
输入数据的第一行包含三个整数：N，M，K，分别代表小智的精灵球数量、皮卡丘初始的体力值、野生小精灵的数量。
之后的K行，每一行代表一个野生小精灵，包括两个整数：收服该小精灵需要的精灵球的数量，以及收服过程中对皮卡丘造成的伤害。
输出格式
输出为一行，包含两个整数：C，R，分别表示最多收服C个小精灵，以及收服C个小精灵时皮卡丘的剩余体力值最多为R。

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;

const int N = 1010, M = 510, S = 110;
int n, m, K;
int w[S], v[S];
int f[N][M];

int main() 
{
    cin >> n >> m >> K;
    for(int i = 1; i <= K; i++) cin >> w[i] >> v[i];

    for(int i = 1; i <= K; i++) 
        for(int j = n; j >= w[i]; j--) 
            for(int k = m; k >= v[i]; k--)
                f[j][k] = max(f[j][k], f[j - w[i]][k - v[i]] + 1);
    
    int res = -1, t;
    for(int j = 0; j <= n; j++) 
        for(int k = 0; k < m; k++) 
            if(f[j][k] > res || (res == f[j][k] && k < t)) 
                res = f[j][k], t = k;
            
    cout<<res<<' '<<m-t;
    return 0;
}

30、二维费用的背包

有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。
每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。
输出最大价值。

#include <iostream>
using namespace std;

const int N = 110;
int f[N][N];

int main()
{
    int n,V,M;
    cin >> n >> V >> M;
    for(int i=0;i<n;i++)
    {
        int v,m,w;
        cin >> v >> m >> w;
        for(int j=V;j>=v;j--)
            for(int k=M;k>=m;k--)
                f[j][k]=max(f[j][k],f[j-v][k-m]+w);
    }
    
    cout<<f[V][M];
    return 0;
}

31、潜水员

潜水员为了潜水要使用特殊的装备。
他有一个带2种气体的气缸：一个为氧气，一个为氮气。
让潜水员下潜的深度需要各种数量的氧和氮。
潜水员有一定数量的气缸。
每个气缸都有重量和气体容量。
潜水员为了完成他的工作需要特定数量的氧和氮。
他完成工作所需气缸的总重的最低限度的是多少？

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 110;

int n, m1, m2;

int f[N][N];

/*
    状态表示：f[i][j][k]表示只从前i个物品中选，氧气至少是j，氮气至少是k的选法集合！属性：最小值！
    状态计算：
        f[i][j][k] = min(f[i - 1][j][k], f[i - 1][max(0, j - v1)][max(0, k - v2)])

    关键点：状态表示的是至少，因此状态的第二维和第三维为负数也是合法的！
        因为：至少是负数的状态一定是包括正数的，即至少是正数状态完全是可以从至少是负数状态转移过来！

        对于负数的处理：从负数转移过来时，直接将负数等价为0即可，0和负数完全等价的！
            因为：至少是负数表示该氧气或体积已经不再需要了，0也可以表示这一状态，因此等价！

    初始化问题：
        1. f[0][0][0] = 0：带入状态表示含义，会发现这是一种合法情况，初始化为0即可，表示合法
        2. f[0][i][j] = INF：其他初始化为正无穷，这不是一种合法情况，因此初始化为无法使用到的值即可！
                             本题求最小值，因此将其初始化为正无穷就无法用它来更新其他人！

    状态表示总结：
        1、体积至多，f[i,k] = 0（只会求价值的最大值）
        2、体积恰好，
            当求价值的最小值：f[0][0] = 0, 其余是INF
            当求价值的最大值：f[0][0] = 0, 其余是-INF
        3、体积至少，f[0][0] = 0，其余是INF（只会求价值的最小值）
*/

int main()
{
    cin >> m1 >> m2 >> n;

    memset(f, 0x3f, sizeof f);
    f[0][0] = 0;

    for(int i = 0; i < n; i ++)
    {
        int v1, v2, w; 
        cin >> v1 >> v2 >> w;
        for(int j = m1; j >= 0; j --)
        	for(int k = m2; k >= 0; k --)
        		f[j][k] = min(f[j][k], f[max(0, j - v1)][max(0, k - v2)] + w);
    }
    
    cout << f[m1][m2] << endl;
    return 0;
}

32、数字组合

给定 N 个正整数 A1,A2,…,AN，从中选出若干个数，使它们的和为 M，求有多少种选择方案。
M看成背包容量，把每个数看作一个物品，Ai看作某个物品的体积， 目标：求总体积恰好为M的方案数.

#include <iostream>
using namespace std;

const int N = 10010;
int f[N];

int main()
{
    int n,m;
    cin >> n >> m;
    f[0]=1; // 恰好凑0为1种方案
    for(int i=0;i<n;i++)
    {
        int v;
        cin >> v;
        for(int j=m;j>=v;j--) f[j]+=f[j-v];
    }
    cout<<f[m];
    return 0;
}

33、买书

小明手里有n元钱全部用来买书，书的价格为10元，20元，50元，100元。
问小明有多少种买书方案？（每种书可购买多本）
f[i][j]:从前i个物品中选，且总体积恰好是j的方案书.

#include <iostream>
using namespace std;

const int N = 1010;
int f[N];
int n,m;

int main()
{
    cin >> m;
    int w[]={10,20,50,100};
    n=4;
    f[0]=1;
    for(int i=0;i<n;i++)
        for(int j=w[i];j<=m;j++)
            f[j]+=f[j-w[i]];
    
    cout<<f[m];
    return 0;
}

34、蒙德里安的梦想（状态DP）

求把 N×M 的棋盘分割成若干个 1×2 的的长方形，有多少种方案。
例如当 N=2，M=4 时，共有 5 种方案。当 N=2，M=3 时，共有 3 种方案。
如下图所示：

#include <iostream>
#include <cstring>
using namespace std;

const int N = 12, M = 1<<N;
typedef long long LL;
LL f[N][M];
bool st[M];

int main()
{
    int n,m;
    while(cin>>n>>m, n||m)
    {
        for(int i=0;i<1<<n;i++)
        {
            st[i]=true;
            int cnt=0;
            for(int j=0;j<n;j++)
                if(i>>j&1)
                {
                    if(cnt&1)
                    {
                        st[i]=false;
                        break;
                    }
                }
                else
                    cnt++;
            if(cnt&1) st[i]=false;
        }
        
        memset(f,0,sizeof f);
        f[0][0]=1;
        for(int i=1;i<=m;i++)
            for(int j=0;j<1<<n;j++)
                for(int k=0;k<1<<n;k++)
                    if((j&k)==0 && st[j|k])
                        f[i][j] += f[i-1][k];
                        
        cout<<f[m][0]<<endl;
        
    }
    return 0;
}