Codeforces Round #702 (Div. 3)

A - Dense Array

模拟

找到不符合的，然后不断让分母增大两倍，直到符合条件。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve()
{
    int n;
    cin>>n;
    vector<int>a(n);
    for(int i=0;i<n;i++)
        cin>>a[i];
    int res=0;
    for(int i=0;i<n-1;i++){
        int x=max(a[i],a[i+1]);
        int y=min(a[i],a[i+1]);
        while(x>y*2){
            res++;
            y<<=1;
        }
    }
    cout<<res<<endl;
}
int main()
{
    int t;
    cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

B - Balanced Remainders

贪心

观察规律可以看到，余数为2的增加1之后变成余数为0的，余数为0的增加1后变成余数为1的，余数为1的增加1后变成余数为0的，所以我们尽可能让大的减小，小的增大。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve()
{
    int n;
    cin>>n;
    vector<int>t(n);
    int a=0,b=0,c=0;
    for(int i=0;i<n;i++){
        cin>>t[i];
        if(t[i]%3==0) a++;
        else if(t[i]%3==1) b++;
        else if(t[i]%3==2) c++;
    }
    int res=0;
    while(1){
        if(a==b && a==c && b==c) break;
        if(c>a) {
            c--,a++;
            res++;
        }
        if(a>b){
            a--,b++;
            res++;
        }
        if(b>c){
            b--,c++;
            res++;
        }
    }
    cout<<res<<endl;
}
int main()
{
    int t;
    cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

C - Sum of Cubes

哈希表 两数之和问题

将可能的数进行存储，然后再遍历，找到符合的即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve()
{
    ll x;
    cin>>x;
    map<ll,ll>mp;
    for(ll i=1;i<100000;i++){
        ll t=x-i*i*i;
        mp[t]++;
    }
    for(ll i=1;i<100000;i++){
        if(mp.count(i*i*i)>0) {
            cout<<"YES"<<endl;
            return;
        }
    }
    cout<<"NO"<<endl;
    
}
int main()
{
    int t;
    cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

D - Perutation Transformation

DFS

每次都找到一段数组中最大值，然后再将它的两侧进行搜索，递归同时携带次数，找到最大值将其赋值。最后输出。

注意边界问题。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int res[10000];
int a[101];
void find(int l,int r,int t){
    if(l>r) return;
    int maxn=-1,index=-1;
    for(int i=l;i<=r;i++){
        if(a[i]>maxn){
            maxn=a[i];
            index=i;
        }
    }
    res[index]=t;
    find(l,index-1,t+1);
    find(index+1,r,t+1);
}
void solve()
{
    int n;
    cin>>n;
    int maxn=-1,index=0;
    for(int i=0;i<n;i++){
        cin>>a[i];
        if(a[i]>maxn){
            maxn=a[i];
            index=i;
        }
    }
    res[index]=0;
    find(0,index-1,1);
    find(index+1,n-1,1);
    for(int i=0;i<n;i++)
        if(i==0)
        cout<<res[i];
    else 
        cout<<" "<<res[i];
    cout<<endl;
}
int main()
{
    int t;
    cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

E - Accidental Victory

前缀和+排序

将数据存储下来之后，可以用二维数组方式保存其信息，防止后续排序时次序错乱。a[i][0]存放数据，a[i][1]存放原来的下标，a[i][2]用来标记是否可行。

从小到大排序，然后记录前缀和。

很显然，最大的肯定可以成为获胜者，那么我们考虑第二大是否可能成为获胜者。那么就是第二大的之前的所有的数值加上本身如果大于等于最大值，那么就可以成为胜者，否则不行。

那么最关键的是考虑到第三大的如何成为获胜者。第一种思路是，此前的所有值加上本身，大于等于其后的总值，但是我们可以看到第一个例子就不符合，最极端的情况就是，1 1 999 1001 1003，像这种情况，如果这种思路判断的话，第三个人无法被判断为获胜者。

但是如果我们从后向前考虑，那么一般化来看，如果当前值加上之前所有的值，大于等于后一个值，那么又如果后一个值已经被判定为可以成为获胜者，那么当前的人就可以合并后一个人的值，而此时，已经转化为了后一个人的情况，当然也是获胜者了。

那么就可以看到，当我们从后向前遍历，因为最后一个一定是获胜者，那么就判断倒数第二个，再到第三个，只要到某个的前缀和无法大于等于后一个时，那么在这个之前的都无法成为获胜者了，跳出循环即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve()
{
    int n;
    cin>>n;
    vector<vector<ll>>a(n+1,vector<ll>(3,0));
    vector<ll>pre(n+1);
    for(ll i=1;i<=n;i++){
        cin>>a[i][0];
        a[i][1]=i;
    }
    if(n==1) {
        cout<<"1"<<endl;
        cout<<"1"<<endl;
        return;
    }
    sort(a.begin(),a.end());
    for(ll i=1;i<=n;i++){
        pre[i]=pre[i-1]+a[i][0];
    }
    for(int i=n;i>=2;i-=1){
        if(pre[i-1] >= a[i][0]) 
            a[i-1][2]=1;
        else 
            break;
    }
    vector<int>res;
    for(int i=1;i<=n;i++){
        if(a[i][2]==1)
            res.push_back(a[i][1]);
    }
    res.push_back(a[n][1]);
    sort(res.begin(),res.end());
    int k=res.size();
    cout<<k<<endl;
    for(int i=0;i<k;i++)
    {
        if(i==0)
            cout<<res[i];
        else
            cout<<" "<<res[i];
    }
    cout<<endl;
}
int main()
{
    int t;
    cin>>t;
    while(t--){
        solve();
    }
    return 0;
}