Educational Codeforces Round 63 (Rated for Div. 2)题解

A. Reverse a Substring

给出一个字符串，现在可以对这个字符串进行一次翻转，问是否存在一种方案，可以使得翻转后字符串的字典序可以变小。

这个很简单，贪心下就行了。

代码如下：

Code

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 3e5 + 5;

int n;

char s[N] ;

int main() {

    cin >> n;

    scanf("%s",s + 1) ;

    int pos1, pos2 = -1;

    int mx = 0;

    for(int i = 1; i <= n; i++) {

        if(s[i] - 'a' + 1 >= mx) {

            mx = s[i] - 'a' + 1;

            pos1 = i;

        } else {

            pos2 = i;

            break ;

        }

    }

    if(pos2 == -1) puts("No") ;

    else {

        puts("YES") ;

        cout << pos1 << ' ' << pos2 ;

    }

    return 0;

}

B. Game with Telephone Numbers

给出一个数字序列，长度为n，满足\(13\leq n\leq 10^5\)，并且保证长度为偶数。并且给出电话号码的定义：长度为11并且首位为8。

现在两个人，每个人选择一个数删去。现在问先手是否有必胜策略。

因为保证了\(n\)为偶数，所以我们可以知道每个人的操作次数，假设每个人可以操作\(k\)次。那么我们就只需要看前\(2*k+1\)个字符就行了，统计一下8的数量就ok了。

具体见代码吧：

Code

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 3e5 + 5;

int n;

char s[N] ;

int main() {

    cin >> n;

    scanf("%s",s + 1) ;

    int remain = (n - 11) / 2;

    int cnt1 = 0, cnt2 = 0;

    for(int i = 1; i <= 2 * remain; i++) {

        if(s[i] == '8') cnt1++ ;

        else cnt2++;

    }

    if(cnt1 > remain) puts("YES") ;

    else if(cnt1 == remain && s[2 * remain + 1] == '8') puts("YES") ;

    else puts("NO") ;

    return 0;

}

C. Alarm Clocks Everywhere

给出\(n\)个数的位置，每个数的位置为\(x_i\)，\(m\)个间隔，分别为\(p_i\)。现在问是否可以从这些间隔里面选出一个\(p_i\)出来，现在还随意选出一个起点，问这样是否可以遍历所有的位置。

比如选择了一个起点\(s\)，假设间隔为\(v\)，那么就会遍历\(s,s+v,\cdots,s+v*k\)。

求出所有间隔的gcd就行了，最后依次枚举每个间隔，判断一下就行了。

代码如下:

Code

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 3e5 + 5;

ll a[N];

int n, m;

int main() {

    ios::sync_with_stdio(false); cin.tie(0);

    cin >> n >> m;

    ll d = 0;

    for(int i = 1; i <= n; i++) {

        cin >> a[i] ;

        if(i != 1) d = __gcd(d, a[i] - a[i - 1]) ;

    }

    ll x;

    int ans = -1;

    for(int i = 1; i <= m; i++) {

        cin >> x;

        if(d % x == 0) {

            ans = i;

        }

    }

    if(ans == -1) cout << "NO"  ;

    else {

        cout << "YES" << '\n';

        cout << a[1] << ' ' << ans ;

    }

    return 0;

}

D. Beautiful Array

给出\(n\)个数，每个数为\(a_i\)，满足\(1\leq n\leq 3*10^5,-10^9\leq a_i\leq 10^9\)。同时给出一个数\(x\)，满足\(-100\leq x\leq 100\)。

现在可以选出一个区间\([l,r]\)，之后对这个区间中的每一个数都乘以一个\(x\)。

询问在至多执行了一次操作过后，这\(n\)个数的最大连续子段和为多少。

额，这个题我一开始以为就是贪心...结果贪遭了，大部分时间就搭进去了。最后发现其实一个简单dp(?)就行了。。。反正我看过题解之后感觉挺简单的。

因为只能最多执行一次操作，所以最后整个区间会被分为三段或者一段。定义\(dp(i,j)\)表示当前第\(i\)个数，且处于第\(j\)段中时，前\(i\)个数的最大连续子段和，这里\(0\leq j\leq 2\)。这里中间那段就是被改变的区间，前面、后面都是没有改变的。之后根据这个来转移就行了。

因为我的转移中只有新开一段和延续之前这两种情况，所以最后还需要枚举一下来维护答案。因为最后的答案不一定会延续到最后一位。

详细见代码吧：

Code

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 3e5 + 5;

int n ;

ll x;

ll a[N] ;

ll dp[N][3] ;

int main() {

    ios::sync_with_stdio(false); cin.tie(0);

    cin >> n >> x;

    for(int i = 1; i <= n; i++) cin >> a[i] ;

    for(int i = 1; i <= n; i++) {

        dp[i][0] = max({a[i], dp[i - 1][0] + a[i]}) ;

        dp[i][1] = max({dp[i - 1][0] + a[i] * x, dp[i - 1][1] + a[i] * x, a[i] * x}) ;

        dp[i][2] = max({dp[i - 1][1] + a[i], dp[i - 1][2] + a[i], a[i]});

    }

    ll ans = 0;

    for(int i = 1; i <= n; i++)

        ans = max({ans, dp[i][0], dp[i][1], dp[i][2]}) ;

    cout << ans ;

    return 0;

}

E. Guess the Root

这是一个交互题。

给出一个函数\(f(x)=a_0+a_1*x+a_2*x^2+\cdots+a_k*x^k\)，其中\(0\leq a<10^6+3,k\leq 10\)。

之后你最多有50次询问，给出一个\(x_0\)，最后会给出回答\(f(x_0)\mod 10^6+3\)。之后要求你输出一个\(x_0\)，满足\(f(x0)\mod 10^6+3\)。

由于这里的\(k\)很小，所以我们可以直接询问11次，然后就会有11个方程，因为题目保证有解，所以直接高斯消元就好啦，可以直接把\(a_0,a_1,\cdots,a_k\)给求出来。

之后枚举\(x\)从\(0\)到\(10^6+2\)就行了，为啥不往后面枚举呢，因为有取余，往后面枚举是没必要的。如果满足条件就直接输出，最后发现没有满足条件的数，直接输出\(-1\)就好了。

代码如下：

Code

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N = 15, MOD = 1e6 + 3;

ll a[N][N], b[N];

ll qp(ll A, ll B) {

    ll ans = 1;

    while(B) {

        if(B & 1) ans = ans * A % MOD;

        A = A * A % MOD;

        B >>= 1;

    }

    return ans ;

}

void gauss() {

    for(int i = 0; i < 11; i++) {

        ll t = qp(a[i][i], MOD - 2) ;

        for(int j = 0; j < 12; j++)

            a[i][j] = a[i][j] * t % MOD;

        for(int j = 0; j < 11; j++) {

            ll c = a[j][i] ;

            if(i != j && a[j][i])

                for(int k = 0; k < 12; k++)

                    a[j][k] = ((a[j][k] - a[i][k] * c % MOD) % MOD + MOD ) % MOD;

        }

    }

}

ll f(ll x) {

    ll ans = 0;

    for(int i = 10; i >= 0; i--) {

        ans = (ans * x + b[i]) % MOD ;

    }

    return ans ;

}

int main() {

    for(int i = 0; i < 11; i++)

        for(int j = 0; j < 11; j++)

            a[i][j] = qp(i, j) ;

    for(int i = 0; i < 11; i++) {

        printf("? %d\n", i);

        fflush(stdout) ;

        scanf("%d", &a[i][11]) ;

    }

    gauss() ;

    for(int i = 0; i < 11; i++) b[i] = a[i][11] ;

    for(int i = 0; i < MOD; i++) {

        if(f(i) == 0) {

            printf("! %d",i) ;

            return 0;

        }

    }

    printf("! -1") ;

    return 0 ;

}