Codeforces Round #673 (Div. 2)A-E题解

Codeforces Round #673 (Div. 2)A-E题解

比赛链接:https://codeforces.com/contest/1417

A题
水，贪心

题意为给定一个长度为n的数列，并给定一个上限k，原数列中的每个数都在1到k之间，现在你每次操作都可以把当前数列中的某一个数字加到另一个数字上，但是不可以让数值超过k，现在询问最多可以操作多少次。

直接贪心选择值最小的那一个，把其他数字尽可能多得用这个最小值加就是了。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

int32_t main()
{
    IOS;
    int t;
    cin>>t;
    while(t--)
    {
        int n,k;
        cin>>n>>k;
        int ans=0,tar=0;
        vector<int>num(n);
        for(int i=0;i<n;i++)
        {
            cin>>num[i];
            if(num[i]<num[tar]) tar=i;
        }
        for(int i=0;i<n;i++)
            if(i!=tar) ans+=(k-num[i])/num[tar];
        cout<<ans<<endl;
    }
} 

B题
贪心，构造

题意为给定一个长度为n的数列，并给定一个数值T，现在要求你把原数列分成两个数列，两个数列中在同一个数列里加起来等于T的数字下标对数最少。

贪心即可了，把小于T的一半的放进第一个数列，大于T的一半的放进第二个数列，刚好等于T一半的均匀分不到两个数列里即可。因为小于T的一半只能和大于T的一半加起来等于T，直接把他们分成两个部分即可，刚好等于一半的均匀分布这个结论自己稿纸上验算下就是了。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

int32_t main()
{
    IOS;
    int t;
    cin>>t;
    while(t--)
    {
        ll n,T;
        cin>>n>>T;
        bool flag=0;
        vector<bool>color(n);
        for(int i=0;i<n;i++)
        {
            ll x;
            cin>>x;
            if(x*2==T) {color[i]=flag;flag=!flag;}
            else if(x*2<T) color[i]=0;
            else color[i]=1;
        }
        for(int i=0;i<n;i++) cout<<color[i]<<' ';
        cout<<endl;
    }
}

C题
字符串，小结论，map简单运用

给定一个长度为n的数列，你需要输出对与取值1-n的k值，对与该数列中所有长度为k的连续子序列，共用的数字中最小的那一个。如果没有共有的数字，则输出-1。

如果直接从正面去考虑，会发现难以思考。我们可以从针对某一个具体的数值来看，如果这个数值作为某个长度k的最小公共值的话，长度k需要不小于这个数列中所有该值出现的位置中相邻位置的最大间距（注意在数列最左侧和最右侧要特殊判定）。利用这个结论我们可以借助map在一次for循环得到每个数值对应的最小k，记录后直接对kfor一遍1-n即为答案，输出最小k即可。

#include<bits/stdc++.h>
#define ll long long
#define INF 0x7f7f7f7f //2139062143
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

int32_t main()
{
    IOS;
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        map<int,pair<int,int>>M;//M[i]=pair{j,k},代表值为i的数字最后出现在下标j的位置，值为i的数字之间的最大间隔为k
        for(int i=1;i<=n;i++)
        {
            int x;
            cin>>x;
            if(M.find(x)==M.end()) M[x]=make_pair(i,i);//数列左侧特判
            else
            {
                M[x].second=max(M[x].second,i-M[x].first);
                M[x].first=i;
            }
        }
        vector<int>ans(n+1,INF);
        for(auto &x:M)
        {
            x.second.second=max(x.second.second,n+1-x.second.first);//特判数列右侧
            ans[x.second.second]=min(ans[x.second.second],x.first);
        }
        int now=INF;
        for(int i=1;i<=n;i++)
        {
            now=min(now,ans[i]);
            if(now==INF) cout<<-1<<' ';
            else cout<<now<<' ';
        }
        cout<<endl;
    }
}

D题
构造，思维

题意为给定一个长度为n的数列，其中的每个数的数值都为1到1e5之间的正整数，现在你需要在最多3n次操作内，使得这个数列中的每一个数的值相等。
每次操作你可以选择两个下标i和j，并且选定一个0到1e9之间的自然数x，对ai减去i $\times$ x，对aj加上i $\times$ x。

首先注意到整个数列的和在操作过程中是没被改变过的，因此首先整个数列的和需要能被数列长度n整数才可能构造。之后我们注意到这里操作的特殊性在于我们对两个下标增减的数值是需要乘以下标i的，那么很容易想到的下标1的数如果足够大，就可以在一次操作满足我们任意一个位置的构造，那么能否先通过某种方式把整个数列所有的数值聚集到a1上，再for一次n分配的所有位置上呢。我们注意到如果我们想把aj位置上的所有数值都移动到a1上，aj的值需要整除j才行，那么如果aj的值无法整除j，我们需要从别的地方补数值到aj上去。
很容易的我们也会想到利用a1补到aj上使得aj整除j，然后就会发现…直接for一遍2到n必定可以完成这样的清零a2到an的操作，因为原数列中每个数都是正整数，也就是说前n个数的和至少为n，也就是说必然能使得aj的值变为能被j整除。
所以我们第一遍for下标2到n，每次循环两轮操作，第一轮操作把a1的值补到aj上使得aj能被j整除，第二轮操作把aj的所有值移动到a1上。
这样一轮操作消耗了2n-2次，把整个数列所有值都移动到了a1上，之后再for一遍2到n的下标，从a1直接把值移动过来构造即可。总共消耗3n-3次操作，必定完成构造。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
const ll maxn=1e4+7;

ll num[maxn];
ll n,sum;

int32_t main()
{
    IOS;
    int t;
    cin>>t;
    while(t--)
    {
        sum=0;
        cin>>n;
        for(ll i=1;i<=n;i++) {cin>>num[i];sum+=num[i];}
        if(sum%n) cout<<-1<<endl;
        else
        {
            sum/=n;
            cout<<3*(n-1)<<endl;
            for(ll i=2;i<=n;i++)//第一遍for把除了num[1]外的所有值清零，移动到num[1]上
            {
                ll temp=i-num[i]%i;
                if(temp==i) temp=0;
                cout<<1<<' '<<i<<' '<<temp<<endl;
                num[1]-=temp;
                num[i]+=temp;
                cout<<i<<' '<<1<<' '<<num[i]/i<<endl;
                num[1]+=num[i];
            }
            for(ll i=2;i<=n;i++) cout<<1<<' '<<i<<' '<<sum<<endl;//第二遍for直接利用num[1]构造
        }
    }
}

E题
位运算，dfs分治，结论

题意为给定一个长度为n的只包含自然数的数列，你需要找到一个合适的值out，使得对原数列中每个数值都异或x后得到一个新数列，这个新数列中逆序对的数量num最小，输出这个最小的num和对应的out值。

这里需要认识到，假设只有0和1的数列，我们可以通过一次for循环的过程中，记录0和1出现了几次，以0和以1为结尾构成逆序对的数量，根据两个值的大小差别决定我们是用0还是用1去异或他们。
由此之后，
我们从高位到低位看，根据取值的不同，数列会被分为2的对应深度次方的几个集合，对于不同的集合来说，他们之间的逆序对数量是已经在前面的层数过程中根据上面一段的计算过程可以求得，之后各个集合之间再也不会产生影响，因为后续只对更低位产生影响，不会对当前集合之间的关系产生影响。
推到此处之后直接写一个dfs分治即可。

#include<bits/stdc++.h>
#define ll long long
#define llINF 9223372036854775807
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;

int n;
ll ans=0,out=0;//ans为最终的数列中逆序对的数量，out为对原数列中每个值进行异或的值

void dfs(vector<vector<ll>>now,int deep)//二维数组now记录数列在当前层数被分割成了几个部分,deep为当前算的是二进制第几位
{
    ll temp=1ll<<deep;
    ll cas0,cas1,sum0=0,sum1=0;//sum0和sum1分别记录当前二进制deep位上，以该位为0的值作为逆序对的右侧（也就是out在此位取0）的逆序对数量
    //和以该位为1的值作为逆序对的右侧(也就是out在此位取1，使得该位的所有数0和1转化）的逆序对数量
    vector<vector<ll>>next;//下一次dfs的二维数组
    vector<ll>next0,next1;//当前分割部分的vector中，二进制deep位为0和1的数字分别放入两个vector
    for(int i=0;i<now.size();i++)
    {
        cas0=cas1=0;
        for(int j=0;j<now[i].size();j++)
        {
            if(now[i][j]&temp) {sum1+=cas0;cas1++;next1.push_back(now[i][j]);}
            else {sum0+=cas1;cas0++;next0.push_back(now[i][j]);}
        }
        if(next0.size()) {next.push_back(next0);next0.clear();}//避免不需要的递归和空间浪费，如果next0和next1不为0才压入下次dfs的数组里
        if(next1.size()) {next.push_back(next1);next1.clear();}
    }
    if(sum0>sum1) {ans+=sum1;out+=temp;}//如果以该位为0的值作为逆序对右侧的逆序对数量大于以该位为1的值作为逆序对的右侧，代表out需要在该位取1
    else ans+=sum0;
    if(deep==0) return;
    dfs(next,deep-1);
}

int32_t main()
{
    IOS;
    cin>>n;
    vector<vector<ll>>num(1);
    num[0].resize(n);
    for(auto &x:num[0]) cin>>x;
    dfs(num,30);//dfs30层即可，1e9的最高位也不过2的30次
    cout<<ans<<' '<<out<<endl;
}