Educational Codeforces Round 102 (Rated for Div. 2) A~D题

写在前边

链接：Educational Codeforces Round 102 (Rated for Div. 2)

第一场打CF，过了AB两题，不过速度挺慢，C题属实没看懂，D题写了个常规做法之后TLE了还剩下几分钟就睡觉了，想到了用前缀和但是确实不知道该怎么写，最近的目标就先上1400吧。

A. Replacing Elements

链接：A题链接

题目大意:

给定一个数组a, 你可以选任意不同的三个下标\(i\), \(j\), \(k\)， 进行操作\(a_i=a_j+a_k\)，问经过若干次操作之后是否能使得数组中的数\(a_i\)都小于等于\(d\)。

思路：

一开始在场上想的是模拟一遍整个过程，最后再检查一下是否合适，看了题解之后根本不用那么麻烦，只需要检查一下数组元素的最大值是否小于等于\(d\)，或者最小的两个数相加是否小于等于\(d\)即可，若最大元素小于\(d\)那么整个数组就符合条件，若最小的两个数相加小于等于\(d\)，那么他们的和一定可以覆盖所有比\(d\)大的数，解决。

代码:

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int t, n, d, a[N];

int main() {
    cin >> t;
    while (t--) {
        cin >> n >> d;
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        sort(a, a + n);
        cout << ((a[0] + a[1] <= d || a[n - 1] <= d) ? "YES" : "NO") << endl;
    }

    return 0;
}

B. String LCM

链接：B题链接

题目大意:

找两个字符串的"最小公倍数"即\(LCM(s, t)\)， 例如\(s = "baba"\), \(t = "ba"\), 那么\(LCM(s, t) = "baba"\)，因为\("baba"*1 = "ba" * 2\)， \(s = "aaa"\), \(t = "aa"\), 那么\(LCM(s, t) = "aaaaaa"\)，因为\("aaa" * 2 = "aa" * 3\)。

思路：

先求\(GCD(s, t)\)，再求\(LCM(s, t)\)。

1. 求\(GCD(s, t)\)，它一定是字符串的一个前缀，因此可以枚举所有的前缀，再判断某个前缀变成原来的几倍是否能变成\(s,t\)，若可以那么就是\(GCD(s, t)\)。
2. 有了\(GCD\)再求\(LCM\)那就是很简单的事了，看代码即可。

代码:

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

typedef long long ll;

int gcd(int a, int b) {
    while (b != 0) {
        a %= b;
        swap(a, b);
    }
    return a;
}

bool check(string s, string x) {
    string temp = "";
    for (int i = 0; i < s.size(); i++) {
        temp += x;
        if (temp == s) {
            return true;
        }
    }
    return false;
}

string gcd_str(string s, string t) {
    string res = "";
    int lens = s.size(), lent = t.size();
    for (int i = min(lens, lent); i >= 1; i--) {
        if (lens % i == 0 && lent % i == 0) {
            string x = s.substr(0, i);
            if (check(s, x) && check(t, x)) {
                return x;
            }
        }
    }
    return "";
}

int main() {
    int n;
    cin >> n;
    while (n--) {
        string s, t, gcd_st, res = "";
        cin >> s >> t;
        gcd_st = gcd_str(s, t);
        if (gcd_st == "") {
            puts("-1");
            continue;
        }
        int len_gcdst = gcd_st.size();
        int len_lcmst = (s.size() / gcd_st.size()) * (t.size() / gcd_st.size());

        for (int i = 0; i < len_lcmst; i++) {
            res += gcd_st;
        }
        cout << res << endl;
    }

    system("pause");
    return 0;
}

优化：可以用数学的方法求\(GCD(s, t)\)进行优化，使代码更短，效率更高。

首先判断两个字符串是否存在\(GCD(s, t)\)可以利用更简单的方法，即 \(s + t\) 是否等于 \(t + s\)，若存在\(GCD\)，那么\(s + t == t + s\)，否则就不存在。那证明一下：

如果他们有公因子"abc"，那么\(s\)就会有\(m\)个\("abc"\)重复，\(t\)就会有\(n\)个\("abc"\)重复，因此:

\[s + t = m * "abc" + n * "abc" = (m + n) * "abc"
\]

而：

\[t + s = n * "abc" + m * "abc" = (n + m) * "abc"
\]

得：\((m + n) * "abc" = (n + m) * "abc"\)，因此\(s + t = t + s\)。

那在有解的情况下，最优解的长度就是\(gcd(s.size(), t.size())\)，如果我们能循环以它的约数为长度的字符串，自然也能循环以它为长度的字符串。

证明不周，详细证明看leetcode 1071. 字符串的最大公因子。

因此优化后的代码：

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

typedef long long ll;

int gcd(int a, int b) {
    while (b) {
        a %= b;
        swap(a, b);
    }
    return a;
}

string gcd_str(string s, string t) {
    if (s + t != t + s) return "";
    return s.substr(0, gcd(s.size(), t.size()));
}

int main() {
    int n;
    cin >> n;
    while (n--) {
        string s, t, gcd_st, res = "";
        cin >> s >> t;
        gcd_st = gcd_str(s, t);
        if (gcd_st == "") {
            puts("-1");
            continue;
        }
        int len_gcdst = gcd_st.size();
        int len_lcmst = (s.size() / gcd_st.size()) * (t.size() / gcd_st.size());

        for (int i = 0; i < len_lcmst; i++) {
            res += gcd_st;
        }
        cout << res << endl;
    }

    return 0;
}

C. No More Inversions

链接：C题链接

题目大意:

给定一个序列\(a\):\(1, 2, 3, ..., k-1,k, k-1, k-2, ...k - (n - k)\), 要求构造一个长度为\(k\)的排列\(p\)，然后通过\(p\)构造出\(b[i] = p[a[i]]\)，要求\(b\)中的逆序对数量不得多于\(a\)中逆序对的数量，并且要求\(b\)的字典序在所有合法方案中最大。

思路：

当时没看懂，今天下午又肝了一下午，看了很多博客才懂了。

首先从\(b[i] = p[a[i]]\)出发，其实就是\(a\)数组用来做\(p\)的下标了，并且若\(p\)数组中是有序的，那么映射后的\(b\)数组是跟\(a\)数组一模一样的。

例如：\(a[] = {1, 2, 3, 4, 5, 4, 3}\), \(p[] = {1, 2, 3, 4, 5}\), 那么\(b[] = {1, 2, 3, 4, 5, 4, 3}\)。

若p数组中有两个数调换位置，那么相应的b数组中对应的数也交换，例如\(p[] = {1, 2, 3, 5, 4}\)，那么b数组中的4和5也相应的发生对换，变成\(b[] = {1, 2, 3, 5, 4, 5, 3}\)，很神奇。

然后就再找规律发现，我们通过\(p\)数组改变\(b\)数组的时候，动的如果是\(a\)数组对称的那部分，那么逆序对的数量是不会发生变化的，例如上边对称的部分就是\({3, 4, 5, 4, 3}\)，若改变\(p\)使得\(p\)变为\(p[] = {1, 2, 4, 3, 5}\), 则对称部分就变成了就变成了\({4, 3, 5, 3, 4}\)，逆序对的数量仍然没有变化，若改变了前面不对称的部分，那么逆序对就会比\(a\)多。

最后我们就可以在上边的基础上让\(b\)的字典序尽量的大，那么就把\(p\)的大数换到对称部分的最前边即可\(p[] = {1, 2, 5, 4, 3}\)，此时\(b[] = {1, 2, 5, 4, 3, 4, 5}\)

至此，solve it!

代码:

#include <iostream>

using namespace std;

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, k;
        cin >> n >> k;
        int t1 = n - k;
        int t2 = k - t1 - 1;
        for (int i = 1; i <= t2; i++) {
            cout << i << " ";
        }
        for (int i = k; i > t2; i--) {
            cout << i << " ";
        }
        cout << endl;
    }

    return 0;
}

D. Program

链接：D题链接

题目大意:

\(x\)的初值为\(0\)，给定一个字符串由\(+\),\(-\)组成，分别使\(x\)加减\(1\)，加下来由\(m\)次操作，每次给定\(l，r\),表示将\(l-r\)（包括\(l、r\)端点）长度的\(+、-\)操作屏蔽，求屏蔽后\(x\)会有多少个不同的值。

思路：

首先明白一点，对于这个题而言，因为一次操作\(x\)只能变化\(1\)，因此一个区间内\(x\)取得的最大值与最小值之差加\(1\)，那么就是\(x\)所取得的不同的值，因此我们需要维护一下这个最大值与最小值。

然后访问的时候，删除\(l、r\)之间的操作后，也就意味着我们不进行这段操作，那我们就需要对上边维护的值进行弥补，那么怎么进行弥补呢，就是\(l - r\)期间\(x\)变化的值加到后边，再判断一种很简单的理解方法就是，对于\(x\)的变化画成一个一个图，中间切开，然后把两边接起来，看下图，中间蓝色切开，再接起来。



然后就变成了这样。



那什么叫"弥补"呢？就是原来蓝色区间中x的值是上升了，但是若删除蓝色区间操作，那么\(x\)的就直接把后边的的折线拉下来了，即\(x\)没有了那段上升操作，即从前一段的重点到后一段的起点，因此，对于前段，不管怎么删除都不受影响，后段会受影响，因此维护最值得时候对于后段给给予"补偿"即可，即后段会减去\(x\)的变化，因此对于前段，我们从前往后维护，对于后段从后往前维护即可，最后最大值就是前段与后段接起来后的最大值，同理也求得最小值，最后作差 + 1得到\(x\)的变化。

代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 2e5 + 10;
char s[N];
int maxpre[N], minpre[N], maxtail[N], mintail[N];
int a[N], sum[N];

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, m;
        cin >> n >> m;
        cin >> s + 1;
        for (int i = 1; i <= n; i++) {
            if (s[i] == '+') {
                a[i] = 1;
            } else {
                a[i] = -1;
            }
            sum[i] = sum[i - 1] + a[i];
            maxpre[i] = max(maxpre[i - 1], sum[i]);
            minpre[i] = min(minpre[i - 1], sum[i]);
        }
        maxtail[n + 1] = -1e9, mintail[n + 1] = 1e9;
        for (int i = n; i >= 1; i--) {
            maxtail[i] = max(maxtail[i + 1], sum[i]);
            mintail[i] = min(mintail[i + 1], sum[i]);
        }
        for (int i = 0; i < m; i++) {
            int l, r;
            cin >> l >> r;
            int temp = sum[r] - sum[l - 1];
            int maxN = max(maxpre[l-1], maxtail[r + 1] - temp);
            int minN = min(minpre[l-1], mintail[r + 1] - temp);
            cout << maxN - minN + 1 << endl;
        }
    }
    system("pause");
    return 0;
}