Codeforces Round #665 (Div. 2) 题解

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

Codeforces Round #665 (Div. 2) 题解

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;

}

不难看出，只有从$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;

}