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

A

给你两个数，问在两个数闭区间范围内的任意两个数之间取模的最大值

显然如果想最大，那么相对较大的数要大，较小的那个数在较大的数一半的右侧，这里讨论一下 $l$ 的位置，如果他已经在右面了就直接输出差值或者模均可

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <map>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 100;
const int INF = 0x3f3f3f3f;
int Data[MAXN];
int main(){
    
    
    #ifdef LOCAL
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    ios::sync_with_stdio(false);
    int t, n, l, r;
    cin >> t;
    while(t--){
    
    
        cin >> l >> r;
        int k;
        k = (r / 2) + 1;
        if(l <= k){
    
    
            cout << r % k << '\n';
        }else{
    
    
            cout << r % l << '\n';
        }
    }
    return 0;
}

B

给你一个数，可以删掉若干位，问你最多删掉多少位能让剩下的数字变成一个非质数

显然如果有某一位是非质数，那么就剩下他自己就好，如果所有位置全是质数，那么有这几种情况， $2, 3, 5, 7$ ，题目保证一定有解，那么这些数字任意两个组合起来都不是质数（类似 $23$ 这种情况属于无解的情况，不存在的）
所以这种情况下只要看任意两个数组合起来是不是非质数即可

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 100;
const double eps = 1e-6;
int a[MAXN];
int vis[MAXN];
int p[MAXN];
int Prime(){
    
    
    int tot = 0;
    for(int i=2;i<=100;i++){
    
    
        if(!vis[i]) p[tot++] = i;
        for(int j=0;j<tot&&i*p[j]<=100;j++){
    
    
            vis[i*p[j]] = 1;
            if(i % p[j] == 0) break;
        }
    }
    return tot;
}
int main(){
    
    
    #ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t, k, n;
    int len = Prime();
    cin >> t;
    string s;
    while(t--){
    
    
        cin >> n >> s;
        bool f = false;
        for(int i=0;i<n;i++){
    
    
            int pos = lower_bound(p, p + len, s[i] - '0') - p;
            if(p[pos] != s[i] - '0'){
    
    
                f = true;
                cout << 1 << '\n';
                cout << s[i] - '0' << '\n';
                break;
            }
        }
        if(f) continue;
        for(int i=0;i<n;i++){
    
    
            int num = s[i] - '0';
            num *= 10;
            for(int j=i+1;j<n;j++){
    
    
                num += s[j] - '0';
                int pos = lower_bound(p, p + len, num) - p;
                if(p[pos] != num){
    
    
                    cout << 2 << '\n';
                    cout << num << '\n';
                    f = true;
                    break;
                }
                num -= s[j] - '0';
            }
            if(f) break;
        }
    }
    return 0;
}

C

给你一组 $01$ 串，设从 $l$ 到 $r$ 这段组成一个二进制数，让你找两段二进制数，满足前一个是后一个的 $k$ 倍， $k$ 是一个非负数，且满足 $r-l+1\geq \lfloor \frac{n}{2}\rfloor$

找 $0$ 的位置，如果没有 $0$ ，那么只要随便找两个相等的数即可，如果有 $0$ ，如果位置在左面一半，那么找两个数从当前一直到末尾即可，否则就是从 $1$ 到当前位置，不细说了，很简单

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <map>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 100;
const int INF = 0x3f3f3f3f;
int Data[MAXN];
int main(){
    
    
    #ifdef LOCAL
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
    ios::sync_with_stdio(false);
    int t, n;
    string s;
    cin >> t;
    while(t--){
    
    
        cin >> n >> s;
        int k = (n >> 1);
        bool f = false;
        for(int i=0;i<n;i++){
    
    
            if(s[i] == '0'){
    
    
                if(i >= k){
    
    
                    cout << 1 << ' ' << i + 1 << ' ' << 1 << ' ' << i << '\n';
                    f = true;
                    break;
                }else{
    
    
                    cout << i + 1 << ' ' << n << ' ' << i + 2 << ' ' << n << '\n';
                    f = true;
                    break;
                }
            }
        }
        if(!f){
    
    
            cout << 1 << ' ' << k << ' ' << 2 << ' ' << k + 1 << '\n';
        }
    }
    return 0;
}

D

给出了一个公式和一个字符串， $+$ 表示 $1$ ， $-$ 表示 $- 1$ ，问在给定的一段区间内至少去掉多少个字符才能保持这段区间内的符号所对的公式值为 $0$

我们先维护一个前缀和 $s u m$ ，如果这段区间对应的值已经是 $0$ ，那么就不需要修改了
如果不是，考虑删除位置 $i$ 以后，整个序列的答案，删除位置 $i$ 以后，他前面的部分不变，但是后面的部分变成了原来的相反数，也就是现在序列变成了 $s u m [r] - s u m [i] - (s u m [i - 1] - s u m [l - 1])$ 也就是 $s u m] r] + s u m [l - 1] - s u m [i] - s u m [i - 1]$ 如果想让这个值为 $0$ ，那么应该有 $s u m [r] + s u m [l - 1] = s u m [i] + s u m [i - 1]$ 而我们已知的是 $r, l$ ，也就是说唯一不知道的值只是 $i$ ，而我们知道 $s u m [i]$ 和 $s u m [i - 1]$ 之间一定是差 $1$ 的，所以右侧一定是个奇数，那么考虑一下，如果 $r - l + 1$ 是奇数，那么左面就变成了奇数，两侧有可能相等，那么如何寻找这个方案呢？
其实我们可以预处理出来 $s u m [i] + s u m [i - 1]$ 所对应的所有 $i$ 值记录下来放到一个桶里面，然后对 $s u m [r] + s u m [l - 1]$ 这个标号的桶进行二分查找，找的一个大于 $l$ 的数，也就是第几个元素，即 $i$ 值
如果 $i - l + 1$ 是偶数，那么可以先把最左面的元素删去，让它变成刚才讨论的情况 $1$
那么为什么 $n$ 为i奇数时，必然能够找到一个位置满足情况呢？设 $f (i)$ 表示去掉 $i$ 之后的值，那么有 $f (1) = - (s u m [n] - a [1]) = a [1] - s u m [n]$ $f (n) = s u m (n) - a [n]$ 这其中能够影响到函数正负的是 $s u m$ ，所以 $f(1)\times f(n)\leq 0$ ，因为函数连续，这说明在这中间一定存在一个数 $i$ 使得函数值为 $0$ ，这样就印证了刚才的唯一性结论

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <iomanip>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 100;
const double eps = 1e-6;
int a[MAXN];
int sum[MAXN];
int main(){
    
    
    #ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t, n, q, l, r;
    string s;
    cin >> t;
    while(t--){
    
    
        cin >> n >> q;
        cin >> s;
        int num = 1, op;
        unordered_map<int, vector<int> > mp;
        for(int i=1;i<=n;i++){
    
    
            if(s[i - 1] == '+') op = 1;
            else op = -1;
            sum[i] = op * num + sum[i - 1];
            num *= -1;
            mp[sum[i] + sum[i - 1]].push_back(i);
        }
        while(q--){
    
    
            cin >> l >> r;
            if(sum[r] - sum[l - 1] == 0) cout << 0 << '\n';
            else{
    
    
                if((l & 1) ^ (r & 1)){
    
    
                    cout << 2 << '\n';
                    cout << l++ << ' ';
                }else {
    
    
                    cout << 1 << '\n';
                }
                auto &v = mp[sum[r] + sum[l - 1]];
                cout << *lower_bound(v.begin(), v.end(), l) << '\n';
            }
        }
    }
    return 0;
}

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

A

B

C

D

猜你喜欢