Codeforces Global Round 13 / contest 1491

于 2021-03-01 10:40:31 发布
阅读量273 收藏
点赞数
分类专栏： codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dragonylee/article/details/114256572
版权

目录


ABCDEFGHI
√√√√√

（ √：做出； ●：尝试未做出； ○：已补题 ）

题目地址：https://codeforces.com/contest/1491



A K-th Largest Value

题意：给出一个初始值为 0 或 1 的长为 n 的数组，每次操作要么选择某个 a i a_i ai​ 变成 1 − a i 1-a_i 1−ai​ ，要么让你打印第 k 大的值。

思路：统计 0 和 1 的个数，实时记录 a 数组即可。

代码：

#define DIN freopen("input.txt","r",stdin);
#define DOUT freopen("output.txt","w",stdout);
#include <bits/stdc++.h>
#include <cstdio>
#define mem(a,b) memset(a,b,sizeof(a))
#define REP(i,a,b) for(int i=(a);i<=(int)(b);i++)
#define REP_(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
#define DEBUG
using namespace std;
typedef long long LL;
typedef std::vector<int> VI;
int read()
{
    int x=0,flag=1; char c=getchar();
    while((c>'9' || c<'0') && c!='-') c=getchar();
    if(c=='-') flag=0,c=getchar();
    while(c<='9' && c>='0') {x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return flag?x:-x;
}

const int maxn=1e5+5;
int a[maxn];

int main()
{
    int n=read(),q=read();
    REP(i,1,n) a[i]=read();
    int n0=0,n1=0;
    REP(i,1,n)
        if(a[i]) n1++;
        else n0++;
    while(q--)
    {
        int t=read();
        if(t==1)
        {
            int x=read();
            if(a[x]) n1--,n0++;
            else n1++,n0--;
            a[x]=1-a[x];
        }
        else
        {
            int k=read();
            if(k<=n1) puts("1");
            else puts("0");
        }
    }

    return 0;
}



B Minimal Cost

题意：n行（编号1-n） 1 0 6 + 2 10^6+2 106+2 列（编号 0 0 0 - 1 0 6 + 1 10^6+1 106+1）的网格中，每一行有一个地方有障碍，这个障碍不会在第一列或者最后一列。把某个障碍上下移动一格需要花费 u ，左右移动一格需要花费 v，并且不能移动到有障碍的格子。要从（1, 0）走到 （n, 1 0 6 + 1 10^6+1 106+1），每次只能往上下左右四个方向移动，问最小花费。

思路：首先在第一列和最后一列没有障碍，可以畅通无阻，所以如果有相邻两行的障碍列坐标相差超过 1，那么就不用任何花费可以直接到。然后如果所有障碍都在同一列，那么最小花费是 v + m i n ( u , v ) v+min(u,v) v+min(u,v)，表示为必须横着移一次，下一次可以横着或者竖着移一次，去更小的那个；如果不是同一列，那么取 m i n ( u , v ) min(u,v) min(u,v) 。

代码：

#define DIN freopen("input.txt","r",stdin);
#define DOUT freopen("output.txt","w",stdout);
#include <bits/stdc++.h>
#include <cstdio>
#define mem(a,b) memset(a,b,sizeof(a))
#define REP(i,a,b) for(int i=(a);i<=(int)(b);i++)
#define REP_(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
#define DEBUG
using namespace std;
typedef long long LL;
typedef std::vector<int> VI;
int read()
{
    int x=0,flag=1; char c=getchar();
    while((c>'9' || c<'0') && c!='-') c=getchar();
    if(c=='-') flag=0,c=getchar();
    while(c<='9' && c>='0') {x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return flag?x:-x;
}

const int maxn=1e5+5;
int a[maxn];

int main()
{
    int T=read();
    while(T--)
    {
        int n=read(),u=read(),v=read();
        REP(i,1,n) a[i]=read();
        int flag=0;
        REP(i,2,n) if(a[i]!=a[i-1]) flag=1;
        if(!flag)
        {
            printf("%d\n",v+min(u,v));
        }
        else
        {
            REP(i,2,n) if(abs(a[i]-a[i-1])>1)
            {
                puts("0");
                flag=-1;
                break;
            }
            if(flag!=-1)
            {
                printf("%d\n",min(u,v));
            }
        }
    }

    return 0;
}



C Pekora and Trampoline

题意：有 n 个蹦床排成一排，每个蹦床有一个数字 S i S_i Si​，表示如果跳到这个蹦床，下一个位置会跳去 i + S i i+S_i i+Si​ 。跳完一个蹦床后，这个蹦床的值会减一，直到值为 1 为止。一次操作的流程为：任选一个蹦床开始跳，直到跳出范围为止。问至少需要多少次操作，可以把所有值都变成 1 。

思路：这题错了 6 次，呜呜呜……

一开始的思路是暴力，然后题目有多组数据， T n 2 Tn^2 Tn2 的复杂度终究是没过。

首先跳的方法肯定是从左往右开始跳，直到那个蹦床变为 1 为止。在跳第 i 个蹦床的时候，它的下一跳一定是一个变化的区间，这个区间内的每个蹦床都会跳一下，这个区间为 [ i + 2 , m i n ( i + S i , n ) ] [i+2,min(i+S_i,n)] [i+2,min(i+Si​,n)] 。所以我们可以用线段树维护每个蹦床在之前跳了多少次，在处理第 i 个蹦床的时候，把这个区间+1。假设处理到第 i 个蹦床，查询线段树得出它在之前跳了 q 次，那么如果 S i − 1 ≥ q S_i-1\ge q Si​−1≥q，答案累加 S i − 1 − q S_i-1-q Si​−1−q，表示需要这么多次操作可以变成 1；如果 S i − 1 < q S_i-1<q Si​−1<q ，表示之前的跳跃已经把这个蹦床变成 1 了，则应当在线段树中把 i+1 处的蹦床加上 q − ( S i − 1 ) q-(S_i-1) q−(Si​−1)，因为它实际上有影响的变成了下一个蹦床。

代码：

#define DIN freopen("input.txt","r",stdin);
#define DOUT freopen("output.txt","w",stdout);
#include <bits/stdc++.h>
#include <cstdio>
#define mem(a,b) memset(a,b,sizeof(a))
#define REP(i,a,b) for(int i=(a);i<=(int)(b);i++)
#define REP_(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
#define DEBUG
using namespace std;
typedef long long LL;
typedef std::vector<int> VI;
int read()
{
    int x=0,flag=1; char c=getchar();
    while((c>'9' || c<'0') && c!='-') c=getchar();
    if(c=='-') flag=0,c=getchar();
    while(c<='9' && c>='0') {x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return flag?x:-x;
}

const int maxn=5005;
int s[maxn];

template <class T>
struct segment_tree_sum
{
    #define chl (k<<1)
    #define chr (k<<1|1)
    #define mid ((l+r)>>1)
    T *t,*tag;
    int n;

    segment_tree_sum(int n) {t=new T[n<<2](); tag=new T[n<<2](); this->n=n;}

    void push_up(int k) {t[k]=t[chl]+t[chr];}

    void push_down(int k,int l,int r)
    {
        if(!tag[k]) return;
        t[chl]+=tag[k]*(mid-l+1); t[chr]+=tag[k]*(r-mid);
        tag[chl]+=tag[k]; tag[chr]+=tag[k]; tag[k]=0;
    }

    void build(int k,int l,int r,T *a)
    {
        if(l>r) return;
        if(l==r) {t[k]=a[l]; return;}
        build(chl,l,mid,a); build(chr,mid+1,r,a);
        push_up(k);
    }
    void build(T *a) {build(1,1,n,a);}

    void update_add(int k,int l,int r,int ll,int rr,T x)
    {
        if(l>rr || ll>r) return;
        if(l>=ll && r<=rr) {t[k]+=x*(r-l+1); tag[k]+=x; return;}
        push_down(k,l,r);
        update_add(chl,l,mid,ll,rr,x); update_add(chr,mid+1,r,ll,rr,x);
        push_up(k);
    }
    void update_add(int ll,int rr,T x) {update_add(1,1,n,ll,rr,x);}

    T query(int k,int l,int r,int ll,int rr)
    {
        if(l>rr || ll>r) return 0;
        if(l>=ll && r<=rr) return t[k];
        push_down(k,l,r);
        return query(chl,l,mid,ll,rr)+query(chr,mid+1,r,ll,rr);
    }
    T query(int ll,int rr) {return query(1,1,n,ll,rr);}
};


int main()
{
    int T=read();
    while(T--)
    {
        int n=read();
        REP(i,1,n) s[i]=read();
        LL ans=0;
        segment_tree_sum<LL> t(n);
        REP(i,1,n)
        {
            int q=t.query(i,i);
            if(i<n-1) t.update_add(i+2,min(n,i+s[i]),1);
            ans+=max(s[i]-1-q,0);
            if(s[i]-1<q) t.update_add(i+1,i+1,q-(s[i]-1));
        }
        printf("%lld\n",ans);
    }

    return 0;
}



D Zookeeper and The Infinite Zoo

题意：一个有无穷多个结点的有向图中，结点编号从 1 开始。对于结点 u，如果 u&v = v，那么 u → u + v u\rightarrow u+v u→u+v 连一条有向边。给出 q（1e5） 组询问，每组询问给出两个数 u i u_i ui​ 和 v i v_i vi​（ < 2 30 <2^{30} <230），问在有向图中是否存在 u i u_i ui​ 到 v i v_i vi​ 的路径。

思路：观察有向边的形式可知，一定是从小的点指向大的点。u&v = v 表示 u 的二进制包含了 v 的二进制，也就是说， u → u + v u\rightarrow u+v u→u+v 实际上等价于从 u 的二进制中选出若干个 1 保留，然后累加到 u 上去。这里选出多个的操作，可以分解为多次选择 1 个的操作，于是考虑 u 的二进制，每次操作一定是这样的形式：选择 0111…1111，把它变为 1000…000 。这是一个 1 的个数不变多的操作。

考虑两个二进制数 u = u 30 u 29 . . . u 1 u 0 u=u_{30}u_{29}...u_{1}u_{0} u=u30​u29​...u1​u0​ 和 v = v 30 v 29 . . . v 1 v 0 v=v_{30}v_{29}...v_{1}v_{0} v=v30​v29​...v1​v0​ ，记二进制前缀和为 U 30 . . . U 1 U 0 U_{30}...U_1U_0 U30​...U1​U0​ 和 V 30 . . . V 1 V 0 V_{30}...V_1V_0 V30​...V1​V0​，二进制前缀和的意思就是 U k = ∑ i = 0 k u i U_k=\sum\limits_{i=0}^{k}{u_i} Uk​=i=0∑k​ui​ 。我们断言如果可以从 u 变为 v，等价于 ∀ k , U k ≥ V k \forall k,U_k\ge V_k ∀k,Uk​≥Vk​ 并且 u ≤ v u\le v u≤v。

原因是这样的：从 u 变为 v，本质上就是考虑 v 的二进制，然后从高位往低位一一满足 v 的 1，对于某个 v 的 1，一定是从 u 的某个区间（这个区间就是这一位直到 v 的下个 1 的那一位）变出来的，变完之后仍然需要保证剩下的 u 的 1 的个数不少于 v 的才行。

代码：

#define DIN freopen("input.txt","r",stdin);
#define DOUT freopen("output.txt","w",stdout);
#include <bits/stdc++.h>
#include <cstdio>
#define mem(a,b) memset(a,b,sizeof(a))
#define REP(i,a,b) for(int i=(a);i<=(int)(b);i++)
#define REP_(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
#define DEBUG
using namespace std;
typedef long long LL;
typedef std::vector<int> VI;
int read()
{
    int x=0,flag=1; char c=getchar();
    while((c>'9' || c<'0') && c!='-') c=getchar();
    if(c=='-') flag=0,c=getchar();
    while(c<='9' && c>='0') {x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return flag?x:-x;
}

int main()
{
    int q=read();
    while(q--)
    {
        int u=read(),v=read();
        if(u>v || __builtin_popcount(u)<__builtin_popcount(v))
            puts("NO");
        else
        {
            int a[32]={0},b[32]={0};
            for(int i=0;i<30;i++)
            {
                if(u&(1<<i)) a[i]=1;
                if(v&(1<<i)) b[i]=1;
            }
            REP(i,1,30) a[i]+=a[i-1];
            REP(i,1,30) b[i]+=b[i-1];
            int flag=1;
            REP(i,0,30) if(a[i]<b[i]) {flag=0; break;}
            puts(flag?"YES":"NO");
        }
    }

    return 0;
}



E Fib-tree

题意：给出一棵树（ n ≤ 2 ⋅ 1 0 5 n\le 2\cdot 10^5 n≤2⋅105），要一直切它的边，直到切完所有边为止。问是否存在一种切的方案，使得对于任意时刻，每棵树的结点数都是斐波那契数。

思路：分析一下复杂度就知道，暴力dfs即可。通过一些想象和推断，可以知道对于一棵树，切一刀的方案最多只有两种，于是对于整棵树考虑切的层次（有点抽象，每个层对应一棵完整的数），最多只有 l o g n logn logn 层。所以暴力枚举的话复杂度是 n l o g n nlogn nlogn 的。于是做法就很清晰了：

dfs整棵树，一边计算每个子树的 size，遇到可以切的情况（也就是子树size和剩下的size都是斐波那契数），就往下一层 dfs，中间标记切的边以便遍历边的时候不选择它们。

代码中的size数组第一维就是刚才说的层次，要保证每一层切树的时候，size互不干扰。

代码：

#define DIN freopen("input.txt","r",stdin);
#define DOUT freopen("output.txt","w",stdout);
#include <bits/stdc++.h>
#include <cstdio>
#define mem(a,b) memset(a,b,sizeof(a))
#define REP(i,a,b) for(int i=(a);i<=(int)(b);i++)
#define REP_(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
#define DEBUG
using namespace std;
typedef long long LL;
typedef std::vector<int> VI;
int read()
{
    int x=0,flag=1; char c=getchar();
    while((c>'9' || c<'0') && c!='-') c=getchar();
    if(c=='-') flag=0,c=getchar();
    while(c<='9' && c>='0') {x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return flag?x:-x;
}

const int maxn=2e5+5;
vector<int> G[maxn];
int n,siz[50][maxn];
bool isfib[maxn];
set<pair<int,int> > s;

bool dfs(int u,int fa,int num,int d)
{
    siz[d][u]=1;
    if(!isfib[num]) return 0;
    if(num==1) return 1;
    for(int v:G[u])
    {
        if(v==fa) continue;
        if(s.count(make_pair(min(u,v),max(u,v)))) continue;
        if(dfs(v,u,num,d)) return 1;
        siz[d][u]+=siz[d][v];
    }
    if(!isfib[siz[d][u]] || !isfib[num-siz[d][u]]) return 0;
    s.insert(make_pair(min(u,fa),max(u,fa)));
    if(dfs(u,0,siz[d][u],d+1) && dfs(fa,0,num-siz[d][u],d+1)) return 1;
    s.erase(make_pair(min(u,fa),max(u,fa)));
    return 0;
}

int main()
{
    int a[50];
    a[0]=a[1]=1;
    REP(i,2,30) a[i]=a[i-1]+a[i-2];
    REP(i,0,30)
    {
        //cout<<a[i]<<endl;
        if(a[i]<maxn) isfib[a[i]]=1;
        else break;
    }

    n=read();
    REP(i,1,n-1)
    {
        int u=read(),v=read();
        G[u].pb(v); G[v].pb(u);
    }
    puts(dfs(1,0,n,0)?"YES":"NO");

    return 0;
}



F

题意：

思路：

代码：


G

题意：

思路：

代码：


H

题意：

思路：

代码：


I

题意：

思路：

代码：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值