Educational Codeforces Round 135 (Rated for Div. 2)A-D

最新推荐文章于 2024-07-12 16:34:36 发布

whitesword白刃

最新推荐文章于 2024-07-12 16:34:36 发布

阅读量309

点赞数 2

分类专栏： cf之旅文章标签： c++ acm竞赛

本文链接：https://blog.csdn.net/m0_57221330/article/details/126788509

版权

cf之旅专栏收录该内容

15 篇文章 0 订阅

订阅专栏

A. Colored Balls: Revisited

找一个最大的即可，那么输出最大的那个值的下标就好了。

#include<bits/stdc++.h>
using namespace std;
const int maxn =2e6+10;
const int mod = 1e9+7;
#define ll long long
#define ull unsigned long long
int num[maxn];


void solve(){
    int n;
    cin>>n;
    for(int i = 1;i<=n;i++){
        cin>>num[i];
    }
    cout<<max_element(num+1,num+n+1)-num<<endl;
}

int main() {
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t = 1;
    cin>>t;
    while(t--){
        solve();
    }
}

B. Best Permutation

构造题，如果我们倒退一下，就会想到最终答案最大只能为n+n-1，那么为了获得这个答案，我们要保证前面的数为0，那么分两种情况构造，如果是偶数的话直接倒着来就行，如果是奇数的话前面用123把这个奇数变成偶数性质即可。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
const int maxn = 1e6+10;

int num[maxn];
void solve(){
    int n;
    cin>>n;
    if(n%2==0){
        for(int i = n-2;i>=2;i--)
            cout<<i<<" ";
        cout<<1<<" "<<n-1<<" "<<n<<endl;
    }
    else{
        cout<<1<<" "<<2<<" "<<3<<" ";
        for(int i = n-2;i>=4;i--)
            cout<<i<<" ";
        cout<<n-1<<" "<<n<<endl;
    }
}

int main(){
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t = 1;
    cin>>t;
    while(t--){
        solve();
    }
}

C. Digital Logarithm

直接贪心暴力就好了，我们把两组数分别赛到大根堆中，如果堆顶相等就可以彼此直接消去，如果有一边比较大，那么想直接消去是不可能的，就只能用操作把这个数变小，ans++。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
const int maxn = 1e6+10;
ll ans = 0;
int change(int x) {
    return to_string(x).length();
}

void solve(){
    int n,x;
    cin>>n;
    priority_queue<int>a,b;
    for(int i = 1;i<=n;i++){
        cin>>x;
        a.push(x);
    }
    for(int i = 1;i<=n;i++){
        cin>>x;
        b.push(x);
    }
    ans = 0;
    while(!a.empty()&&!b.empty()){
        if(a.top()==b.top()){
            a.pop(),b.pop();
        }
        else if(a.top()>b.top()){
            a.push(change(a.top()));
            a.pop();
            ans++;
        }
        else{
            ans++;
            b.push(change(b.top()));
            b.pop();
        }
    }
    cout<<ans<<endl;
}

int main(){
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t = 1;
    cin>>t;
    while(t--){
        solve();
    }
}

D. Letter Picking

两个做法吧。

第一个是可以观察出，Bob是不可能获胜的，Bob只可能争取平局。因为假设最小的字符不在两边，那么Alice会争取让最后的局面变成类似cab这样，无论Bob取哪边，Alice都可以获得a作为前缀。那么Bob会去想办法让最小的字符放在两边，但是没有用，因为如果最小的字符暴露在外面，那么Alice把目标定在除去两端外最小的那个即可。同样，如面对类似baac这样的局面，Alice只要让自己第二个字符最小即可。

总之，Bob必败，现在问题就转换成Bob能否争取平局即可。Bob想要平局其实很简单，根据博弈论的对称性原理，采取和Alice一样的操作即可。

但是这个地方有个思维误区（D我就wa这了），就是Bob采取对称性原理的时候，Alice可以想办法破坏这个对称性原理，而且因为Alice是先手，是可以做到这一点的。

换而言之，如果后手在争取对称性平局，先手是有机会去破坏这个对称性达到胜利的。

很明显，如果类似BBCAAC这样的局面，不能无脑考虑Alice如果拿了B就可以直接拿掉B，还要考虑如果Alice如果拿了C就无法平局，换而言之就是Alice的必胜态

如果Bob想平局，只有这么一种可能，就是Alice拿左边的时候，Bob拿右边可以对称性，Alice拿右边的时候Bob拿左边可以对称性，或者剩下的全是对子（例如BBAA这样的情况）

AC1：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
const int maxn = 1e6+10;
ll ans = 0;

void solve(){
    string s;
    cin>>s;
    int i = 0;
    int j = s.size()-1;
    while(i<j){
        if(s[i]==s[j]){
            i++,j--;
        }
        else
            break;
    }
    while(i<j){
        if(s[i]==s[i+1])
            i+=2;
        else
            break;
    }

    if(i<j){
        cout<<"Alice"<<endl;
    }
    else
        cout<<"Draw"<<endl;
}

int main(){
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t = 1;
    cin>>t;
    while(t--){
        solve();
    }
}

第二种做法看一下数据范围可以想到用二维dp去做，因为每轮可选择的只有首和尾，而且具备无后效性，用区间dp一下应该就好了

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
const int maxn = 1e6+10;
ll ans = 0;
int dp[2001][2001];  //1是Alice赢，2是平局，3是Bob
string s;
int check(int l,int r,int x,int y){
    if(dp[l][r]!=2)
        return dp[l][r];//如果前一个状态不是平局的话，处于必胜态的人必定仍然能维持必胜态
    if(s[x]==s[y])
        return 2;
    if(s[x]<s[y])
        return 1;
    return 3;
}

void solve(){
    cin>>s;
    int n = s.size();
    for(int len = 2;len<=n;len+=2){
        for(int l = 0;l<=n-len;l++){
            int r = l+len-1;
            if(len==2){
                if(s[l]==s[r])
                    dp[l][r] = 2;
                else
                    dp[l][r] = 1;
                continue;
            }
            dp[l][r] = min(max(check(l+2,r,l,l+1), check(l+1,r-1,l,r)),max(check(l,r-2,r,r-1),check(l+1,r-1,r,l)));
            /*cout<<l<<" "<<r<<" "<<dp[l][r]<<endl;
            if(l==0&&r==n-1){
                cout<<check(l+2,r,l,l+1)<<" "<<check(l+1,r-1,l,r)<<" "<<check(l,r-2,r,r-1)<<" "<<check(l+1,r-1,r,l)<<endl;
            }*/
        }
    }
    if(dp[0][n-1]==1)
        cout<<"Alice"<<endl;
    else if(dp[0][n-1]==2)
        cout<<"Draw"<<endl;
    else
        cout<<"Bob"<<endl;

}

int main(){
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t = 1;
    cin>>t;
    while(t--){
        solve();
    }
}