Codeforces Round #818 (Div. 2)A-D

Dashboard - Codeforces Round #818 (Div. 2) - CodeforcesCodeforces. Programming competitions and contests, programming communityhttps://codeforces.com/contest/1717

A. Madoka and Strange Thoughts

打表找规律，发现数差是333151这样一个恒定的。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5+10;
int bit[maxn];
#define ll long long

int GCD(int a, int b) {
    return b ? GCD(b, a % b) : a;
}

int LCM(int a, int b) {
    return a * b / GCD(a, b);
}

void solve() {
    int n,ans;
    cin>>n;
    ans = 1;
    ans+=(n-1)/6*16;
    if((n-1)%6<=3)
        ans+=((n-1)%6)*3;
    else if((n-1)%6==4)
        ans+=10;
    else{
        ans+=15;
    }
    cout<<ans<<endl;
}

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

B. Madoka and Underground Competitions

只管横竖的数独题，那我们把NxN的矩阵切割成MxM然后对每个MxM进行相同的数独填写即可，构造就是比如 3x3的部分 要求3 2有X，那么我们让3 2 有X，同时 2 3也有 其他部分x = y才放X

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5+10;
int bit[maxn];
#define ll long long

int GCD(int a, int b) {
    return b ? GCD(b, a % b) : a;
}

int LCM(int a, int b) {
    return a * b / GCD(a, b);
}
int n,m,r,c;
char ans[501][501];
void solve() {
    cin>>n>>m>>r>>c;
    r = r%m;
    if(r==0)
        r = m;
    c = c%m;
    if(c==0)
        c = m;
    for(int i = 1;i<=n;i++){
        int a = i%m;
        if(a==0)
            a = m;
        for(int j = 1;j<=n;j++){
            int b = j%m;
            if(!b)
                b = m;
            if(a==c){
                if(b==r)
                    cout<<"X";
                else
                    cout<<".";
            }
            else if(a==r){
                if(b==c)
                    cout<<"X";
                else
                    cout<<".";
            }
            else{
                if(a==b)
                    cout<<"X";
                else
                    cout<<".";
            }
        }
        cout<<endl;
    }
}

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

C. Madoka and Formal Statement

主要关键就是考虑到这个影响具有无后效性！即下标为1的情况可以只考虑下标为2的情况

有个思维陷阱就是觉得下标2的位置会被后面影响从而反过来影响下标1，但是事实上我们的目的是让ai = bi，如果下标2会被后面影响说明它到不了bi，即会失败，自然不用考虑反过来影响下标1的情况了。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5+10;
int bit[maxn];
#define ll long long

int a[maxn],b[maxn];
int n;
void solve() {
    cin>>n;
    for(int i = 1;i<=n;i++)
        cin>>a[i];
    for(int i = 1;i<=n;i++)
        cin>>b[i];
    for(int i = 1;i<=n;i++){
        if(a[i]>b[i]){
            cout<<"No"<<endl;
            return;
        }
        if(a[i]!=b[i]){
            int tar = i%n;
            if(b[i]>b[tar+1]+1){
                cout<<"No"<<endl;
                return;
            }
        }
    }
    cout<<"Yes"<<endl;
}

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

D. Madoka and The Corruption Scheme

简单来说就是一个对战表，然后A提前订好了每场比赛是左边赢还是右边赢，这个时候B可以去修改左右位置，问最终获胜者可能是几个人?(很难读的题意)

其实如果反过来思考就不难，如果我们从根出发，如果这一轮是左边赢那么我们走左边，反之走右边，最终走到的叶子就是胜者，也就是说其实如果我们不修改的话，由于路线是固定的，最终胜者其实只和n(高度)个回合相关，如果我们修改了，那么将走不同的路线。

那其实枚举修改1次，修改2次，修改3次。。。k次的总情况数就好了，由于其二叉树同时叶节点不同，最终访问到的叶子节点代表不同的情况，用组合数算一下就好了。

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10,mod=1e9+7;
int n,k,prd[N],ipr[N];
int C(int n,int m){
    return 1ll*prd[n]*ipr[m]%mod*ipr[n-m]%mod;
}
long long qpow(long long base, long long power) {
    long long result = 1;
    while (power > 0) {
        if (power & 1) {//此处等价于if(power%2==1)
            result = result * base % mod;
        }
        power >>= 1;//此处等价于power=power/2
        base = (base * base) % mod;
    }
    return result;
}

int main(){
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    cin>>n>>k;
    if(k>=n){
        cout<<qpow(2,n);
        return 0;
    }
    prd[0]=1;
    for(int i=1;i<=n;++i)
        prd[i]=1ll*prd[i-1]*i%mod;
    ipr[n]=qpow(prd[n],mod-2);
    for(int i=n-1;i>=0;--i){
        ipr[i]=1ll*ipr[i+1]*(i+1)%mod;
    }
    int ans=1;
    for(int i=1;i<=k;++i)
        ans=(ans+C(n,i))%mod;
    cout<<ans;
}