Codeforces Round #665 (Div. 2) 题解

Codeforces Round #665 (Div. 2) 题解

写得有点晚了，估计都官方题解看完切掉了，没人看我的了qaq。

目录

• Codeforces Round #665 (Div. 2) 题解
  • A - Distance and Axis
  • B - Ternary Sequence
  • C - Mere Array
  • D - Maximum Distributed Tree
  • E - Divide Square
  • F - Reverse and Swap

A - Distance and Axis

现在有整数\(n\)，问你执行多少次对\(n\)加一/减一的操作后能有整数\(m\)且\(||n-m|-m|=k\)。

首先，假如\(n\leq k\)，那么把\(n\)变成\(k\)就能满足条件，然后我们考虑\(n>k\)：假如限定\(0\leq m\leq n\)且\(m\leq n-m\)，得到了\(m=\frac{n-k}2\)，那么只要保证\(n-k\)是偶数就好了，操作一次即可。

程序如下：

#include<bits/stdc++.h>
using namespace std;

int t,n,k;

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    cin>>t;
    while(t--){
        cin>>n>>k;
        if(n<=k){
            cout<<k-n<<'\n';
        }else{
            cout<<(n-k&1)<<'\n';
        }
    }

    return 0;
}

B - Ternary Sequence

不难看出，只有从\(a\)中取出\(2\)和\(b\)中取出的\(1\)配对时，贡献为\(2\)；从\(a\)中取出\(1\)和\(b\)中取出的\(2\)配对时，贡献为\(-2\)。那么我们肯定要最大化第一种情况出现的次数，最小化第二种情况的出现次数。那么先把\(a\)中的\(2\)和\(b\)中的\(1\)配对，然后尽量的使用\(a\)中的\(2\)和\(0\)去匹配\(b\)中的\(2\)即可。可以证明这样得到的是最优的。

虽然我不会证明但是还是来感性理解一下：

假如把\(a\)中的\(2\)，\(b\)中的\(1\)这样的匹配拆散，用\(a\)中的\(2\)去匹配\(b\)中的\(2\)，那么答案不变。假如去匹配\(b\)中的其他数，那么结果会更差。其余的都差不多，偷个懒不写了（

程序如下：

#include<bits/stdc++.h>
using namespace std;

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int T,x1,y1,z1,x2,y2,z2;
    cin>>T;
    while(T--){
        cin>>x1>>y1>>z1>>x2>>y2>>z2;
        int ans=0,tmp;
        tmp=min(z1,y2);
        z1-=tmp;
        y2-=tmp;
        ans+=tmp*2;
        tmp=min(z1,z2);
        z1-=tmp;
        z2-=tmp;
        tmp=min(x1,z2);
        x1-=tmp;
        z2-=tmp;
        tmp=min(y1,z2);
        ans-=tmp*2;
        cout<<ans<<'\n';
    }

    return 0;
}

C - Mere Array

为了叙述方便，我们记最小的元素为\(m\)。

我们先来看是\(m\)倍数的元素，可以证明它们之间一定可以互换位置，也只有它们可以互换位置。

证明只有它们可以互换位置很简单，不是\(m\)倍数的元素，和其他的元素求最大公因数肯定不等于\(m\)。

它们之间一定可以互换位置，是因为假如我们使用\(m\)作为中转，就可以间接地交换它们。

由于一个有序的序列，子序列一定有序。所以我们就屏蔽不是\(m\)倍数的元素，把剩下的元素排序，再检查是否为有序序列即可。

程序如下：

#include<bits/stdc++.h>
using namespace std;

int n,a[100005],mn;
bool mark[100005];

void mian(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    mn=*min_element(a+1,a+1+n);
    vector<int> v;
    for(int i=1;i<=n;i++){
        if(a[i]%mn==0){
            v.emplace_back(a[i]);
        }
        mark[i]=a[i]%mn==0;
    }
    sort(v.begin(),v.end());
    bool f=true;
    for(int i=1,j=0;i<=n;i++){
        if(mark[i]){
            a[i]=v[j++];
        }
        assert(j<=v.size());
        f&=a[i]>=a[i-1];
    }
    cout<<(f?"YES\n":"NO\n");
}

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int T;
    cin>>T;
    while(T--){
        mian();
    }

    return 0;
}

D - Maximum Distributed Tree

首先，反过来考虑。考虑每条边对于答案的贡献。每条边经过的次数越多，那么就需要配上一个更大的权值。

计算边经过的次数：我们钦点一个根出来。不难发现，一个结点连向它父亲的边，假如有一条路径经过这条边，那么一定路径的一端在子树内，一端在子树外。这个我们DFS处理子树大小就可以计算了。

如何分配权值：首先由于要使得权值中\(1\)的出现次数最小，那么就需要尽量的给每个边都分出一个\(k\)的因子。假如因子少了，那么只能补充\(1\)，假如因子多了，那么就取最大的一部分因子分配给经过次数最多的边，其余的小的因子再分配给其他边，这样就能保证结果最优。

程序如下，需要注意先sort后取模：

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int mod=1e9+7;

int n,m;
vector<int> g[100005];
int sz[100005];
vector<ll> e,p;

void dfs(const int &x,const int &p){
    sz[x]=1;
    for(int &y:g[x])if(y!=p){
        dfs(y,x);
        sz[x]+=sz[y];
    }
    if(x!=1){
        e.emplace_back((ll)sz[x]*(n-sz[x]));
    }
}

void mian(){
    cin>>n;
    for(int i=1;i<=n;i++){
        g[i].clear();
    }
    for(int i=1;i<n;i++){
        static int u,v;
        cin>>u>>v;
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    }
    e.clear();
    dfs(1,-1);
    sort(e.begin(),e.end());
    reverse(e.begin(),e.end());
    for(ll &x:e)x%=mod;
    cin>>m;
    p.resize(m);
    for(int i=0;i<m;i++){
        cin>>p[i];
    }
    sort(p.begin(),p.end());
    if(m>n-1){
        for(int i=m-2;i>=n-2;i--){
            p[i]=p[i]*p[i+1]%mod;
        }
        p.resize(n-1);
    }
    reverse(p.begin(),p.end());
    while(p.size()<n-1)p.emplace_back(1);
    ll ans=0;
    for(int i=0;i+1<n;i++){
        ans=(ans+e[i]*p[i])%mod;
    }
    cout<<ans<<'\n';
}

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int T;
    cin>>T;
    while(T--){
        mian();
    }

    return 0;
}

E - Divide Square

注意到有两个限制条件：线段肯定和一条正方形的边相交、没有线段在一条直线上。

不难看出（虽然我赛时没看出），一个和正方形的两条对边都相交的线段，会使得答案加一，两条相交的线段，也会使得答案加一。那么我们就需要计算这些东西了。

和正方形的两条对边都相交的线段，可以在读入时就判断好。

两条相交的线段，肯定是横向的和竖向的相交。这里我们假设有一条横向的，从下往上移动的扫描线。同时使用树状数组维护，扫描线上每个位置是否有竖向线段与其交叉。那么横向的线段要计算交叉的竖向线段数，只需要做一次区间和就好。我们离线输入数据，在竖向线段的底端所在的位置，加入它，在顶端删去它，就可以维护扫描线上交叉的竖向线段了。

程序如下：

#include<bits/stdc++.h>
using namespace std;

const int bound=1e6+1;

int bit[bound+5];

int sum(int pos){
    int res=0;
    while(pos>0){
        res+=bit[pos];
        pos-=pos&-pos;
    }
    return res;
}

void add(int pos,int val){
    while(pos<=bound){
        bit[pos]+=val;
        pos+=pos&-pos;
    }
}

int n,m;
long long ans=1;
vector<pair<int,int>> qs[bound+5];
vector<int> seg[bound+5];

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    cin>>n>>m;
    for(int i=1;i<=n;i++){
        int y,l,r;
        cin>>y>>l>>r;
        y++;l++;r++;
        qs[y].emplace_back(l,r);
        ans+=l==1&&r==bound;
    }
    for(int i=1;i<=m;i++){
        int x,d,u;
        cin>>x>>d>>u;
        x++;d++;u++;
        seg[d].emplace_back(x);
        seg[u+1].emplace_back(-x);
        ans+=d==1&&u==bound;
    }
    for(int y=1;y<=bound;y++){
        for(int &x:seg[y])add(abs(x),x/abs(x));
        for(pair<int,int> &p:qs[y])ans+=sum(p.second)-sum(p.first-1);
    }
    cout<<ans<<endl;

    return 0;
}

F - Reverse and Swap

裸的数据结构题，最喜欢了~

不难看出，我们需要线段树，那么剩下的就是考虑怎么维护了。单点修改和区间求和我就偷懒不讲了嗷。万能的OI Wiki都有。接下来需要用到区间修改的懒标记思想，所以不会的还是要去看OI Wiki。

我们先来处理\(Swap\)操作：把整个序列分成若干个长度为\(2^k\)的区间，假如这些区间编号为\(1,2,3,\dots\)，那么我们交换\(1\)和\(2\)，\(3\)和\(4\)，以此类推。由于线段树奇妙的结构，对\(2^k\)长的区间进行交换操作，实际上就是对于每个\(2^{k+1}\)的区间，交换它的左右儿子，那么我们只要存一个懒标记就可以了。这里需要记录各种长度的区间是否要交换，那么我们把它压进一个int里维护即可。

然后，我们来把\(Reverse\)变成\(Swap\)，\(Reverse\)就是区间把\(2^k\)的区间进行\(Reverse\)操作，实际上相当于对于长度\(2^{k-1},2^{k-2},\dots,2^{1},2^{0}\)的区间执行\(Swap\)操作，好了我们不用实现它了。

程序如下：

#include<bits/stdc++.h>
using namespace std;

struct SegTree{
    typedef long long ll;
    struct node{
        node *l,*r;
        ll val;
        int len,swp;
        node(){
            l=r=nullptr;
            val=len=swp=0;
        }
        void pushdown(){
            if(swp&len>>1){
                node tmp=*r;
                *r=*l;
                *l=tmp;
                swp^=len>>1;
            }
            l->swp^=swp;
            r->swp^=swp;
            swp=0;
        }
        void pullup(){
            val=l->val+r->val;
        }
    };

    int sz;
    node *root;
    void build(node *id,const int &l,const int &r,const vector<int> &a){
        id->len=r-l+1;
        if(l==r){
            id->val=a[l-1];
            return;
        }
        id->l=new node;
        id->r=new node;
        build(id->l,l,l+r>>1,a);
        build(id->r,(l+r>>1)+1,r,a);
        id->pullup();
    }
    SegTree(const int &n,const vector<int> &a){
        sz=1<<n;
        root=new node;
        build(root,1,sz,a);
    }

    void upd(node *id,const int &l,const int &r,const int &pos,const int &val){
        if(pos<l||r<pos)return;
        if(pos<=l&&r<=pos){
            id->val=val;
            return;
        }
        id->pushdown();
        upd(id->l,l,l+r>>1,pos,val);
        upd(id->r,(l+r>>1)+1,r,pos,val);
        id->pullup();
    }

    void upd(const int &pos,const int &val){
        upd(root,1,sz,pos,val);
    }

    ll qry(node *id,const int &l,const int &r,const int &ql,const int &qr){
        if(qr<l||r<ql)return 0;
        if(ql<=l&&r<=qr){
            return id->val;
        }
        id->pushdown();
        return qry(id->l,l,l+r>>1,ql,qr)+qry(id->r,(l+r>>1)+1,r,ql,qr);
    }

    ll qry(const int &l,const int &r){
        return qry(root,1,sz,l,r);
    }

    void reverse(const int &k){
        root->swp^=(1<<k)-1;
    }

    void swap(const int &k){
        root->swp^=1<<k;
    }
};

int n,q;

int main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    cin>>n>>q;
    vector<int> a(1<<n);
    for(int i=0;i<1<<n;i++){
        cin>>a[i];
    }
    SegTree t(n,a);
    while(q--){
        int typ,x,y;
        cin>>typ>>x;
        if(typ==1){
            cin>>y;
            t.upd(x,y);
        }else
        if(typ==2){
            t.reverse(x);
        }else
        if(typ==3){
            t.swap(x);
        }else
        if(typ==4){
            cin>>y;
            cout<<t.qry(x,y)<<'\n';
        }
    }

    return 0;
}