暑假集训week3-DP

已于 2022-08-05 15:59:24 修改
阅读量297 收藏
点赞数 1
文章标签： 算法 c++ 图论
于 2022-08-05 15:40:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MrJinNEU/article/details/126178449
版权

暑假集训-week3-动态规划

A - 最大子段和

在这里插入图片描述
经典的最大子段和

#include <bits/stdc++.h>
using namespace std;
// 最大子段和(dp模板题)
// https://www.luogu.com.cn/problem/P1115
int a[200001];
int dp[200001];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    int ans = -9999999;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        dp[i] = max(dp[i - 1] + a[i], a[i]);
        ans = max(dp[i], ans);
    }
    cout << ans;
    return 0;
}

B - Max Sum Plus Plus

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
// https://vjudge.csgrandeur.cn/contest/507882#problem/B
// 参考题解：https://blog.csdn.net/weixin_44035017/article/details/103318078?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165934103416782388023006%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=165934103416782388023006&biz_id=0&spm=1018.2226.3001.4187
// 二维dp+滚动数组优化
const int maxn = 1e6 + 9;
int n, m, a[maxn], dp[maxn], lastmax[maxn];
int remp_sum, sum;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    while (scanf("%d%d", &m, &n) != EOF)
    {
        for (int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        memset(dp, 0, sizeof(dp));
        memset(lastmax, 0, sizeof(lastmax));
        remp_sum = 0, sum = 0;
        for (int i = 1; i <= m; i++)
        {
            sum = -0x3f3f3f3f;
            for (int j = i; j <= n; j++)
            {
                dp[j] = max(dp[j - 1] + a[j], lastmax[j - 1] + a[j]);
                lastmax[j - 1] = sum;
                sum = max(sum, dp[j]);
            }
        }
        cout << sum << endl;
    }
    return 0;
}

C - Longest Ordered Subsequence

在这里插入图片描述
最大上升子序列模板

#include <iostream>
using namespace std;
// 模板：最大上升子序列
const int maxn = 100010, INF = 0x7f7f7f7f;
int a[maxn], dp[maxn]; // dp[i]代表以a[i]结尾的子序列最大长度
int n, ans = -INF;
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        dp[i] = 1;
    }
    for (int i = 1; i <= n; i++)
        for (int j = 1; j < i; j++)
            if (a[j] < a[i])
                dp[i] = max(dp[i], dp[j] + 1);
    for (int i = 1; i <= n; i++)
        ans = max(ans, dp[i]);
    printf("%d\n", ans);
    return 0;
}

D - 采药

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
// 01背包模板题
const int maxn = 10000;
int t, m;
int cost[maxn], value[maxn], bag[maxn];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> t >> m;
    for (int i = 1; i <= m; i++)
    {
        cin >> cost[i] >> value[i];
    }
    for (int i = 1; i <= m; i++)
    {
        for (int j = t; j >= cost[i]; j--)
        {
            bag[j] = max(bag[j - cost[i]] + value[i], bag[j]);
        }
    }
    cout << bag[t];
    return 0;
}

E - Piggy-Bank

在这里插入图片描述
在这里插入图片描述
完全背包分别求最大和求最小
求最小时先全统一赋值为无穷大，然后再将初始赋值为0
顺便快读的板子也在这里了

#include <bits/stdc++.h>
using namespace std;
// 传送门：https://vjudge.csgrandeur.cn/contest/507882#problem/E
// 完全背包
// 快读不能和清缓存一起用！
const int maxn = 100100;
int t, e, f, n, m; // n为个数，m为背包大小
int cost[maxn], value[maxn], bag[maxn];
inline int read()
{
    int s = 0, w = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            w = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
        s = s * 10 + ch - '0', ch = getchar();
    return s * w;
}
int main()
{
    t = read();
    while (t--)
    {
        memset(bag, 0x3f, sizeof(bag));
        e = read(), f = read(), n = read();
        m = f - e;
        for (int i = 1; i <= n; i++)
        {
            value[i] = read();
            cost[i] = read();
        }
        bag[0] = 0;
        for (int i = 1; i <= n; i++)
        {
            int p = value[i];
            int w = cost[i];
            for (int j = w; j <= m; j++)
            {
                bag[j] = min(p + bag[j - w], bag[j]);
            }
        }
        if (bag[m] == 0x3f3f3f3f)
            cout << "This is impossible." << endl;
        else
            printf("The minimum amount of money in the piggy-bank is %d.\n", bag[m]);
    }

    return 0;
}

F - Dividing

在这里插入图片描述
在这里插入图片描述
多重背包的二进制优化

#include <bits/stdc++.h>
using namespace std;
// https://vjudge.csgrandeur.cn/contest/507882#problem/F
// 多重背包优化
// 二进制优化
int cnt[601000];
int sum;
int value[601000]; //此题不需要空间
int dp[601000];
inline int read()
{
    sum = 0;
    for (int i = 1; i <= 6; i++)
        cin >> cnt[i], sum += cnt[i] * i;
    return sum;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int flag = 0;
    while (read())
    {
        memset(dp, 0, sizeof(dp));
        memset(value, 0, sizeof(value));
        printf("Collection #%d:\n", ++flag);
        if (sum % 2)
        {
            printf("Can't be divided.\n\n");
            continue;
        }
        int num = 0;
        for (int i = 1; i <= 6; i++)
        {
            int remp = cnt[i];
            int k = 1; //二进制个数
            while (k <= remp)
            {
                num++;
                value[num] = i * k;
                remp -= k;
                k *= 2;
            }
            if (remp > 0)
            {
                num++;
                value[num] = i * remp;
            }
        }
        sum /= 2;
        for (int i = 1; i <= num; i++)
            for (int j = sum; j >= value[i]; j--)
                dp[j] = max(dp[j], dp[j - value[i]] + value[i]); //注意传进max内的两个参数
        if (dp[sum] == sum)
            printf("Can be divided.\n\n");
        else
            printf("Can't be divided.\n\n");
    }
    return 0;
}

G - 石子合并

在这里插入图片描述
一个环形的链！！！
处理方法很有意思，直接将原链扩充二倍，在长度2*n的直链取一个长度n的链得到最大贡献值

#include <bits/stdc++.h>
using namespace std;
// 区间dp:https://www.luogu.com.cn/problem/P1880
// 因为是一个环形区间，我们可以通过将数组扩充两倍来实现
const int maxn = 330;
int n;
int a[maxn], sum[maxn], dp_min[maxn][maxn], dp_max[maxn][maxn];
inline int d(int i, int j)
{
    return sum[j] - sum[i - 1];
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n;
    memset(dp_min, 0x3f3f3f3f, sizeof(dp_min));
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    for (int i = 1; i <= 2 * n; i++)
    {
        a[i + n] = a[i];
        sum[i] = a[i] + sum[i - 1];
        dp_min[i][i] = 0;
    }
    for (int len = 1; len < n; len++)
    {
        for (int l = 1, r = l + len; (r <= n + n) && (l <= n + n); l++, r = l + len)
        {
            for (int k = l; k < r; k++) //这个地方是小于号！！！加了等于的话就超出边界了！
            {
                dp_max[l][r] = max(dp_max[l][r], dp_max[l][k] + dp_max[k + 1][r] + d(l, r));
                dp_min[l][r] = min(dp_min[l][r], dp_min[l][k] + dp_min[k + 1][r] + d(l, r));
            }
        }
    }
    int max1 = -0x3f3f3f3f, min1 = 0x3f3f3f3f;
    for (int i = 1; i <= n; i++)
    {
        max1 = max(max1, dp_max[i][i + n - 1]);
        min1 = min(min1, dp_min[i][i + n - 1]);
    }
    cout << min1 << endl
         << max1 << endl;
    return 0;
}

H - 能量项链

在这里插入图片描述
首尾的处理很有意思
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
// 区间dp
// https://www.luogu.com.cn/problem/P1063
const int maxn = 3 * 110;
int n;
int head[maxn], tail[maxn];
int dp[maxn][maxn];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> head[i];
        head[i + n] = head[i];
    }
    for (int i = 1; i <= 2 * n - 1; i++)
    {
        tail[i] = head[i + 1];
    }
    tail[2 * n] = head[1];
    for (int len = 2; len <= n; len++)
    {
        for (int l = 1, r = l + len - 1; (l <= 2 * n) && (r <= 2 * n); l++, r = l + len - 1)
        {
            for (int k = l; k < r; k++)
                dp[l][r] = max(dp[l][r], dp[l][k] + dp[k + 1][r] + head[l] * tail[k] * tail[r]);
        }
    }
    int res = 0;
    for (int i = 1; i <= n; i++)
    {
        res = max(res, dp[i][i + n -1]);
    }
    cout << res;
    return 0;
}

I - 没有上司的舞会

在这里插入图片描述
在这里插入图片描述
树形dp模板题，看注释
感觉树形dp的思路还是很清晰的

#include <bits/stdc++.h>
using namespace std;
int n;
int happy[6010], dp[6010][2];
// dp[x][1]:代表x节点参选，此时以x为根的子树贡献最大和
// dp[x][0]:代表x节点不参选，此时以x为根的子树贡献最大和
// 传送门：https://www.luogu.com.cn/problem/P1352
bool visit[6010];
vector<int> son[6010];
void search(int x) //搜索
{
    int fa = x;
    dp[x][1] = happy[x], dp[x][0] = 0;
    for (int i = 0; i < son[x].size(); i++)
    {
        int s = son[x][i];
        search(s);
        dp[x][1] += dp[s][0];
        dp[x][0] += max(dp[s][0], dp[s][1]);
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> happy[i];
    }
    for (int i = 1; i <= n - 1; i++)
    {
        int l, k;
        cin >> l >> k;
        visit[l] = true; //他有父亲节点
        son[k].push_back(l);
    }
    int root; //找到根节点
    for (int i = 1; i <= n; i++)
        if (visit[i] == false)
        {
            root = i;
            break;
        }
    search(root);
    cout << max(dp[root][1], dp[root][0]);
    return 0;
}

J - 战略游戏

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
// https://www.luogu.com.cn/problem/P2016
// 树形dp
const int maxn = 200000;
int n, dp[maxn][2];
vector<int> son[maxn];
int cnt;
bool visit[maxn];
void search(int x)
{
    dp[x][1] = 1, dp[x][0] = 0;
    int f = x;
    for (int i = 0; i < son[f].size(); i++)
    {
        int s = son[f][i];
        search(s);
        //若该点无士兵，则子节点必须全部都有士兵占据
        dp[f][0] += dp[s][1];
        // 若该点没有士兵，子节点有无士兵都可，只要最小就行
        dp[f][1] += min(dp[s][1], dp[s][0]);
    }
}
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        int k, tar;
        cin >> tar >> k;
        for (int j = 1; j <= k; j++)
        {
            int remp;
            cin >> remp;
            visit[remp] = true;
            son[tar].push_back(remp);
        }
    }
    int ans = 0, root = 0;
    for (int i = 0; i < n; i++)
        if (visit[i] == false)
        {
            root = i;
            break;
        }
    search(root);
    cout << min(dp[root][0], dp[root][1]);
    return 0;
}
蜡笔小金QAQ
关注
NOIP集训Week 6总结
KGV093的博客
10-22 292
依稀记得上周这时在干嘛。。。又一周飞逝而去。 本周已经没有未复习的完整知识板块，主要在查漏补缺并且弥补一些小的盲点。完成的内容有：树形dp练习，一些普通dp练习以及背包dp练习，非旋转treap入门，数论基础（exgcd,phi......），容斥原理入门，A*搜索入门，DFS剪枝，二分答案练习。 本周相较上周来说在时间安排方面有了一定的进步，运动时间安排得更合理了，但是晚上回家复习的落实还可
暑假集训之思维训练 总结 加自己a题
07-10 103
貌似今天ac出来了四道题：自己还得加把油： 1 http://openoj.awaysoft.com:8080/judge/contest/view.action?cid=242#problem/A 传言中的按位dp，自己要好好想想； 2 http://openoj.awaysoft.com:8080/judge/contest/view.action?cid=242#pro...
2019暑假正睿集训8.10day7题解及总结
Flag_z的博客
08-10 313
T1 松 50pts~80pts 这道题直接暴力搜索，每次在三个符号中任选一个，按题意合并数。当合并了还剩两个数的时候，就判断它们选哪种符号最终能为1，找到一种ans+1 100pts 优化1：位运算。把输⼊串按照FFT初始化⽅法⼀样bitrev⼀ 下就可以⽤位运算优化。 优化2：四⽑⼦。当串⻓之后16的时候预处理。 ~~~~ 可能要稍微松⼀下，也可能不⽤。~~ 为此我今天学了三个多小时的FFT（...
莞中集训游记
ssllyr
08-04 278
游记
16-17学期计划（每周）
09-06 143
WEEK 0：9.4 ~ 9.10 过渡、恢复期，主要打老师的题目以及一些水题回复，周末两轮cf WEEK 1：9.11 ~ 9.17 本周复习重点：DP 内容：状压DP、数位DP 具体安排：做完老师的题目，然后自己在JZOJ上面做专题 WEEK 2：9.18 ~ 9.24 ...
2020.7月做题记录
Panda_Hu's blog
08-01 841
转眼就到了2020的下半年了…前方仍是一片茫然。
30个题型+代码(冲刺2023蓝桥杯)(中)
IT OR 考公？
03-13 1万+
前缀和，差分，二分，双指针，递归，递推，BFS，DFS，Dijkstra, Floyd，质数筛，最大公约数，背包dp，线性dp，区间dp，组合计数，快速幂，KMP，哈希，并查集，博弈论
算法笔记(个人用)(不定期更新)
cuber-lotus的博客
03-23 2838
文章目录前言说明Note文档编辑相关语言特性相关 (C/C++)输出数组最后一个元素后面无空格二分查找函数rand() 范围算法相关排序区间求和题单基础数学素数素数判断素数筛朴素筛选 (埃式筛)朴素筛选优化线性筛 (欧拉筛)闰年判断蔡勒（Zeller）公式GCD10转R进制卡特兰数完美数分解因数欧几里得-欧拉定理数根[1~n] 中完全平方数的个数计算Π pia二分查找顺序序列找唯一值逼近类二分容斥原理位运算整形存储大小intlong long`__builtin_函数`取模自动取模工具类除法取模判断奇偶统计
POJ 试题分类
热门推荐
nike0good |Oier&ACMer | 熟能生巧
08-09 3万+
转载请注明出处：優YoUhttp://blog.csdn.net/lyy289065406/article/details/6642573 改革V1.0 ——刷题法则 恭祝Blog.cn开博2012.8.1 较初级: OJ上的一些水题(可用来练手和增加自信)  (poj1003,poj1004,poj1005,poj120
信奥帮-信息学奥赛-CSP-J1S1初赛集训知识点-考点-思维导图课件
06-09
《信奥帮-信息学奥赛-CSP-J1S1初赛集训知识点解析》 在信息技术日益发展的今天，信息学奥赛（IOI）已成为青少年展现编程技能和逻辑思维能力的重要舞台。CSP（Contest Selection Process）是NOIP（全国青少年信息学...
蓝桥杯大赛少儿创意编程EV3组赛前集训课程包-v180901.pdf
07-17
需要注意的是，组委会强调集训课程包与日常EV3课程的区别，并不建议完全用集训课程来代替日常课程。集训课程更注重逻辑思维和编程能力的提升，而非趣味性的学习。 最后，本课程包的下一版本预计将于2019年3月1日...
暑假集训周报WEEK4
08-04
"暑假集训周报WEEK4" 在这周的集训周报中，我们将讨论三个具有代表性的算法问题：背包问题、纸牌问题和纪念品分组问题。这些问题都是经典的算法问题，都是NOIP（全国青少年信息学奥林匹克竞赛）中的常见题型。 ...
CSP-J复赛集训200分-300分必刷-csp-j-2021网络链接
10-23
CSP-J复赛集训200分-300分必刷-csp-j-2021网络链接
CSP-J复赛集训200分-300分必刷-csp-j-2021插入排序
10-23
CSP-J复赛集训200分-300分必刷-csp-j-2021插入排序
PCA（主成分分析）算法的应用场景
huanfeng_AI的博客
11-09 395
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
1163：阿克曼(Ackmann)函数
最新发布
呆萌很的博客
11-12 117
1163：阿克曼(Ackmann)函数
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1273
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
0-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
太极生两鱼
11-12 31
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
二分查找习题篇(上)
zoelinkailuo的博客
11-07 1004
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值