Codeforces Round #698 (Div. 2)A-D题解

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

A题
贪心

题意:
给定长度为n的递增的整数数列，问对每个数字都染上一种颜色，使得每个颜色的数字拿出来都是单调递增的。
问最少需要几种颜色。

本来这个问题是个LIS问题，然而给定的数列已经递增的了。就变成了一个沙比题
对于每个数字来说，如果它出现了cas次，由于单一颜色的数字是严格单调递增的，所以这个cas个数字都要被染上不同的颜色。
所有数字的出现次数cas，取最大的那个就是答案。

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

int main()
{
    IOS
    int t;
    cin>>t;
    while(t--)
    {
        int n;cin>>n;
        int num[107];
        int ans=0;
        int cas=0;//cas保存到当前位置位置，当前这个数出现了几次
        for(int i=0;i<n;i++)
        {
            cin>>num[i];
            if(i&&num[i]==num[i-1]) cas++;
            else cas=1;
            ans=max(ans,cas);
        }
        cout<<ans<<endl;
    }
}

B题
构造，贪心，暴力

题意:
给定一个一位正整数d。
然后给定若干正整数ai，询问ai是否能用若干个十进制表示下至少有一位包含d的整数相加得到。

这里先推得一个简单的结论，如果ai>=10d的话，ai必定能按照上述要求得到。
首先如果ai<=10d+9，那ai自身就带了一个d，因此直接可以用单个ai相加得到。
如果ai>10d+9，那么ai可以表示成(10d+x)+(y+d)，其中x的十位为0，y的个位为0，由于ai>10d+9，
故(10d+x)+(y+d)>10d+9即x+y>9-d,即x+y为一个整数z。
x的十位不能为0，y的个位不能为0，那么我们把z的十位丢给y，个位丢给x，其他位随意分配给x和y都可。故必定存在满足要求的10d+x和y+d。

当ai<10d的时候，这时我们已经不可能在除了个位外的地方放置整数d了。
我们直接枚举十位选择了什么数字记为k，判断ai-10k是否能被d整除即可。

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

int main()
{
    IOS
    int t;
    cin>>t;
    while(t--)
    {
        int n,d;cin>>n>>d;
        while(n--)
        {
            int x;cin>>x;
            if(x>=d*10) cout<<"YES"<<endl;
            else
            {
                bool flag=0;
                for(int i=0;i<10;i++)//暴力枚举十位用了什么数字
                {
                    int temp=i*10;
                    if(x>temp&&(x-temp)%d==0) flag=1;//如果能整除则存在
                }
                if(flag) cout<<"YES"<<endl;
                else cout<<"NO"<<endl;
            }
        }
    }
}

C题
相关tag:数学

题意:
给定一个正整数n，给定2n个两两不相同的整数，其中每一个整数它的相反数都必定包含在这2n个整数里。每个值与其它2n-1个数的差的绝对值累加起来，记作x。
现在给定这2n个整数的x，让你判断这2n个x是否是合理的，也就是说能否找到一组2n个两两不相同的整数，可以得到给定的这2n个x。

我们如果把这2n个数全部放到数轴上(代码实现时需要排序）。我们只看原点右侧的部分，以x1点为标准。
从x1点移动到x2点，这一段的左侧有5个点，右侧有3个点，每移动一个长度单位，左侧的点的距离和+5，右侧点的距离和-3，总距离和+2。因此x1点移动到x2点所增加的总距离就为2$\times$d2。
可以继续推广，从xi点到xi+1点，其距离为di，则总距离增加量为2i$\times$di，也就是说这两点的总距离的差值，需要能被2i整除（且不为0）。

由此我们可以计算出x2,x3…xn到x1的距离，并借由此计算出x1与原点的距离(同样要满足可整除，且不小于等于0），从而判断是否存在解。

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

ll num[2*maxn];
ll now=0;

int main()
{
    IOS
    int t;
    cin>>t;
    while(t--)
    {
        int n;cin>>n;n*=2;
        for(int i=0;i<n;i++) cin>>num[i];
        sort(num,num+n);
        bool flag=1;
        int now=0;
        for(int i=1;i<n;i+=2)
        {
            if(num[i]!=num[i-1]) flag=0;//需要对应相等
            num[now++]=num[i];//只需要保留一半的数就够了
        }
        ll sum=0;//记录不计算 x轴正轴上，从左往右看(下面的点都这么看)的第1个点，在不计算自身到原点这段距离的情况下其他点产生的距离和
        for(int i=1;i<now;i++)//now即n/2，最开始的n值
        {
            ll mod=i*2;//从第i个点移动到第i+1个点，每移动一个长度会增加2i的总距离
            ll dis=num[i]-num[i-1];
            if(dis==0||dis%mod) {flag=0;break;}//如果无法整除增加的长度或者点重合了都是不满足的情况
            else sum+=dis/mod*2*(now-i);//当前这一段会被计算2*(now-i)次
        }
        sum=num[0]-sum;//依靠剩余的sum值计算第一个点和原点的距离
        if(sum%n||sum<n) flag=0;//该距离会被计算2n(这里的n在最开始已经*2了)次，因此要被2n整除且距离不为0
        if(flag) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
}

D题
相关tag:数学，结论

题意:
给定n个整数xi。
每次操作你可以在原有的整数里挑选两个数x和y，把2x-y的值加入到这些整数里。
问是否能在若干次操作后，得到整数k。

这里需要注意到，每次操作是2x-y。
多次计算之后的数用原有的xi表示，可以表示为k1$\times$x1+k2$\times$x2+…kn$\times$xn。
我们把k1+k2+…+kn算出来记为K。
最开始的时候，xi的K值都为1。
经过一次2x-y的运算后，得到的数K值仍然为1，因为1 $\times$ 2-1=1。
也就是说如果我们当前的数的K值如果都为1，经过2x-y操作后的得到的新数的K也仍为1。

利用归纳法可以得到，我们得到的数的K值只能为1。
那么也就是说，我们能表示的数是由某一个xi，加上任意系数组合的 x两两之间的差值得到的。
这某一个xi我们可以枚举。
而后面任意系数组合的 x两两之间的差值，他们的最大公约数gcd是他们可以被分割得到的最小绝对值的数。也就是说他们能表示的数，只有gcd的整数倍。
我们可以通过计算这些数差值的最大公约数，得到这个最小块。

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

ll num[maxn];
int n;
ll k;

ll gcd(ll a,ll b)
{
    return b?gcd(b,a%b):a;
}

int main()
{
    IOS
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n>>k;
        bool flag=0;
        for(int i=0;i<n;i++)
        {
            cin>>num[i];
            if(num[i]==k) flag=1;//如果输入的值已经是k了就没必要进行后续部分
        }
        if(!flag)
        {
            vector<ll>cas;
            for(int i=1;i<n;i++) cas.push_back(abs(num[i]-num[i-1]));//相邻两个数之间的差值
            for(int i=1;i<cas.size();i++) cas[0]=gcd(cas[0],cas[i]);//求取差值的最大公约数
            //即利用所给的这些数作差，任意组合后能得到的最小一块的值是多少
            for(int i=0;i<n;i++)
            {
                ll temp=k-num[i];//枚举除了差值之外，多余的那一个数是哪一个
                if(temp%cas[0]==0) flag=1;
            }
        }
        if(flag) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
    }
}