Acwing动态规划（C++例题与答案）（顺序五）

门前云梦

已于 2024-07-11 17:04:43 修改

阅读量281

点赞数 5

分类专栏：算法与数据结构文章标签：动态规划 c++ 算法

于 2024-07-11 16:58:26 首次发布

算法与数据结构专栏收录该内容

6 篇文章

订阅专栏

背包问题

01背包

例题（01）

一个题解

#include<iostream>
using namespace std;

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

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 = 0;j <= m;j++){
            f[i][j] = f[i-1][j];
            if(j >= v[i]) f[i][j] = max(f[i][j],f[i-1][j-v[i]]+w[i]);
        }
    }
    cout << f[n][m]<< endl;
    return 0;
}

完全背包

例题

一个题解

#include<iostream>
using namespace std;
const int N = 1010;
int f[N];
int v[N],w[N];
int main()
{
    int n,m;
    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]<<endl;
}

多重背包1

例题

一个题解

#include<iostream>
using namespace std;

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

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 = 1;j <= m;j++){
            for(int k = 0;k <= s[i] && j >= k*v[i] ;k++){
                f[i][j] = max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
            }
        }
    }
    
    cout << f[n][m]<<endl;
    return 0;
}

多重背包2

例题

一个题解

#include <iostream>
#include <algorithm>

using namespace std;

// 物品个数最多是1000 x log2000 
const int N = 12010, M = 2010;

int n, m;
int v[N], w[N];
int f[M];

int main()
{
    cin >> n >> m;

    int cnt = 0;
    for (int i = 1; i <= n; i ++ )
    {
        // 对于每一种物品 i 都进行打包操作 1 2 4 8 .... c (c = s - 1 - 2 - 4 - 8 ...)
        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] = a * s;
            w[cnt] = b * s;
        }
    }
    
    n = cnt;
    
    // 对分好组的 n 包物品做 0 - 1 背包问题
    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] << endl;

    return 0;
}

分组背包

例题

一个题解

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

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

int main()
{
    cin >> n >> m;

    for (int i = 1; i <= n; i ++ ) // n组物品
    {
        cin >> s[i]; 
        for (int j = 0; j < s[i]; j ++ )
            cin >> v[i][j] >> w[i][j]; // v[i][j]、w[i][j]表示第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 (v[i][k] <= j)
                    f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);

    cout << f[m] << endl;

    return 0;
}

线性DP

数字三角形

一个题解

#include<iostream>
using namespace std;

const int N = 510,INF = 1e9;
int n;
int a[N][N];
int f[N][N];

int main(){
    cin >> n;
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= i;j++)
            cin >> a[i][j];
    
    // 为什么从0开始？因为最左端会获得来着0的不存在的节点
    for(int i = 0;i <= n;i++)
        // 为什么从i+1结束？ 因为最右端会获得来着i+1的不存在的节点
        for(int j = 0;j <= i+1;j++)
            f[i][j] = -INF;
    
    f[1][1] = a[1][1];
    
    // 为什么i从2开始，j从1开始？
    // f[1][1]附初值，需要从第二行开始计算
    for(int i = 2;i <= n;i++)
        for(int j = 1;j <=i;j++)
            f[i][j] = max(f[i-1][j-1]+a[i][j],f[i-1][j]+a[i][j]);
    
    int res = -INF;
    for(int i = 1;i<= n;i++)    
        res =  max(res,f[n][i]);
    
    cout << res << endl;
    return 0;
}

最长上升子序列1

一个题解

#include<iostream>
using namespace std;

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

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

最长上升子序列2

一个题解

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int n;
int a[N]; // 存储数列
int q[N]; // 存储子序列长度结尾元素的最小值
/*
    如q[2],表示上升序列长度为2时，结尾元素最小值为q[2]
    即若有子序列 1  2 和子序列 1  5; 
    因为2 < 5,所以q[2] = 2
*/

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

    int len = 0; // 前i个数最大的上升子序列的值
    /* 枚举每个数a[i]，做如下操作
        1. 二分出数组q中小于a[i]的最大的数，因为要将a[i]插到该序列之后
        2. 更新前i个数最大的上升子序列的值：len = max(len, r + 1);
        3. 将a[i]插到序列长度为r的后面,更新q:q[r + 1] = a[i];
    */
    for (int i = 0; i < n; i ++ )
    {
        // 二分出小于a[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;
        }
        // 更新前i个数最大的上升子序列的值
        len = max(len, r + 1);
        // 更新q
        q[r + 1] = a[i];
    }

    printf("%d\n", len);

    return 0;
}

最长公共子序列

一个题解

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
char a[N], b[N];
int f[N][N];

int main()
{
    scanf("%d%d", &n, &m);
    scanf("%s%s", a + 1, b + 1);

    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]);
            if (a[i] == b[j]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
        }

    printf("%d\n", f[n][m]);

    return 0;
}

区间DP

例题

一个题解

#include<iostream>
using namespace std;

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

int main(){
    cin >> n;
    for(int i = 1;i <= n;i++) cin >> s[i];
    for(int i = 1;i <= n;i++) s[i] = s[i] + s[i-1]; 
    
    // 对于每一种长度，求i 从 1 、2 、 3 ... 开始的情况
    for(int len = 2;len <= n;len++){
        for(int i = 1;i + len - 1 <= n ;i++){
            int l = i,r = i + len - 1;
            f[l][r] = 1e9;
            // 在这个给定的长度 k 中再划分集合、状态转移
            for(int k = l;k < r; k++){
                f[l][r] = min(f[l][r],f[l][k]+f[k+1][r]+s[r]-s[l-1]);
            }
        }
    }
    cout << f[1][n] << endl;
    return 0;
}

计数类DP

例题

一个题解

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010, mod = 1e9 + 7;

int n;
int f[N];

int main()
{
    cin >> n;

    f[0] = 1;
    
    for (int i = 1; i <= n; i ++ )
        for(int j = i; j <= n; j ++ ){
            f[j] = (f[j] + f[j - i]) % mod;
        }
            
    cout << f[n] << endl;

    return 0;
}

数位统计类DP

例题

一个题解

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 10;

/*

001~abc-1, 999

abc
    1. num[i] < x, 0
    2. num[i] == x, 0~efg
    3. num[i] > x, 0~999

*/

// 获取num中以l开头，r结尾组成的数是多少，就是求思路中的“abc”
int get(vector<int> num, int l, int r)
{
    int res = 0;
    for (int i = l; i >= r; i -- ) res = res * 10 + num[i];
    return res;
}

// 求10的x次方
int power10(int x)
{
    int res = 1;
    while (x -- ) res *= 10;
    return res;
}

// count函数用于计数 1 ~ n 中，x出现的次数
int count(int n, int x)
{
    if (!n) return 0; // 如果n为0，返回0；因为我们统计的是从1~n中每个数出现的次数（注意数据范围取不到0的）

    // num数组用于存储每一位上的数是多少（注意是倒着的，因此在下面for循环时，也是倒着遍历的）
    vector<int> num; 
    // 如 n = 12345
    // 则 num = {5,4,3,2,1}
    while (n)
    {
        num.push_back(n % 10);
        n /= 10;
    }
    // n此时表示原来n有多少位，然后用于计算i在每一位上的数有多少个
    n = num.size();
    
    // 计算i在每一位上的数有多少个
    int res = 0;
    // - !x的作用是，当x = 0时，要统计0在每一位上的数的个数，因为0不能在首位，所以此时 - !x = -1 ，即从第二位开始枚举
    for (int i = n - 1 - !x; i >= 0; i -- )
    {
        // ---------------------------第 ① 种情况---------------------------
        if (i < n - 1) // 枚举到最高位时，第①种情况是不存在的，因此需要i < n - 1特判一下
        {
            res += get(num, n - 1, i + 1) * power10(i); 
            if (!x) res -= power10(i); // 如果 x == 0,要减去在首位的计数
        }
        // ---------------------------第 ② 种情况---------------------------
        // ② 中 第 Ⅰ 种情况，为0，不用写
        if (num[i] == x) res += get(num, i - 1, 0) + 1; // 即 ② 中的第 Ⅱ 种情况 (d = x)
        else if (num[i] > x) res += power10(i); // 即 ② 中的第 Ⅲ 种情况  （d > x）
    }

    return res;
}

int main()
{
    int a, b;
    while (cin >> a >> b , a)
    {
        if (a > b) swap(a, b); // 保证 b 是始终大于 a 的（因为题目中输入的第一个数 a 有可能大于第二个数 b ）

        // 计算的是b和a中i出现的次数
        // 要求的是b到a之间的数的数，因此采用前缀和的思想，用b的计数-a的计数
        for (int i = 0; i <= 9; i ++ )
            cout << count(b, i) - count(a - 1, i) << ' ';
        cout << endl;
    }

    return 0;
}

状态压缩DP

例题

一个题解

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

using namespace std;

typedef long long LL;

const int N = 12, M = 1 << N; // M 最多是 2 的 N 次方

int n, m;
LL f[N][M]; 
vector<int> state[M]; // 存储所有的合法状态
bool st[M]; // 判断当前这一列空着的连续块是不是2的偶数倍（即判断这一列是否合法）

int main()
{   
    // 输入n和m，当n和m都为0的时候退出循环
    while (cin >> n >> m, n || m)
    {   
        // 循环2的n次方次，处理st数组？---------------问题一：为什么是2的n次方次循环
        // 这个循环其实表示的是每列的每种状态，如i = 1011下，当前这一列空着的连续块是不是2的偶数倍
        // 因为对于每一行，都有选和不选两种情况，则对n行，有2的n次方种选法，则要循环2的n次方次
        for (int i = 0; i < 1 << n; i ++ )
        {
            // i表示的是什么？ i =(1011)2进制=(11)10进制
            int cnt = 0; // cnt表示0的个数
            bool is_valid = true;
            for (int j = 0; j < n; j ++ )
                if (i >> j & 1) // 如果当前位为 1,判断前面的空格的数量是不是偶数个-----------问题二：这行代码是什么意思？
                {
                    if (cnt & 1) // 判断前面的空格的数量是不是偶数个------------------问题三：这行代码是什么意思？
                    {
                        is_valid = false; // 不是偶数个，直接置位false
                        break;// break
                    }
                    cnt = 0; // 如果是偶数个，则从这行起，重新开始计算空格的数量
                }
                else cnt ++ ; // 如果当前位为0，则继续计数，cnt++
            if (cnt & 1) is_valid = false; // 遍历到末尾，如果最后这段0的个数是奇数个，则将is_valid置为false
            
            st[i] = is_valid; // 经过以上代码，便统计完这列了，将这列是否合法记在st数组中
        }
        
        // 枚举所有的合法状态
        for (int i = 0; i < 1 << n; i ++ )
        {
            state[i].clear();
            for (int j = 0; j < 1 << n; j ++ )
                // 满足放置横着的1x2块的合法的两个条件
                if ((i & j) == 0 && st[i | j]) //C++中， | 表示按位或
                    // 将j存到state[i]----------------问题四：这行代码是什么意思？
                    state[i].push_back(j); // 将i列的合法的行j存在state[i]中
        }
        
        
        memset(f, 0, sizeof f);
        f[0][0] = 1;
        for (int i = 1; i <= m; i ++ )
            for (int j = 0; j < 1 << n; j ++ )
                // 对于每个状态f[i][j] ,枚举所有在这列的合法的状态state[k]，dp
                for (auto k : state[j])
                    // 将所有合法的方案加起来
                    f[i][j] += f[i - 1][k];

        cout << f[m][0] << endl;
    }

    return 0;
}

树形DP

例题

一个题解

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

using namespace std;

const int N = 6010;

int n;
int h[N], e[N], ne[N], idx;
int happy[N];
int f[N][2];
bool has_fa[N]; // 存储没有父节点的节点---即根节点

// 邻接表存边
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs(int u)
{
    f[u][1] = happy[u];
    
    // 计算这个点所连的所有边（即遍历所有该节点的子节点）
    for (int i = h[u]; i!=-1; i = ne[i])
    {
        // dfs计算每个节点选与不选的happy最大值
        int j = e[i];
        dfs(j);

        f[u][1] += f[j][0];
        f[u][0] += max(f[j][0], f[j][1]);
    }
}

int main()
{
    scanf("%d", &n);

    for (int i = 1; i <= n; i ++ ) scanf("%d", &happy[i]);

    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(b, a);// b是a的直接上司，即b是a的父节点
        has_fa[a] = true;// a有父节点为b，因此将其置位true
    }
    
    // 求出根节点，即has_fa为false的节点，即没有父节点的节点
    int root = 1;
    while (has_fa[root]) root ++ ;
    
    // 从根节点开始dfs
    dfs(root);
    
    printf("%d\n", max(f[root][0], f[root][1]));

    return 0;
}

记忆化搜索

例题

一个题解

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

const int N = 310;
int n,m;
int g[N][N];
int f[N][N];
// -------------问题二：这两个数组是什么意思？-------------------
int dx[4] = {-1,0,1,0},dy[4] = {0,-1,0,1};
    
int dp(int x,int y){
    // if(f[x][y] != -1) return f[x][y]; 记忆化搜索的核心！！
    if(f[x][y] != -1) return f[x][y]; // 如果这个点已经计算过了，直接返回即可，这就是记忆化搜索
    f[x][y] = 1;
    for(int i = 0;i < 4;i++){
        int a = x + dx[i],b = y + dy[i];
        if(a >= 1 && a <= n && b >= 1 && b <= m&& g[a][b] > g[x][y]){
            f[x][y] = max(f[x][y],dp(a,b)+1);
        }
    }
    return f[x][y];
}

int main(){
    cin >> n >> m;
    for(int i = 1;i <= n;i++)
        for(int j = 1 ; j <= m;j++)
            cin >> g[i][j];
    //---------------问题一：为什么要初始化为-1？-----------------
    memset(f,-1,sizeof f);
    int res = -1;
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= m;j++){
            res = max(res,dp(i,j));
        }
    }
    cout << res << endl;
    return 0;
}