Acwing提高课-DP(背包模型)

最新推荐文章于 2024-02-04 16:07:07 发布
最新推荐文章于 2024-02-04 16:07:07 发布
阅读量169 收藏
点赞数
分类专栏： # ACM&基础dp 文章标签： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acm_durante/article/details/123970883
版权

1、01背包

1. 基本01背包(压维度)

  1. dp[i]:前i个物品，体积为j的最大价值
    for(int i = 1; i <= m; i++) //前i个物品
    {
        for (int j = t; j >= a[i].time; j--)
        {
            dp[j] = max(dp[j - a[i].time] + a[i].val, dp[j]);
        }
    }

2. 01背包记录方案

  1. dp[j]:前i个数，体积为j的种类数
  2. 初始状态: d p [ 0 ] = 1 dp[0] = 1 dp[0]=1
  3. 转移方程: d p [ i ] [ j ] + = d p [ i − 1 ] [ j − x ] ) dp[i][j] += dp[i-1][j-x]) dp[i][j]+=dp[i−1][j−x])
  4. ACcode:
/*
 * @Author: 0iq
 * @LastEditTime: 2022-01-10 15:34:26
 * @CSDN blog: https://blog.csdn.net/acm_durante
 * @E-mail: 1055323152@qq.com
 * @ProbTitle: 01背包方案数量
 */
// #pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
const int N = 1e4 + 8;
int dp[N]; // 选前i个数使得和为j的种类
int main()
{
    IOS;
    int n, m;
    cin >> n >> m;
    dp[0] = 1;
    rep(i, 1, n)
    {
        int x;
        cin >> x;
        for (int j = m; j >= x; j--)
        {
            dp[j] += dp[j - x];
        }
    }
    cout << dp[m];
    return 0;
}

2、完全背包

1. 货币系统

  1. 问题描述:给你n个数a[i]，a[i]可以使用任意次，现问你这个n个数有哪些只能被唯一表示。
  2. 完全背包记录方案，当dp[i] = 1时，代表值为i的数，只能由一个数组成，及ans++。
  3. ACcode：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
const int N = 25010;
int dp[N];
int n;
int t;
int a[105];
int maxx = 0;
int main()
{
    IOS;
    cin >> t;
    while (t--)
    {
        int n;
        cin >> n;
        rep(i, 1, n) cin >> a[i],maxx = max(maxx,a[i]);
        memset(dp, 0, sizeof(dp));
        
        dp[0] = 1;
        for (int i = 1; i <= n; i++)
        {
            for (int j = a[i]; j <= maxx; j++)
            {
                dp[j] += dp[j - a[i]];
            }
        }
        int ans = 0;
        for(int i = 1; i <= n;i++)
        {
            if(dp[a[i]] == 1) ++ans;
        }
        cout << ans << '\n';
    }

    return 0;
}

3、多重背包

1、多重背包问题(二进制优化)

  1. 多重背包二进制优化后，转换为01背包
  2. ACcode:
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
vector<pair<int, int>> ve;
int dp[2004];
int main()
{
    IOS;
    int n, v;
    cin >> n >> v;
    rep(i, 1, n)
    {
        int av, aw, as;
        cin >> av >> aw >> as;
        //二进制优化
        int cnt = 1;
        while (as >= cnt)
        {
            ve.push_back({av * cnt, aw * cnt});
            as -= cnt;
            cnt <<= 1;
        }
        if (as > 0)
            ve.push_back({av * as, aw * as});
    }
    int len = ve.size();
    for (int i = 0; i < len; i++)
    {
        for (int j = v; j >= ve[i].first; j--)
        {
            dp[j] = max(dp[j], dp[j - ve[i].first] + ve[i].second);
        }
    }
    cout << dp[v];
    return 0;
}

2、多重背包(朴素版)

  1. dp[i][j]:选择前i个物品，体积为j的最大价值
  2. 三重循环：一维是枚举物品，二维是枚举价值，三维是枚举决策(选择该物品的数量)
  3. ACcode:
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
const double PI = acos(-1.0);
struct node
{
    int v, w, s;
} a[505];
int dp[6002];
int main()
{
    IOS;
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> a[i].v >> a[i].w >> a[i].s;
    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= 0; j--) //枚举价值
        {
            for (int k = 0; k <= a[i].s && k * a[i].v <= j; k++) //决策
            {
                dp[j] = max(dp[j], dp[j - a[i].v * k] + a[i].w * k);
            }
        }
    }
    cout << dp[m];
    return 0;
}

4、二维费用背包

1、潜水员

  1. 询问体积至少是j的最小花费。
  2. 费用背包类型：
    1. 体积最多为j：dp[i][j],表示前i个物品，体积至多为j，初始值全为0，v >= 0
    2. 体积恰好为j：dp[i][j],表示前i个物品，体积恰好为j，dp[0][0] = 0,其余全是inf，v >= 0
    3. 体积至少为j：dp[i][j],表示前i个物品，体积至少为j，dp[0][0] = 0,其余全是inf，v 可以小于0
      • 转移方程: d p [ i ] [ j ] = m a x ( d p [ i ] [ j ] , d p [ i ] [ m a x ( j − a , 0 ) ] + w ) dp[i][j] = max(dp[i][j],dp[i][max(j-a,0)]+w) dp[i][j]=max(dp[i][j],dp[i][max(j−a,0)]+w)，体积至少为 m a x ( j − a , 0 ) ] max(j-a,0)] max(j−a,0)]，装上物品a，则是体积至少为 j j j
  3. ACcode：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
const int N = 1e4 + 4;
int n, m, k;
int dp[505][505]; //至少是i和j的最小费用
int main()
{
    IOS;
    cin >> n >> m >> k;
    memset(dp, 127, sizeof(dp));
    dp[0][0] = 0;
    for (int i = 1; i <= k; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;

        for (int j = n; j >= 0; j--)
        {
            for (int z = m; z >= 0; z--)
            {

                dp[j][z] = min(dp[j][z], dp[max(j - a, 0)][max(z - b, 0)] + c);
            }
        }
    }
    cout << dp[n][m];
    return 0;
}

3、分组背包

1、模板题

  1. dp[i][j]:前i组物品，j容量的最大价值
  2. 第一维枚举组，第二维枚举当前组的各个物品，第三维枚举体积
  3. ACcode
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
const int N = 105;
// int dp[N][N]; //前i组物品，j容量的最大价值
int n, v;
int main()
{
    IOS;
    //不压缩
    // cin >> n >> v;
    // for (int i = 1; i <= n; i++)
    // {
    //     int s;
    //     cin >> s;
    //     for (int k = 1; k <= s; k++)
    //     {
    //         int av, aw;
    //         cin >> av >> aw;
    //         for (int j = 1; j <= v; j++)
    //         {
    //             dp[i][j] = max(dp[i][j], dp[i - 1][j]); //必须加这一句，否则无法比较出选择第i组的最值
    //             if (j >= av)
    //                 dp[i][j] = max(dp[i - 1][j - av] + aw, dp[i][j]);
    //         }
    //     }
    // }
    // cout << dp[n][v];
    //压缩
    int dp[N];
    memset(dp, 0, sizeof(dp));
    cin >> n >> v;
    int av[N], aw[N];
    for (int i = 1; i <= n; i++)
    {
        int s;
        cin >> s;
        for (int k = 1; k <= s; k++)
            cin >> av[k] >> aw[k];
        for (int j = v; j >= 1; j--)
        {
            for (int k = 1; k <= s; k++)
            {
                if (j >= av[k])
                    dp[j] = max(dp[j], dp[j - av[k]] + aw[k]);
            }
        }
    }
    cout << dp[v];
    return 0;
}

2、机器分配

  1. 分组背包求方案数，不能压缩状态，求方案时，从dp[n][m]倒序枚举。
  2. ACcode
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
int n, m; //m相当于体积
int dp[15][30];
int a[15][30];
int ans[15];
int main()
{
    IOS;
    cin >> n >> m;
    rep(i, 1, n)
            rep(j, 1, m)
                cin >> a[i][j];
    for (int i = 1; i <= n; i++) //前i个公司
    {
        for (int j = 1; j <= m; j++) //j体积
        {
            dp[i][j] = dp[i - 1][j];     //不选
            for (int k = 1; k <= m; k++) //决策选择哪个机器
            {
                if (j >= k)
                    dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + a[i][k]); //选择i公司的k物品
            }
        }
    }
    cout << dp[n][m] << "\n";
    int v = m;
    for (int i = n; i; i--) //公司
    {
        for (int k = 1; k <= m; k++) //决策
        {
            if (v >= k && dp[i][v] == dp[i - 1][v - k] + a[i][k])
            {
                
                ans[i] = k;
                v -= k;
                break;
            }
        }
    }
    rep(i,1,n) cout << i << " " << ans[i] << "\n";
    return 0;
}

4、有依赖的背包

1、 有依赖的背包问题

  1. 树形DP套01背包,将u号节点的儿子看做物品，儿子的属性看做体积，儿子的dp则为价值。
  2. ACcode:
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)

const int N = 104;
struct node
{
    int v, w;
} a[N];
vector<int> e[N];
int n, av;
int dp[N][N]; //i号节点的j体积
void dfs(int u, int fa)
{
    for (auto v : e[u]) //循环物品
    {
        if (v == fa)
            continue;
        dfs(v, u);
        for (int j = av - a[u].v; j >= 0; j--) //循环体积
        {
            for (int k = 0; k <= j; k++) //循环决策
                dp[u][j] = max(dp[u][j], dp[u][j - k] + dp[v][k]);
        }
    }
    /*
    将父亲节点的物品放入，单独考虑
    */
    for (int i = av; i >= 0; i--)
    {
        if (i >= a[u].v)
            dp[u][i] = dp[u][i - a[u].v] + a[u].w;
        else
            dp[u][i] = 0;
    }
}
int main()
{
    IOS;

    cin >> n >> av;
    int rt = 0;
    rep(i, 1, n)
    {
        int p;
        cin >> a[i].v >> a[i].w >> p;
        if (p == -1)
            rt = i;
        else
        {
            e[p].push_back(i);
            e[i].push_back(p);
        }
    }
    dfs(rt, 0);
    cout << dp[rt][av];
    return 0;
}

5、背包求方案数

1、背包问题求方案数

  1. 在01背包的基础上，求解最优解法的方案数。
  2. 在传统01背包的基础上，我们在设一个dp[i][j],表示前i个物品中，体积恰好为j时，最优解的方案数量。
  3. ACcode
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;
int dp[1002], dp2[1002]; //dp:前i个物品j体积的最大价值，dp2:前i个物品j体积的的最优解数量
int main()
{
    IOS;
    int n, v;
    cin >> n >> v;
    dp2[0] = 1;
    for(int i = 1; i <= n ; i++)
    {
        int av, aw;
        cin >> av >> aw;
       
       	for(int j = v; j >= av; j--)
        {
            int maxx = max(dp[j], dp[j - av] + aw), cnt = 0;
            if (maxx == dp[j])
                cnt += dp2[j],cnt %= mod;
            if (maxx == dp[j - av] + aw)
                cnt += dp2[j - av],cnt %= mod;
            dp2[j] = cnt;
            dp[j] = maxx;
        }
    }
    int ans = 0;
    for(int i = 0 ; i <= v; i++ ) if (dp[i] == dp[v]) ans += dp2[i], ans %= mod;
    cout << ans;
    return 0;
}

2、背包问题求具体方案数

  1. 归结到图论中进行。DP其实出来就是一张DAG图
  2. ACcode
/*
若求字典序最小，则贪心进行，将一个物品分为三种情况
1. 只能选
2. 只能不选
3. 可选可不选
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define lowbit(x) ((x) & -(x))
#define lson p << 1, l, mid
#define rson p << 1 | 1, mid + 1, r
#define mem(a, b) memset(a, b, sizeof(a))
#define IOS                      \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0)
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;

const int N = 1004;
int dp[N][N];
struct node
{
    int v, w;
} a[N];
int n, m;

int main()
{
    IOS;
    cin >> n >> m;
    rep(i, 1, n)
            cin >> a[i].v >> a[i].w;
    for (int i = n; i >= 1; i--) //字典序最小，翻转过来再dp
        for (int j = 0; j <= m; j++)
        {
            if (j >= a[i].v)
                dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - a[i].v] + a[i].w);
            else
                dp[i][j] = dp[i + 1][j];
        }
    int j = m;
    for (int i = 1; i <= n; i++)
    {
        if (j >= a[i].v && dp[i][j] == dp[i + 1][j - a[i].v] + a[i].w)
        {
            cout << i << " ";
            j -= a[i].v;
        }
    }

    return 0;
}
0iq2333
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AcWing 单调队列优化DP问题 1088. 旅行问题
皓首不倦 不负少年
08-02 157
import sys sys.stdin = open('data.txt', 'r') ''' 问题做一下转换，把环拆开，组成长度为原来两倍的序列，把每个车站的油量和下一步的距离的差值 作为数组元素的数值，对这个长度是2n的数组求前缀和序列，其实题目要求的就是所有长度是n的滑动 窗口里面前缀和的最小值和窗口开始位置前面一个前缀和的差值的最小值是不是小于0，如果小于0， 说明中间n次移动至少有一次出现了没有油的情况，顺时针和逆时针都做一遍单调队列求滑动窗口最小值 的流程，两次结果有一次是成功的，就可以从.
Acwing提高课DP二刷（考研复习）
Alanrookie的博客
04-04 763
DP 1.acwing1010 导弹拦截 题目大意：利用若干组互相独立的单调序列去覆盖原序列 思路：贪心解决 2.AcWing 187. 导弹防御系统 思路：爆搜+贪心 3.AcWing 272. 最长公共上升子序列 思路：dp(i,j)表示a数组从前i个数里面选，b数组从前j个数组里面选，且以bj结尾的最长公共上升子序列的长度，然后根据题意进行状态状态转移。 PS:直接进行状态转移会发现这题会超时，可以先把超时的代码写下来，然后再做等价变形。背包转移的化简与此相同，这种等价变形类的DP可以说很经典了 .
【AcWing】线性DP、区间DP、计数类DP
m0_70948728的博客
07-25 401
线性DP、区间DP、计数类DP
AcWing算法学习笔记：动态规划（背包 + 线性dp + 区间dp + 计数dp + 状态压缩dp + 树形dp + 记忆化搜索）
最新发布
一只可爱的小猴子的博客
02-04 1130
若体积从小到大进行遍历，当更新f[i, j]时，f[i - 1, j - vi] 已经在更新f[i, j - vi]时被更新了。因此体积需要从大到小进行遍历，当更新f[i, j]时，f[i - 1, j - vi] 还未被更新。并枚举每一个数字，若以该数字结尾的序列，其倒数第二个数字应该是小于该数字的最大的数。更新状态时，记录每一位子串是由哪一位结尾的子串转移而来的。将f[i]与f[i - 1]轮流交替使用数组进行存储。枚举每一个分组内的物品，进行01背包的选法策略。由于不存在01背包中的更新覆盖的情况。
Acwing动态规划计数DP——整数划分
Studying Blog by Bryce Gu
02-24 643
题目： 一个正整数nn可以表示成若干个正整数之和，形如：n=n1+n2+…+nk，其中n1≥n2≥…≥nk,k≥1。 我们将这样的一种表示称为正整数nn的一种划分。 现在给定一个正整数n，请你求出n共有多少种不同的划分方法。 输入格式 共一行，包含一个整数n。 输出格式 共一行，包含一个整数，表示总划分数量。 由于答案可能很大，输出结果请对1e9+7 取模。 数据范围 1≤n≤1000 思路详解： 这道题主要可以用到完全背包的思想： 可以将题意理解为面对一个...
【AcWing】【DP--状态机模型】
仅用作个人学习交流，侵权删。
02-09 84
样例2：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4。随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3。样例1：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2。对于第一组样例，阿福选择第2家店铺行窃，获得的现金数量为8。
Profibus－DP参考模型
11-15
Profibus-DP是一种基于工业自动化领域的通信协议，其设计遵循开放系统互连（OSI）模型的原理。根据描述，Profibus-DP主要定义了OSI模型的前三层：物理层、数据链路层和用户接口，而第三层至第七层则没有详细描述。 ...
acwing和leetcode-algo:某物
07-07
acwing和leetcode 暂时计划： 每天刷: 巩固以及熟悉 每日必刷 2021.6.25： DP: 前面的也要刷 第一期：2021/4/5 之前： 11 94 102 104 111 121 144 145 2021/4/5开始，每天刷： (3月份每日一题) (3月份每日一题) | ...
PROFIBUS-DP调试及助手ProfiAssist
10-23
【PROFIBUS-DP调试及助手ProfiAssist】是一种专门用于调试和优化PROFIBUS-DP网络的工具，对于理解和应用PROFIBUS-DP系统至关重要。PROFIBUS-DP（Decentralized Periphery）是工业自动化领域广泛应用的现场总线标准之...
acwing提高课动态规划代码
04-18
综上所述，"acwing提高课动态规划代码"这一资源提供了学习和实践动态规划的好机会，特别是背包模型的实现，可以帮助开发者掌握动态规划的核心思想，并熟练运用C++进行高效编程。通过深入理解并动手实践这些代码，...
0-1背包问题-算法简洁易懂
05-23
0-1背包问题算法简洁易懂 0-1背包问题简介 0-1背包问题是算法设计中的一种经典问题。它是一个组合优化问题，属于NP-hard问题。问题的描述是：给定一组物品，每个物品都有一个价值和一个重量，要求在不超过背包容量...
acwing动态规划（三）——数位统计、状压DP、树形DP、记忆化搜索
Stephen_Zhao0的博客
03-28 321
数位统计 1.计数问题 题目： 算法思路：因为求的是一个区间内的值，所以利用前缀和思想。求出1~n中，x出现的次数即可。 q:如何求出1~n中，x出现的次数？ a:求出x在每一位上出现的次数。 ...
ＡＣＷＩＮＧ277. 饼干（ＤＰ，状态输出）
tomjobs的博客
10-12 399
圣诞老人共有M个饼干，准备全部分给N个孩子。 每个孩子有一个贪婪度，第 i 个孩子的贪婪度为 g[i]。 如果有 a[i] 个孩子拿到的饼干数比第 i 个孩子多，那么第 i 个孩子会产生 g[i]*a[i]的怨气。 给定N、M和序列g，圣诞老人请你帮他安排一种分配方式，使得每个孩子至少分到一块饼干，并且所有孩子的怨气总和最小。 输入格式 第一行包含两个整数N,M。 第二行包含N个整数表示g1~gN...
【Acwing提高】DP·状态机模型
鱼竿钓鱼干
03-15 146
推荐：炒鸡棒的萌新DP题单（大概？） DP·状态机模型知识点题目大盗阿福股票买卖 IV股票买卖 V设计密码修复DNA 知识点 题目 扩展方式 扩展来源 大盗阿福 股票买卖 IV 股票买卖 V 设计密码 修复DNA 题目 大盗阿福 股票买卖 IV 股票买卖 V 设计密码 修复DNA ...
ACwing 2. 01背包问题（DP）
Michael是个半路程序员
10-23 288
文章目录1. 题目2. 解题 1. 题目 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0<vi,wi
低买（acwing）（线性DP）
qq_45604735的博客
06-25 110
题目地址 配套地址 /* 最长下降子序列，求方案数。 预先用n ^ 2 处理完最长下降子序列。 dp(i) 表示前i个构成最长下降子序列 之后用ans(i)表示构成以i结尾的最长下降子序列的方案数， ans(i) += ans(j),且 dp(j) + 1 = dp(i) && a(j) > a(i)，j < i 初始化ans数组，为每一段的起点是初始为1. 注意当价格序列相同，只计算一次。
ACwing提高课-DP(区间dp、数位dp)
04-06 300
区间DP、数位DP
动态规划DP题单 AcWing算法基础课 （详解）
m0_51448653的博客
08-21 997
目录背包问题背包问题初始化总结AcWing 2. 01背包问题AcWing 3. 完全背包问题AcWing 4. 多重背包问题AcWing 5. 多重背包问题 IIAcWing 9. 分组背包问题 背包问题 背包问题初始化总结 AcWing 2. 01背包问题 #include <bits/stdc++.h> #define endl '\n' #define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0) #define l
ACWing 状态压缩DP （完结撒花 day40
qq_23852555的博客
07-26 246
训练记录

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值