DP入门鸭

@DP入门

---

前言

1.定义:给定一个问题，我们把它拆分成若干子问题，直到子问题可以直接解决，然后把子问题的答案保存起来，以减少重复计算，再根据子问题答案反推，得到原问题解。
2.核心思想：递推
3.DP=DFS+记忆化搜索

一.经典中的经典：01背包问题

解法一：DFS+记忆化搜索

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int mem[N][N];//记忆数组
int dfs(int x,int spV){
    if(mem[x][spV])return mem[x][spV];
    int sum;
    if(x>n)sum=0;
    else if(spV<v[x])sum= dfs(x+1,spV);
    else sum= max(dfs(x+1,spV),dfs(x+1,spV-v[x])+w[x]);
    mem[x][spV]=sum;
    return sum;
}
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d %d",&v[i],&w[i]);
    }
    int res=dfs(1,m);
    printf("%d",res);
    return 0;
}

解法二：dp

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int mem[N][N];//mem[i][j]代表从第i个物品到第n个物品分配j体积所达到 的最大价值。
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d %d",&v[i],&w[i]);
    }
    for(int i=n;i>=1;i--){
        for(int j=0;j<=m;j++){
            if(j<v[i])mem[i][j]=mem[i+1][j];
            else mem[i][j]=max(mem[i+1][j],mem[i+1][j-v[i]]+w[i]);
        }
    }
    printf("%d",mem[1][m]);
    return 0;
}

对解法二空间优化

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N];
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d %d",&v[i],&w[i]);
    }
    for(int i=n;i>=1;i--){
        for(int j=m;j>=0;j--){//这里j必须倒序
        	if(j>=v[i])f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    printf("%d",f[m]);
    return 0;
}

二、背包问题集锦

1.二维费用的背包问题

tips:就是开一个三维数组，其他没区别

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int v1,m1,n1;
int v[N],w[N],m[N];
int f[N][102][102];
int main(){
    scanf("%d %d %d",&n1,&v1,&m1);
    for(int i=1;i<=n1;i++){
        scanf("%d %d %d",&v[i],&m[i],&w[i]);
    }
    for(int i=n1;i>=1;i--){
        for(int j=m1;j>=0;j--){
            for(int k=v1;k>=0;k--){
                if(j>=m[i]&&k>=v[i])f[i][j][k]=max(f[i+1][j][k],f[i+1][j-m[i]][k-v[i]]+w[i]);
                else f[i][j][k]=f[i+1][j][k];
            }
        }
    }
    printf("%d",f[1][m1][v1]);
    return 0;
}

2.完全背包问题

tips:递推公式有改变，其他没区别

#include<bits/stdc++.h>
using namespace std;
const int N=1002;
int n,m;
int v[N],w[N];
int f[N][N];
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d %d",&v[i],&w[i]);
    }
    for(int i=n;i>=1;i--){
        for(int j=v[i];j<=m;j++){//注意要正序！！！
            if(j>=v[i])f[i][j]=max(f[i+1][j],f[i][j-v[i]]+w[i]);
            else f[i][j]=f[i+1][j];
        }
    }
    printf("%d",f[1][m]);
    return 0;
}

空间优化：

#include<bits/stdc++.h>
using namespace std;
const int N=1002;
int n,m;
int v[N],w[N];
int f[N];
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d %d",&v[i],&w[i]);
    }
    for(int i=n;i>=1;i--){
        for(int j=v[i];j<=m;j++){
           f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    printf("%d",f[m]);
    return 0;
}

三.题目强化

1.最小花费爬楼梯

简单题

2.最长递增子序列（lc300）

最重要的两点：1.mem数组含义：以下标为i的数字为结尾的最长子序列长度 2.递推含义：以下标为i的数字结尾的最长子序列的长度=以此序列的倒数第二位数字为结尾的最长子序列长度+1

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int>mem(nums.size());
        int tmp=nums[0];
        for(int i=0;i<nums.size();i++){
            mem[i]=1;
            for(int j=0;j<i;j++){
                if(nums[j]<nums[i])mem[i]=max(mem[i],mem[j]+1);
            }
        }
        int res=1;
        for(int i=0;i<nums.size();i++){
            res=max(res,mem[i]);
        }
        return res;
    }
};

3.零钱兑换(lc322)

题解：
1.mem[i][j]含义：当可选硬币从第i个到第n个，组成总金额的最少硬币个数。
2.递推公式：完全背包问题
3.和完全背包不同的是，需要刚好等于总金额，故初始化数组为无穷大代表不能组成总金额（这里amount+1可以充当无穷大），同时mem[%d][0]应为0，代表可以组成总金额。

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int mem[13][10002];
        mem[coins.size()][0]=0;
        for(int i=0;i<=coins.size();i++){
            for(int j=1;j<=amount;j++){
                mem[i][j]=amount+1;
            }
        }
        for(int i=coins.size()-1;i>=0;i--){
            mem[i][0]=0;
            for(int j=1;j<=amount;j++){
                if(j>=coins[i])mem[i][j]=min(mem[i+1][j],mem[i][j-coins[i]]+1);
                else mem[i][j]=mem[i+1][j];
            }
        }
        return mem[0][amount]>amount?-1:mem[0][amount];
    }
};

用滚动数组优化空间

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int>mem(amount+1,amount+1);
        mem[0]=0;
        for(int i=coins.size()-1;i>=0;i--){
            for(int j=1;j<=amount;j++){
                if(j>=coins[i])mem[j]=min(mem[j],mem[j-coins[i]]+1);
            }
        }
        return mem[amount]>amount?-1:mem[amount];
    }
};

另一种角度：mem[i]含义：组成金额i的最少硬币个数
递推式：mem[i]等于mem[i-coin[1~n]]+1（如果有含义的话）中的最小值。
代码如下：

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1,amount + 1);  //这里之所以都填充成amount + 1是因为如果初始成0或者-1，求min的时候会无法耿新，所
        //初始化成amount + 1，因为钱币的最小金额就是1，构成amount的最大钱币数量就是amount个
        dp[0] = 0;
        for(int i = 1;i <= amount;i++) {
            for(auto& coin:coins) {
                if(i >= coin) {
                    dp[i] = min(dp[i],dp[i - coin] + 1);
                }
            }
        }
        return dp[amount] > amount ? -1 : dp[amount]; //之所以有大于amount的情况比如样例二，因为在计算i=3的时候min里面的两个值
        //都是4，一个是本身初始化amount + 1的四，一个是经过min算出的一个4；
    }
};

4.整数拆分（lc343）

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1,1);//默认情况下dp[0]=1,dp[1] = 1,dp[2] =1;这个里面默认是有两个及以上的
        for(int i=3;i<=n;i++){
            for(int j =1;j<=i/2;j++){//只需要遍历一半就行
                dp[i] = max(max(dp[i],j*dp[i-j]),j*(i-j));
            }
        }
        return dp[n];
    }
};

总结

这仅仅是最简单的DP题，还有更高的山在等着我们！！！