Educational Codeforces Round 163 Editorial

B. Array Fix

大致就是让你找到数组a 中降序排列的相邻的两个数，通过操作(就是把数字拆位处理），让这个数组变成非降序排列。

如果正着考虑，我们的每一次操作都需考虑前面和后面的数字是否进行操作，正难则反,倒序遍历就只需考虑每个数字的前一个元素。贪心，模拟吧。

#include <bits/stdc++.h> 
using namespace std;
const int mod = 1e9+7;
const double pi = acos(-1.0);
const int N = 2e5 + 10;
typedef long long ll;
typedef pair<int,int> pii;
inline int lowbit(int x) {return x & (- x);}

void oper(int x,int& g,int& s){
    g = x % 10;
    s = x / 10 % 10; 
}
void solve()
{
    int n;cin >> n;
    vector <int> a(n);
    string ans = "YES";
    for(int i = 0;i < n;i ++) cin >> a[i];
    int g = 0,s = 0,in = a[n - 1];//in 记录上一个元素
    for(int i = n - 2;i >= 0;i --){
        if(in < a[i]){
            if(a[i] >= 10){
                oper(a[i],g,s);//操作
                if(g > in || s > g){
                    ans = "NO";
                    break;
                }
                in = s;
            }else {
                ans = "NO";
                break;
            }
        }else in = a[i];
    }   
    cout << ans << "\n";
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 1;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

C. Arrow Path

大概意思就是从走到，然后两种行为，主动(四个方向前进一格),被动(按照格子中的字符的方向前进一格)。

好像可以搜索出来，但只有两行，所以可以直接两行分别处理。可以发现对于第一行，所有的偶数位我们都是可以主动选择方向，奇数位被动，而第二行相反，然后就是一种贪心的走法，尽量选择字符 > 所在的位置。

#include <bits/stdc++.h> 
using namespace std;
const int mod = 1e9+7;
const double pi = acos(-1.0);
const int N = 2e5 + 10;
typedef long long ll;
typedef pair<int,int> pii;
inline int lowbit(int x) {return x & (- x);}


void solve()
{
    int n;cin >> n;
    string s1,s2;
    cin >> s1 >> s2;
    int flag1 = 0,flag2 = 0;
    string ans = "YES";
    for(int i = 1;i < n;i ++){
        if(i % 2 && s1[i] != '>'){//奇数位不是'>'就无法在第一行前进
            if(s2[i - 1] != '>'){//回退，判断第二行的上一个位置
                ans = "NO";
            }
        }
        if(i % 2 == 0 &&s2[i] != '>'){
            if(s1[i - 1] != '>'){
                ans = "NO";
            }
        }
    }
        cout << ans << "\n";
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 1;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

D. Tandem Repeats?

就是找到一个符合串联重复(偶数长度的字符串，其前半部分等于后半部分) 条件的最长子串

范围比较小，可以 复杂度通过。假设 d 表示与字符 s[i] 位置的距离，i 表示当前位置。

两重循环，该怎么循环，是先枚举 d 的大小，还是先枚举 i 的位置？

如果我们先枚举 i 的位置，再枚举 d 的大小，那么还需要再次循环判断串联重复字符的长度，和一些边界条件。

#include <bits/stdc++.h> 
using namespace std;
const int mod = 1e9+7;
const double pi = acos(-1.0);
const int N = 2e5 + 10;
typedef long long ll;
typedef pair<int,int> pii;
inline int lowbit(int x) {return x & (- x);}


void solve()
{
    string s;cin >> s;
    int len = (int)s.length();
    int res = 0,ans = 0;
    for(int i = 1;i <= len / 2;i ++){//枚举d的大小
        res = 0;
        for(int j = 0;j < len - i;j ++){//枚举位置
            if(s[j] == s[j + i] || s[j] == '?' || s[j + i] == '?'){//判断相等
                res ++;
            }else res = 0;
            if(res == i) ans = res;//判断每一个对应的位置是否相同
        }
    }
    cout << 2 * ans << "\n";
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 1;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

E. Clique Partition