Educational Codeforces Round 126 (Rated for Div. 2)（ABCD）

斗奋力努

已于 2022-04-11 16:02:59 修改

阅读量656

点赞数 1

分类专栏： codeforces 思维文章标签： c++ 算法

于 2022-04-10 21:12:38 首次发布

本文链接：https://blog.csdn.net/curryljx/article/details/124085625

版权

codeforces 同时被 2 个专栏收录

23 篇文章 1 订阅

订阅专栏

思维

23 篇文章 0 订阅

订阅专栏

Educational Codeforces Round 126 (Rated for Div. 2)（ABCD）

A. Array Balancing

在这里插入图片描述
题意：
有两个长度为n的序列a，b，相同位置下可以交换两序列元素 $s w a p (a [i], b [i])$ ，问两个序列的每相邻两位的绝对值之和最小是多少
思路：
相同下标下，小值给a，大值给b就好了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5;
ll n,a[30],b[30];

void solve(){
    scanf("%lld",&n);
    for(ll i=1;i<=n;i++) scanf("%lld",&a[i]);
    for(ll i=1;i<=n;i++) scanf("%lld",&b[i]);
    for(ll i=1;i<=n;i++){
        if(a[i]>b[i]) swap(a[i],b[i]);
    }
    ll sum=0;
    for(ll i=2;i<=n;i++) sum+=abs(a[i]-a[i-1])+abs(b[i]-b[i-1]);
    printf("%lld\n",sum);
}

int main(){
    int T;scanf("%d",&T);
    while(T--) solve();
    return 0;
}

在这里插入图片描述
题意：
给定一个数v，每秒数可以进行一次操作：
①v=(v+1)%32768
②v=(v*2)%32768
问v等于0的最少时间是多少
思路：
感觉跟今年沈阳的密码锁很像，我们开始记录0到每个值的最小时间，然后查询时直接输出就好了。
因为从结果开始，所以每次有三种转移情况：
①是加1过来的，所以得减1
②是乘2过来的，且小于模数，所以在保证当前是偶数的情况下除2
③是乘2过来的，但大于等于模数，所以在保证当前是偶数的情况下转移值应该是(32768+u)/2

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5,mod=32768;
int n,dp[N];

void init(){
    memset(dp,-1,sizeof(dp));
    dp[0]=0;
    queue<int>q;
    q.push(0);
    while(!q.empty()){
        auto u=q.front(); q.pop();
        int num[5];
        num[1]=(u-1+mod)%mod;
        num[2]=(u%2==0)?u/2:0;
        num[3]=(u%2==0)?(32768+u)/2:0;
        for(int i=1;i<=3;i++){
            if(dp[num[i]]==-1){
                dp[num[i]]=dp[u]+1;
                q.push(num[i]);
            }
        }
    }
}

void solve(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int x;scanf("%d",&x);
        printf("%d%c",dp[x],(i==n)?'\n':' ');
    }
}

int main(){
    init();
    int T=1;
    while(T--) solve();
    return 0;
}

C. Water the Trees

在这里插入图片描述
题意：
给定长度为n的序列，奇数秒钟可以使某个元素+1，偶数秒钟可以使某个元素+2，也可以跳过该秒操作，问最少多少秒可以使得全部元素相等。
思路：
直接二分答案，最终相等的元素肯定使初始序列中的最大值mx，或最大值mx+1。
二分时。我们记录偶数秒钟和奇数秒钟出现次数，每个去判断需要的多少偶数秒钟，不足是用奇数秒钟代替，还不行就 $return\ false;$ ，最后可以就 $return\ true;$ 就好了
最后两种情况取min值

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e5+5;
ll n,h[N],mx;

bool cek1(ll mid){
    ll ou=mid/2,ji=(mid+1)/2;
    for(ll i=1;i<=n;i++){
        ll cha=mx-h[i];
        ll nu2=min(ou,cha/2);
        cha=cha-nu2*2;
        ou-=nu2;
        if(ji>=cha) ji-=cha;
        else return false;
    }
    return true;
}

bool cek2(ll mid){
    ll ou=mid/2,ji=(mid+1)/2;
    for(ll i=1;i<=n;i++){
        ll cha=mx+1-h[i];
        ll nu2=min(ou,cha/2);
        cha=cha-nu2*2;
        ou-=nu2;
        if(ji>=cha) ji-=cha;
        else return false;
    }
    return true;
}

void solve(){
    mx=0;
    scanf("%lld",&n);
    for(ll i=1;i<=n;i++) scanf("%lld",&h[i]),mx=max(mx,h[i]);
    ll l1=0,r1=1e18;
    while(l1<r1){
        ll mid=(l1+r1)>>1;
        if(cek1(mid)) r1=mid;
        else l1=mid+1;
    }
    ll l2=0,r2=1e18;
    while(l2<r2){
        ll mid=(l2+r2)>>1;
        if(cek2(mid)) r2=mid;
        else l2=mid+1;
    }
    printf("%lld\n",min(l1,l2));
}

int main(){
    int T;scanf("%d",&T);
    while(T--) solve();
    return 0;
}

D. Progressions Covering

在这里插入图片描述
题意：
给出长度为n的序列b。对于一个长度为n的序列a来说，每次可以选择一个长度为k的连续区间，区间从左到右每个数加分别加1，2，3…k
问最少操作多少次，使得所有位置a[i]>=b[i]
思路：
~~(晚点补下线段树解法)~~
肯定从后往前会好一点，然后每个记录后面一个对前面的贡献，注意前面区间[1,k-1]每次最多变换也只有i就好了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e5+5;
ll n,k,a[N],b[N];

void solve(){
    scanf("%lld%lld",&n,&k);
    for(ll i=1;i<=n;i++) scanf("%lld",&b[i]);
    ll sum=0,cnt=0,now=0;
    for(ll i=n;i>=1;i--){
        now-=cnt;
        if(i<=n-k) cnt-=a[i+k];
        ll mx=min(i,k);
        if(now<b[i]){
            ll ned=b[i]-now;
            ll num=ned/mx+(ned%mx==0?0:1);
            a[i]=num;
            sum+=num;
            cnt+=num;
            now+=num*mx;
        }
    }
    printf("%lld\n",sum);
}

int main(){
    int T=1;
    while(T--) solve();
    return 0;
}

线段树的写法
如果写过P1438 无聊的数列，本题用线段树会十分容易。
我们知道每次修改长度为k的区间，且每个位置值从左到右满足首项是1，公差是1的等差序列。
我们用线段树维护一个差分数组，（树状数组也是可以的）
每次修改就是[l,r]就是位置r需要的修改次数ned

原序列：0 0 0 0 0 0
差分序列：0 0 0 0 0 0
等差序列：1 2 3 4 5  (ned=1)
加上等差数列后的序列：1 2 3 4 5 0
然后差分：1 1 1 1 1 -

所以我们贪心的想，从后往前维护一个差分数组，我分了两种情况。
情况1：区间[k,n]
在这种情况下，我们知道对于每个不满足条件的位置i，我们每次都可以让其加上k。所以比较跟b[i]的大小关系，然后区间修改就好了。对答案贡献全记到ans1
情况2：区间[1,k-1]
在这种情况下，我们知道对于每个不满足条件的位置i，我们每次最多让其加上i，如果加k，则左端点将超出边界，显然不符合实际情况。这个时候可以偷个懒，不用去区间修改，我们直接记录一下区间[1,k-1]内此时最多还需要多少次修改就好了。对答案贡献全记到ans2
最后答案就是ans1+ans2

//https://codeforces.com/contest/1661/problem/D  区间修改满足等差序列，用线段树维护差分数组
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e5+5;
ll n,k,b[N];
struct node{
    ll l,r;
    ll add,sum;
}tr[N<<2];

void pushup(ll u){tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;}

void pushdown(ll u){
    auto &root=tr[u],&left=tr[u<<1],&right=tr[u<<1|1];
    if(root.add){
        left.sum+=(left.r-left.l+1)*root.add,left.add+=root.add;
        right.sum+=(right.r-right.l+1)*root.add,right.add+=root.add;
        root.add=0;
    }
}

void build(ll u,ll l,ll r){
    tr[u]={l,r,0,0};
    if(l==r) return;
    ll mid=(l+r)>>1;
    build(u<<1,l,mid),build(u<<1|1,mid+1,r);
}

ll query(ll u,ll l,ll r){
    if(l<=tr[u].l&&tr[u].r<=r) return tr[u].sum;
    pushdown(u);
    ll sum=0;
    ll mid=(tr[u].l+tr[u].r)>>1;
    if(l<=mid) sum+=query(u<<1,l,r);
    if(r>mid) sum+=query(u<<1|1,l,r);
    return sum;
}

void modify(ll u,ll l,ll r,ll k){
    if(l<=tr[u].l&&tr[u].r<=r){
        tr[u].add+=k;
        tr[u].sum+=(tr[u].r-tr[u].l+1)*k;
        return;
    }
    pushdown(u);
    ll mid=(tr[u].l+tr[u].r)>>1;
    if(l<=mid) modify(u<<1,l,r,k);
    if(r>mid) modify(u<<1|1,l,r,k);
    pushup(u);
}

int main(){
    scanf("%lld%lld",&n,&k);
    for(ll i=1;i<=n;i++) scanf("%lld",&b[i]);
    build(1,1,n);
    ll ans1=0,ans2=0;
    for(ll i=n;i>=1;i--){
        ll ai=query(1,1,i);
        if(ai>=b[i]) continue;
        ll cha=b[i]-ai;
        if(i>=k){ //情况1
            ll ned=cha/k+(cha%k==0?0:1);
            ans1+=ned;
            ll l=i-k+1,r=i;
            modify(1,l,r,ned);
            //后面的都已经满足条件，且不会对前面早造成影响，所以可以不修改
            // if(r+1<=n) modify(1,r+1,r+1,-k*ned); 
        }
        else{ //情况2
            ll ned=cha/i+(cha%i==0?0:1);
            ans2=max(ans2,ned);
        }
    }
    printf("%lld\n",ans1+ans2);
}

斗奋力努

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Educational Codeforces Round 126 (Rated for Div. 2)（ABCD）

Educational Codeforces Round 126 (Rated for Div. 2)（ABCD）A. Array Balancing题意：有两个长度为n的序列a，b，相同位置下可以交换两序列元素swap(a[i],b[i])swap(a[i],b[i])swap(a[i],b[i])，问两个序列的每相邻两位的绝对值之和最小是多少思路：相同下标下，小值给a，大值给b就好了#include<bits/stdc++.h>using namespace std;typ
复制链接

扫一扫