Codeforces Round 913 (Div. 3) A~G

A.Rook(循环)

题意:

给出一个 8 × 8 8 \times 8 8×8的棋盘和一个棋子(可以任选上下左右四方向移动任意步数),问一次移动可以到达哪些格子。

分析:

使用for循环对棋子所在的行列进行遍历并输出。

代码:

#include 

typedef long long LL;
using namespace std;
const int N = 3e5 + 5;

void solve() {
    string s;
    cin >> s;
    for (int i = 1; i <= 8; i++) {
        if (s[1] - '0' != i) {
            cout << s[0] << i << endl;
        }
    }
    for (int i = 0; i < 8; i++) {
        if (s[0] - 'a' != i) {
            cout << (char)(i + 'a') << s[1] << endl;
        }
    }
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

B.YetnotherrokenKeoard(模拟)

题意:

给出一个仅包含字母的字符串,其中'B'字符为删去当前字符前的第一个大写字母,'b'字符为删去当前字符前的第一个小写字母。

问:最后剩下的字符串是什么?

分析:

使用结构体存储每个字符,同时记录字符和字符原本所在的下标,并开两个vector分别存储大小写字母,遇到大小写的b且当前对应的vector非空,就删除对应vector最后一个元素。

遍历完字符串后将两个vector中的元素放在一起排序输出即可。

hint:大小写'b'的功能仅为删除元素,不会出现在结果字符串中

代码:

#include 

typedef long long LL;
using namespace std;
const int N = 3e5 + 5;

struct Node{
    char c;
    int pos;
    bool operator < (const Node &o) const {
        return pos < o.pos;
    }
};

vector<Node> up, low, ans;

void solve() {
    string s;
    cin >> s;
    up.clear();
    low.clear();
    ans.clear();
    for (int i = 0; i < s.size(); i++) {
        if (s[i] >= 'a' && s[i] <= 'z') {
            if (s[i] == 'b') {
                if (!low.empty()) low.pop_back();
            } else {
                low.push_back(Node{s[i], i});
            }
        } else {
            if (s[i] == 'B') {
                if (!up.empty()) up.pop_back();
            } else {
                up.push_back(Node{s[i], i});
            }
        }
    }
    for (int i = 0; i < up.size(); i++) {
        ans.push_back(up[i]);
    }
    for (int i = 0; i < low.size(); i++) {
        ans.push_back(low[i]);
    }
    sort(ans.begin(), ans.end());
    for (int i = 0; i < ans.size(); i++) {
        cout << ans[i].c;
    }
    cout << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

C.Removal of Unattractive Pairs(思维)

题意:

给出一个仅包含小写字母的字符串,每次可以选择两个相邻且不同的字符删除,问经过若干次删除后,剩下的字符串的最短长度是多少?

分析:

只需要考虑出现次数最多的字符,如果其他字符加起来的数量还没有该字符的出现次数多,那么一定无法消除所有字符。

共分为以下几种情况:

  • 出现次数最多的字符的数量不大于其他所有字符的数量

    • n为奇数,由于每次只能消除2个字符,那么必然有1个字符会被剩下
    • n为偶数,可以全部删除
  • 出现次数最多的字符的数量大于其他所有字符的数量

    • 此时消耗掉所有其他字符都无法将出现次数最多的字符消除,计算剩余多少个字符即可。

代码:

#include 

typedef long long LL;
using namespace std;
const int N = 3e5 + 5;

int cnt[30];

void solve() {
    int n;
    string s;
    cin >> n >> s;
    memset(cnt, 0, sizeof (cnt));
    int maxn = -1;
    for (int i = 0; i < n; i++) {
        cnt[s[i] - 'a']++;
        maxn = max(maxn, cnt[s[i] - 'a']);
    }
    if (maxn * 2 <= n) {
        if (n % 2 == 1) cout << 1 << endl;
        else cout << 0 << endl;
    }
    else cout << n - 2 * (n - maxn) << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

D.Jumping Through Segments(二分)

题意:

在数轴上有 n n n条线,第 i i i条线段覆盖 l i ∼ r i l_i \sim r_i liri的区域,开始时站在 0 0 0点上,每次可以选择一个 0 ∼ k 0 \sim k 0k之间的数字 x x x,可以向前或向后跳跃 x x x距离。

要求:第 i i i次跳跃的落点需要在第 i i i条线段中。

问: k k k最少是多少才能保证完成所有跳跃?

分析:

可以对 k k k进行二分,每次检查时维护可以跳到的区间的最左端和最右端,然后检查能否落在下一条线段中。如果不能,那么当前 k k k不合法,否则,继续检查,并将区间约束在当前线段中。

代码:

#include 

typedef long long LL;
using namespace std;
const int N = 3e5 + 5;

int n, l[N], r[N];

bool check(int k) {
    int L = 0, R = 0;
    for (int i = 1; i <= n; i++) {
        int jump_l = L - k, jump_r = R + k;
        if (jump_l > r[i] || jump_r < l[i]) return false;
        L = max(jump_l, l[i]), R = min(jump_r, r[i]);
    }
    return true;
}

void solve() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> l[i] >> r[i];
    }
    int L = 0, R = 1e9, ans = -1;
    while (L <= R) {
        int mid = (L + R) / 2;
        if (check(mid)) {
            ans = mid;
            R = mid - 1;
        } else {
            L = mid + 1;
        }
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

E.Good Triples(思维)

题意:

给出一个非负整数 n n n,问有多少三元组 ( a , b , c ) (a,b,c) (a,b,c)满足 a + b + c = n a + b + c = n a+b+c=n d i g s u m ( a ) + d i g s u m ( b ) + d i g s u m ( c ) = d i g s u m ( n ) digsum(a) + digsum(b) + digsum(c) = digsum(n) digsum(a)+digsum(b)+digsum(c)=digsum(n)

  • d i g s u m ( i ) digsum(i) digsum(i)表示将数字 i i i十进制位上的每一个数字加在一起的结果。

分析:

a + b + c a + b + c a+b+c出现进位时,必有 d i g s u m ( a ) + d i g s u m ( b ) + d i g s u m ( c ) ≠ d i g s u m ( n ) digsum(a) + digsum(b) + digsum(c) \ne digsum(n) digsum(a)+digsum(b)+digsum(c)=digsum(n),因此,将 n n n十进制位上每个数字拆出来,单独考虑每个数字的方案,最后根据乘法原理统计答案即可。

hint:需预处理 i = a + b + c ( 0 ≤ i ≤ 9 ) i = a + b + c(0 \le i \le 9) i=a+b+c(0i9)的方案数。

代码:

#include 

typedef long long LL;
using namespace std;
const int N = 3e5 + 5;

LL cnt[15];

void solve() {
    string s;
    cin >> s;
    LL ans = 1;
    for (int i = 0; i < s.size(); i++) {
        ans *= cnt[s[i] - '0'];
    }
    cout << ans << endl;
}

int main() {
    for (int i = 0; i <= 9; i++) {
        for (int j = 0; i + j <= 9; j++) {
            for (int k = 0; i + j + k <= 9; k++) {
                cnt[i + j + k]++;
            }
        }
    }
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

F.Shift and Reverse (思维+双指针)

题意:

给一个数组 a a a,可以对数组进行如下两个操作:

  • 移位:将数组最后一个元素移动到首位,其他元素向右移动。
  • 翻转:将整个数组翻转。

询问最少需要多少次操作使得序列非递减,如果不可以输出 − 1 -1 1

分析:

如果某个位置开始连续 n n n个数字都是递增的,那么这个数字可以作为最终结果第一个位置上的数。把这个数移动到第一个位置有两种方案,一种是直接移位,一种是先翻转再移位再翻转回来。
如果某个位置开始连续 n n n个数字都是递减的,那么这个数字可以是最终结果最后位置的数,同样有两种方案,一种是先移位再翻转,一种是先翻转再移位。
分别计算两种方案的答案取最小即可。

代码:

#include 

using namespace std;
typedef long long LL;

int main() {
    const int INF = 1e9;
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> a(n * 2);
        for (int i = 0; i < n; i++)
            cin >> a[i], a[i + n] = a[i];
        int ans = INF;
        for (int i = 0; i < n; i++) {
            int j = i;
            while (j + 1 < 2 * n && a[j + 1] >= a[j])
                j++;
            for (int k = i; k <= j && k < n; k++) {
                int len = j - k + 1;
                if (len >= n) {
                    ans = min(ans, (n - k) % n);
                    int rev = n - 1 - k;
                    ans = min(ans, n - 1 - rev + 2);
                }
            }
            i = j;
        }
        for (int i = 0; i < n; i++) {
            int j = i;
            while (j + 1 < 2 * n && a[j + 1] <= a[j])
                j++;
            for (int k = i; k <= j && k < n; k++) {
                int len = j - k + 1;
                if (len >= n) {
                    ans = min(ans, (n - k) % n + 1);
                    int rev = n - 1 - k;
                    ans = min(ans, n - 1 - rev + 1);
                }
            }
            i = j;
        }
        if (ans > INF / 2)
            ans = -1;
        cout << ans << endl;
    }
}

G. Lights (图论)

题意:

n n n盏灯, n n n个开关,开关 i i i可以改变 i i i a [ i ] a[i] a[i]的状态,改变指亮变灭,灭变亮。
询问最少需要用多少开关可以关掉所有的灯。如果不可以输出 − 1 -1 1

分析:

将相关联的灯建边,每次操作都对边两端处理。可以发现这是一颗基环树,也就是说:在非环上的点可以按照拓扑序来唯一的去处理(要么 1 1 1 0 0 0,同时另一端也变化,要么不变)。现在就只剩下环上的一部分了,可以发现若环上剩余亮着的灯是奇数的话那么就不能全部熄灭了。
接下来考虑环,若环上某一条边的操作已经确定下来了(变或者不变),那么其余所有边操作都确定了。将所有边操作分为两类表示,对其中一类中的每一条边操作后,如果整个环都能变成 0 0 0那么就是合法的。最后比较两类边集大小考虑输出哪一类即可。分别计算两种情况取最小即可。

代码:

#include 

using namespace std;
typedef long long LL;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        string s;
        cin >> s;
        vector<int> a(n + 5, 0), degree(n + 5, 0), f(n + 5, 0), g(n + 5, 0), del(n + 5, 0);
        for (int i = 0; i < n; i++) {
            if (s[i] == '1')
                f[i + 1] = 1;
        }
        for (int i = 1; i <= n; i++) {
            int v;
            cin >> v;
            degree[v]++;
            g[i] = v;
        }
        queue<int> q;
        vector<int> ans;
        for (int i = 1; i <= n; i++) {
            if (!degree[i]) {
                q.push(i);
            }
        }
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            int v = g[u];
            degree[v]--;
            if (f[u])
                f[v] ^= 1, ans.push_back(u);
            if (!degree[v])
                q.push(v);
        }
        int flag = 0;
        for (int i = 1; i <= n; i++) {
            if (degree[i]) {
                q.push(i);
                vector<int> tmp;
                int cnt = 0, t = 0, res = 0;
                while (!q.empty()) {
                    int u = q.front();
                    q.pop();
                    tmp.push_back(u);
                    degree[u] = 0;
                    int v = g[u];
                    if (f[u])
                        t ^= 1;
                    res += t;
                    if (degree[v])
                        q.push(v);
                }
                if (t) {
                    flag = 1;
                    break;
                }
                if (flag)
                    break;
                cnt = tmp.size();
                t = 0;
                if (res < cnt - res) {
                    for (auto x: tmp) {
                        if (f[x])
                            t ^= 1;
                        if (t)
                            ans.push_back(x);
                    }
                } else {
                    for (auto x: tmp) {
                        if (f[x])
                            t ^= 1;
                        if (!t)
                            ans.push_back(x);
                    }
                }
            }
        }
        if (flag == 0) {
            cout << ans.size() << endl;
            for (auto x: ans)
                cout << x << " ";
            cout << endl;
        } else
            cout << "-1" << endl;
    }
    return 0;
}

学习交流

以下为学习交流QQ群,群号: 546235402,每周题解完成后都会转发到群中,大家可以加群一起交流做题思路,分享做题技巧,欢迎大家的加入。

Codeforces Round 913 (Div. 3) A~G_第1张图片

你可能感兴趣的:(codeforces题解,算法,信息学奥林匹克,ACM-ICPC,OI,Codeforces)