Harbour.Space Scholarship Contest 2021-2022 (open for everyone, rated, Div. 1 + Div. 2)(补题)

Posted 2021-08-27 佐鼬Jun

B. Reverse String

题意： 字符串s，先定一个位置，先往右走(x步，x>=0)，停下来后，再往左走(y步,y>=0)，走过的路径会写出一个字符串，问能不能形成字符串t
思路： 直接暴力找就可以，原题起点的位置是先定再往右走，再往左走。
可以直接从第一个单字符往右走，再往左走回来。如果这样暴力形成的大字符串的子串如果有字符串t，说明是可以形成的。因为暴力向右走的终点和原题向右走的终点是一样的，暴力向左走的终点明显覆盖了原题向左走的终点，所以就看字符串t是不是，暴力字符串x的子串就行。
（**顺便学一波substr和find函数 **）
也可以像这位大佬一样用区间dp的思维来暴力写。链接放在下面
链接: link.

#include <bits/stdc++.h>
using namespace std;
string s, t, x;
int flag;
void check(string y) {
    if (y.find(t) != y.npos) {
        flag = 1;
    }
}
int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        cin >> s >> t;
        flag = 0;
        int len = s.size();
        for (int i = 1; i <= len; i++) {
            x = s.substr(0, i);
            reverse(x.begin(), x.end());
            check(s.substr(0, i) + x.substr(1, x.size() - 1));
            if(flag) break;
        }
        if (flag)
            puts("YES");
        else
            puts("NO");
    }
    return 0;
}

C. Penalty

题意： 点球大战，奇数场我方点球，偶数场对方点球，1代表必进，0代表必不进，？代表不清楚，当双方比分悬殊（一方的分数高到另一方每场都进，也赢不了）就结束比赛，后者打满10场结束比赛。
思路: 总共10次点球，直接模拟就行，让其中一方分数高（那以放的?都进，另一方的?都不进），看何时能结束比赛，两方都试一下，看取结束时间最小值。
注意： 裁判是不知道每个人是否会进球的，他只会看比分是否悬殊（一方的分数高到另一方每场都进，也赢不了）

#include <bits/stdc++.h>
using namespace std;
char s[20];
int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        scanf("%s", s);
        int a = 0, b = 0;
        int i = 0;
        for (i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                if (s[i] == '1' || s[i] == '?') {
                    a++;
                }
            } else {
                if (s[i] == '1') {
                    b++;
                }
            }
            int c = b;
            for (int j = 9; j > i; j -= 2) {
                if (j % 2 == 1) {
                    c++;
                }
            }
            if (a > c) break;
        }
        int j = 0;
        int c = 0, d = 0;
        for (j = 0; j < 10; j++) {
            if (j % 2 == 0) {
                if (s[j] == '1') {
                    c++;
                }
            } else {
                if (s[j] == '1' || s[j] == '?') {
                    d++;
                }
            }
            int q = c;
            for (int k = 8; k > j; k -= 2) {
                if (k % 2 == 0) {
                    q++;
                }
            }
            if (d > q) break;
        }
        printf("%d\\n", min({i + 1, j + 1, 10}));
    }
    return 0;
}

D. Backspace

题意： 一个字符串s和一个字符串x，从第一个位置开始，你可以选择删除x的最后一个字符串（用了删除就代表不能输入s当前位置的单字符了）并到下一个位置，也可以选择输入s当前位置的单字符到x，问能否通过上述操作，得到字符串t。
思路： 得到字符串t，是从前往后遍历，并选择那两个选择的。到要判断字符串s能否得到字符串t，就要从后往前遍历（恶心在这儿，想了半天 ）。因为如果从前往后遍历的话，s和t不匹配时，会说明三个问题
1.要么是下一步操作选择了删除操作，导致当前这个s位置的单字符被删除了
2.要么就是当前位置选择了删除操作，从而没输入当前s位置的单字符
3.要么就是前面就匹配错了
很显然非常不好判断，再加上字符串长度很长，要尽量减少时间复杂度
换个思考方式，从后往前遍历。
如果从后往前遍历，s和t不匹配时，只说明一个问题：
1.就是s当前位置没输入（使用了删除操作），这样就会导致s的前一个位置是输入过数据的，但被当前的删除操作给删掉了，所以s的前一个位置直接不用看（跳过）
这也就是代码中，当发生不匹配时，要往前走两格的含义。
匹配过程用双指针即可

#include <bits/stdc++.h>
using namespace std;
string s, t;

int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        cin >> s >> t;
        int lens = s.size();
        int lent = t.size();
        int now = t.size() - 1;
        for (int i = lens - 1; i >= 0; i--) {
            if (now >= 0 && s[i] == t[now]) {
                now--;
            } else {
                i--;
            }
        }
        if (now == -1) {
            puts("YES");
        } else {
            puts("NO");
        }
    }
    return 0;
}

To be continued
如果你有任何建议或者批评和补充，请留言指出，不胜感激