2024牛客寒假算法基础集训营2【难题详解】

已于 2024-02-19 16:18:32 修改
阅读量296 收藏 1
点赞数 2
文章标签： 算法
于 2024-02-14 18:27:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Perfect_Life_/article/details/136112805
版权
本文讨论了多重背包问题的三种解法：暴力TLE版本、二进制优化的O(nmlogn)方法和基于图论的O(nm+n^2)解法。同时涉及C.Tokitsukaze的问题，如Min-MaxXOR中的关键点和线段树在PowerBattle问题中的应用。
摘要由CSDN通过智能技术生成

D. Tokitsukaze and Slash Draw

多重背包解法

题意：将物品移动n-k步的最小价值，移动ai步需要花费bi (若>=n则%n)

暴力TLE O(n^2*m)

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(),x.end()
#define no cout<<"No"<<endl
#define yes cout<<"Yes"<<endl
#define endl '\n'
// #define x first
// #define y second
typedef pair<int,int> PII;
const int N=200010;
const int mod=998244353;
const int INF=0x3f3f3f3f;
void solve(){
    int m,n,k;cin>>n>>m>>k;
    int v[m]={};int w[m]={};
    for(int i=0;i<m;i++){
        cin>>v[i]>>w[i];
    }
    vector<int>dp(n+1,1e18);
    dp[k]=0;
    for(int i=0;i<m;i++){
        for(int p=0;p<n;p++){
            for(int j=0;j<=n;j++){
                dp[j]=min(dp[j],dp[(j-v[i]+n)%n]+w[i]);
            }
        }
    }
    if(dp[n]==1e18)cout<<-1<<endl;
    else cout<<dp[n]<<endl;
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    cin>>_;
    while(_--)solve();
    return 0;
}

二进制优化 O(nmlogn)

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(),x.end()
#define no cout<<"No"<<endl
#define yes cout<<"Yes"<<endl
#define endl '\n'
// #define x first
// #define y second
typedef pair<int,int> PII;
const int N=200010;
const int mod=998244353;
const int INF=0x3f3f3f3f;
void solve(){
    int m,n,k;cin>>n>>m>>k;
    vector<int>v;
    vector<int>w;
    for(int i=0;i<m;i++){
        int a,b;cin>>a>>b;
        int t=n-1;
        if(n%a==0){
            t=n/a-1;
        }
        int cnt=1;
        while(t>cnt){
            v.push_back(cnt*a);
            w.push_back(cnt*b);
            t-=cnt;
            cnt*=2;
        }
        if(t>0){
            v.push_back(t*a);
            w.push_back(t*b);
        }
    }
    vector<int>dp(n+1,1e18);
    dp[0]=0;
    for(int i=0;i<v.size();i++){
        for(int j=0;j<=n;j++){
            dp[j]=min(dp[j],dp[((j-v[i])%n+n)%n]+w[i]);
        }
    }
    if(dp[n-k]==1e18)cout<<-1<<endl;
    else cout<<dp[n-k]<<endl;
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    cin>>_;
    while(_--)solve();
    return 0;
}

此题不能用单调队列优化，因为取模的关系，导致状态转移没有单调性

图论解法 O(nm+n^2)

可以发现，此题为起点为 k 终点为 n 的最短路

不要使用堆优化，因为是稠密图

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(),x.end()
#define no cout<<"No"<<endl
#define yes cout<<"Yes"<<endl
#define endl '\n'
#define x first
#define y second
typedef pair<int,int> PII;
const int N=5050;
const int mod=998244353;
const int INF=1e18;
int n,m,k;
void solve(){
    cin>>n>>m>>k;
    PII edge[m];
    for(int i=0;i<m;i++){
        int a,b;cin>>a>>b;
        edge[i]={a,b};
    }
    int d[n+1]={};
    int book[n+1]={};
    for(int i=1;i<=n;i++)d[i]=1e18;
    d[k]=0;
    for(int p=0;p<n;p++){
        int mn=INF;int t=k;
        for(int i=1;i<=n;i++){//找最近的点
            if(book[i]==0&&d[i]<=mn){
                mn=d[i];
                t=i;
            }
        }
        if(t==n)break;
        book[t]=1;
        for(int j=0;j<m;j++){//松弛出边
            if(book[(t+edge[j].x+n-1)%n+1])continue;
            d[(t+edge[j].x+n-1)%n+1]=min(d[(t+edge[j].x-1+n)%n+1],d[t]+edge[j].y);
        }
    }
    if(d[n]==1e18)cout<<-1<<endl;
    else cout<<d[n]<<endl;
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    cin>>_;
    while(_--)solve();
    return 0;
}

C. Tokitsukaze and Min-Max XOR

关键点：\min(a_{b1},a_{b2},\ldots,a_{bm})\oplus\max(a_{b1},a_{b2},\ldots,a_{bm})\leq k  与a的相对位置没有关系，所以当max=ai,min=aj,且ai⊕aj<=k时，中间数可以随便选，那么贡献就为 2^i-j-1

暴力枚举最大最小值为O(n^2)，trie树优化为O(nlogn)：

对于一个ai，其贡献可能为 2^{i-j_1-1}+2^{i-j_2-1}+\cdots，所以trie中维护累加  \sum2^{-j}

故对于一个ai其贡献为:  ans+=ksm(2,i-1)*query(a[i]);
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin()+1,x.end()
#define endl '\n'
const int N=200010;
const int mod=1e9+7;
const int INF=0x3f3f3f3f;
unordered_map<int,int>mp;
unordered_map<int,int>mp2;
int ksm(int a,int n){
    int r=1ll;
    while(n){
        if(n&1)r=r*a%mod;
        a=a*a%mod;
        n>>=1;
    }
    return r;
}
int inv(int a){
    return ksm(a,mod-2);
}
void solve(){
    int n,k;cin>>n>>k;
    int nx[n*30][2]={},val[n*30]={},idx=1;
    vector<int>a(n+1);
    for(int i=1;i<=n;i++)cin>>a[i];
    sort(all(a));

    auto insert=[&](int x,int pos){
        int t=0;//初始为根节点0
        for(int i=30;i>=0;i--){
            int j=x>>i&1;
            if(!nx[t][j])nx[t][j]=idx++;
            t=nx[t][j];
            val[t]=(val[t]+mp2[pos])%mod;
        }
    };

    auto query=[&](int x){
        int t=0,res=0;
        for(int i=30;i>=0;i--){
            int j=x>>i&1;
            if(k>>i&1){
                if(nx[t][j])res=(res+val[nx[t][j]])%mod;
                if(nx[t][!j]){
                    t=nx[t][!j];
                }else return res;
            }else{
                if(nx[t][j]){
                    t=nx[t][j];
                }else return res;
            }
        }
        res=(res+val[t])%mod;
        return res;
    };

    int ans=0;
    for(int i=2;i<=n;i++){
        insert(a[i-1],i-1);
        ans=(ans+mp[i-1]*query(a[i])%mod)%mod;
    }
    cout<<(ans+n)%mod<<endl;
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    cin>>_;
    int t=1;
    for(int i=0;i<=N;i++){
        mp[i]=t;
        mp2[i]=inv(t);
        t=t*2%mod;
    }
    while(_--)solve();
    return 0;
}

G. Tokitsukaze and Power Battle (easy)

不难发现此题本质是：

线段树中存每个点的pre[i]-a[i+1] 

区间修改：维护 [l,r] 区间的 pre[i]-a[i+1] 

区间查询：查询区间的最大值

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) x.begin(),x.end()
#define no cout<<"No"<<endl
#define yes cout<<"Yes"<<endl
#define endl '\n'
// #define x first
// #define y second
typedef pair<int,int> PII;
const int N=200010;
const int mod=998244353;
const int INF=0x3f3f3f3f3f3f3f3f;
struct SegmentTree
{
    struct Node
    {
        int l, r;
        int val, lz;
    };
    vector<Node>tr;
    SegmentTree(int n) {
        tr.resize(4 * n + 5);
    }
    void pushup(int t)
    {
        tr[t].val = max(tr[t * 2].val, tr[t * 2 + 1].val);
    }
    void pushdown(int t)
    {
        if (tr[t].lz) {
            tr[2 * t].val += tr[t].lz;
            tr[2 * t + 1].val += tr[t].lz;
            tr[2 * t].lz += tr[t].lz;
            tr[2 * t + 1].lz += tr[t].lz;
            tr[t].lz = 0;
        }
    }
    template<typename M>
    void build(int t, int l, int r, vector<M>& a)
    {
        tr[t].l = l, tr[t].r = r;
        if (l == r) {
            tr[t].val = a[l];
            return;
        }
        int mid = tr[t].l + tr[t].r >> 1;
        build(t * 2, l, mid, a); build(t * 2 + 1, mid + 1, r, a);
        pushup(t);
    }
    template<typename M>
    void modify(int t, int x, M val) {
        if (tr[t].l == tr[t].r) {
            tr[t].val += val ;
            tr[t].lz += val;
            return;
        }
        pushdown(t);
        int mid = tr[t].l + tr[t].r >> 1;
        if (x <= mid) modify(t * 2, x, val);
        else modify(t * 2 + 1, x, val);
        pushup(t);
    }
    template<typename M>
    void modify(int t, int l, int r, M val) {
        if (l <= tr[t].l && tr[t].r <= r) {
            tr[t].val += val ;
            tr[t].lz += val;
            return;
        }
        pushdown(t);
        int mid = tr[t].l + tr[t].r >> 1;
        if (l <= mid) modify(t * 2, l, r, val);
        if (r > mid) modify(t * 2 + 1, l, r, val);
        pushup(t);
    }
    int query(int t, int l, int r) {
        if (l <= tr[t].l && tr[t].r <= r) {
            return tr[t].val;
        }
        pushdown(t);
        int mid = tr[t].l + tr[t].r >> 1;
        int mx = -INF;
        if (l <= mid) mx = max(mx, query(t * 2, l, r));
        if (r > mid) mx = max(mx, query(t * 2 + 1, l, r));
        return mx;
    }
};
void solve(){
    int n,q;cin>>n>>q;
    vector<int>a(n+1);
    vector<int>pre(n+1);
    for(int i=1;i<=n;i++){
        cin>>a[i];
        pre[i]=pre[i-1]+a[i];
    }
    for(int i=1;i<=n-1;i++){
        pre[i]-=a[i+1];
    }
    SegmentTree tr(n);
    tr.build(1,1,n-1,pre);
    while(q--){
        int op;cin>>op;
        if(op==1){
            int x,y;cin>>x>>y;
            if(x-1>=1)tr.modify(1,x-1,a[x]-y);
            if(x<=n-1)tr.modify(1,x,n-1,y-a[x]);
            a[x]=y;
        }else{
            int l,r;cin>>l>>r;
            if(l==1)cout<<tr.query(1,l,r-1)<<endl;
            else cout<<tr.query(1,l,r-1)-tr.query(1,l-1,l-1)-a[l]<<endl;
        }
    }

}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int _=1;
    cin>>_;
    while(_--)solve();
    return 0;
}

Perfect_Life_
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
2024牛客寒假算法基础集训营4【难题详解】
Perfect_Life_的博客
02-21 404
只写if(mx[i][j-1][2]!因为if判断为false的话， mx[i][j-1][3] 这个状态就不会被考虑。mx[j][7]表示，在当前遍历的 i~j 中所满足的最大值。mx[i][j][1]=表示选了式子中的第一个数b1。状态转移：按选或不选第j个数划分。
2024牛客寒假算法基础集训营1【难题详解】
Perfect_Life_的博客
02-03 137
dp[j]表示：满足m的二进制表示下第j位为1，且背包的体积=m-(1
2021牛客寒假算法基础集训营2-I题
mixinju的CSDN博客
02-05 195
2021牛客寒假算法基础集训营2-I题 题目链接： 先上代码，代码如下： #include <iostream> //#include <algorithm> #include <bitset> #define mod 1000000007 using namespace std; bitset <40000000> p; int ans[40000000]; int main(int argc, char** argv) { //freopen("W
2020牛客寒假算法基础集训营1 题解
LiuKairui的博客
03-02 740
A:honoka和格点三角形 题目描述 honoka最近在研究三角形计数问题。 她认为，满足以下三个条件的三角形是“好三角形”。 1.三角形的三个顶点均为格点，即横坐标和纵坐标均为整数。 2.三角形的面积为 。 3.三角形至少有一条边和 轴或 轴平行。 honoka想知道，在平面中选取一个大小为 109+710^9+7109+7 的矩形格点阵，可以找到多少个不同的“好三角形”？由于答案可能过大，请...
2024牛客暑期训练营第一场
07-22
2024牛客暑期训练营第一场
2020牛客多校暑期集训营第一场题解.pdf
01-20
2020牛客多校暑期集训营第一场题解.pdf
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
【18】输出字符菱形
2301_78786609的博客
07-19 383
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 329
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
算法题目整合5
qq_62571233的博客
07-23 631
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 126
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
2024.7.19 刷题总结
TheJustice_的博客
07-19 248
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
3.5 查找和排序算法
m0_38066007的博客
07-23 126
大纲 算法基础 常用的表示算法的方法 算法的复杂度 查找 顺序查找、二分查找 哈希查找 真题 排序 插入排序 希尔排序 简单选择排序 堆排序 冒泡排序
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 269
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 339
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
AtCoder Beginner Contest 363(A~D题)
最新发布
sin1810335764的博客
07-23 120
枚举长度，首先计算出答案回文数的长度。通过枚举和减法可以计算出是当前长度下第k𝑘大的回文数。而前一半就是顺序的，第k𝑘大就是当前长度的数的第k𝑘大，这个很好求。接下来只需要构成回文，直接输出即可。将L𝐿从小往大排序，那么只需要第n−P+1𝑛−𝑃+1大的数满足条件即可，假设这个数是a𝑎。因此，只需要计算T−a𝑇−𝑎即可。注意，如果这个数是负数，意味着初始时就满足条件，此时要输出00。我们只需要找到下一阶段的下限。a / 100 是本阶段+1 变成下一阶段，再 * 100变成下限，再与原来的相减即可。
牛客暑期多校集训营五题详解：最小行走距离与传送门策略
2020牛客暑期多校集训营第五场的编程题目是关于带权图的路径规划与优化问题，主要涉及C++编程。题目背景是有一个包含n个节点和m条边的图，初始位置在1号节点，需要按照顺序完成k个任务，每个任务包括从一个特定的a[i...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值