Codeforces Round #706 (Div. 2) A-D题解

写在前边

链接：Codeforces Round #706 (Div. 2)

$A,B,C,D$,这场有点简单，不过由于A写炸了后边题连看都没看就溜了，就从上大分变成了掉大分

A. Split it!

链接：A题链接

题目大意:

给定一个字符串$s$，和一个数字$k$，那么$a_i$是$s$的一个子串，$R（a_i）$代表$a_i$的逆序，问是否满足：

\[s = a_1 + a_2 + ... + a_k + a_{k + 1} + R(a_k) + R(a_{k - 1}) + ... + R(a_1)
\]

思路：

首先要知道，有一个单独的$a_{k + 1}$部分，那么这部分，根本无所谓，但是对于它的两侧必然要是回文的，一开始就拽着回文串不放了，思维定势，以为全串必然要是回文才行，所以写炸了，所以只需要判断$s[1, k]$是否等于$s[n - k + 1, n]$（下标从1开始）即可，还要注意的是如果这个串的长度为偶数，那么$k$必然不能等于$\cfrac{s.size()}{2}$，

代码:

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cstdio>

#include <vector>

#include <map>

#include <cstring>

//#pragma GCC optimize(2)

//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f

#define PII pair<int, int>

#define P2LL pair<long long, long long>

#define endl '\n'

#define pub push_back

#define pob pop_back

typedef long long LL;

typedef unsigned long long ULL;

typedef vector<long long> VLL;

typedef vector<int> VI;

const int Mod = 10000007;

LL gcd(LL a, LL b) {

    return b ? gcd(b, a % b) : a;

}

void solve() {

    string s;

    int n, k;

    cin >> n >> k;

    cin >> s;

    if (k == 0) {

        puts("YES");

        return;

    }

    //这题并不一定要求中间是回文的

    if (s.size() % 2 == 0 && k == s.size() / 2) {

        puts("NO");

        return;

    }

    bool flag = true;

    for (int i = 0; i < k; i++) {

        if (s[i] != s[s.size() - 1 - i]) {

            flag = false;

            break;

        }

    }

    puts(flag ? "YES" : "NO");

}

int main()

{

    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    int t;

    scanf("%d", &t);

    while (t--) {

        solve();

    }

    return 0;

}

B. Max and Mex

链接：B题链接

题目大意:

给定一个序列$s$，我们可以进行$k$次操作，每次操作是添加一个$\lceil \cfrac{a + b}{2} \rceil$,$a = mex(s)$, $b = max(s)$,$max$就是序列中最大的数字，$mex$表示序列中最小不存在的非负整数，例如在序列$0，1，2，4$中，那么$mex = 3$，问$k$次插入后，$S$中不同数字的个数有多少。

思路：

先找到第一个$mex$，如果$mex <= max(S)$,可以发现，插入一个$\lceil \cfrac{a + b}{2} \rceil$，永远不会出现这个数，因此，mex就永远不会变化，与此同时插入的值也永远不会大于max，所以mex与max不变，那么序列中不同数的个数最多就加1，用一个set维护就好。

如果$mex == max(S)$，即假设序列为$0,1,2,3$，那么第一个$mex$就是$4$，所以$\lceil \cfrac{a + b}{2} \rceil$算出来就是$mex$，就插入一个新值，所以这种情况下，有多少个$k$，就插入多少个新值。

注意：取最大值的时候要看要注意数组并不一定是严格有序的啊！！

代码:

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cstdio>

#include <vector>

#include <map>

#include <cstring>

#include <set>

//#pragma GCC optimize(2)

//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f

#define PII pair<int, int>

#define P2LL pair<long long, long long>

#define endl '\n'

#define pub push_back

#define pob pop_back

typedef long long LL;

typedef unsigned long long ULL;

typedef vector<long long> VLL;

typedef vector<int> VI;

const int Mod = 10000007;

LL gcd(LL a, LL b) {

    return b ? gcd(b, a % b) : a;

}

const int N = 1e5 + 10;

int a[N];

//题目没说给有序数组大哥

void solve() {

    int n, k;

    scanf("%d%d", &n, &k);

    multiset<int> st2; //记录没有的数字 最小的数字

    set<int> st3;

    for (int i = 0; i < n; i++) scanf("%d", &a[i]);       

    sort(a, a + n);

    for (int i = 0; i < n; i++) {

        st3.insert(a[i]);

        st2.insert(a[i]);

    }

    if (k == 0) {

        cout << st3.size() << endl;

        return;

    }

    int m = 0;

    for (auto &it : st2) {

        if (m != it) {

            break;

        }

        m++;

    }

    if (m > a[n - 1]) cout << n + k << endl;

    else {

        st3.insert((m + a[n - 1] + 1) / 2);

        cout << st3.size() << endl;

    }

}

int main()

{

    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    int t;

    scanf("%d", &t);

    while (t--) {

        solve();

    }

    return 0;

}

C. Diamond Miner

链接：C题链接

题目大意:

不说了，太简单了。

思路：

排序，贪心求值就好了

代码:

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cstdio>

#include <vector>

#include <map>

#include <cstring>

#include <cmath>

//#pragma GCC optimize(2)

//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f

#define PII pair<int, int>

#define P2LL pair<long long, long long>

#define endl '\n'

#define pub push_back

#define pob pop_back

typedef long long LL;

typedef unsigned long long ULL;

typedef vector<long long> VLL;

typedef vector<int> VI;

const int Mod = 10000007;

const int N = 1e5 + 10;

void solve() {

    int n;

    scanf("%d", &n);

    vector<int> a, b;

    for (int i = 0; i < n * 2; i++) {

        int x, y;

        scanf("%d%d", &x, &y);

        if (x == 0) b.push_back(abs(y));

        if (y == 0) a.push_back(abs(x));

    }

    sort(a.begin(), a.end());

    sort(b.begin(), b.end());

    double res = 0.0;

    for (int i = 0; i < n; i++) {

        res += sqrt((LL) a[i] * a[i] + (LL) b[i] * b[i]); //千万不要忘记long long

    }

    printf("%.15lf\n", res);

}

int main()

{

    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    int t;

    scanf("%d", &t);

    while (t--) {

        solve();

    }

    return 0;

}

D. Let's Go Hiking

链接：D题链接

题目大意:

给题目大意转化一下就是，小$A$只能走一条单调递减序列，小$B$只能走一条单调递减序列，直到到某个人走的时候这个人无路可走了那么他就输了。题目中为小$A$先选一个起点，然后小B后选一个起点，接下来，小A先做决策，再B做决策，两者选择永远最优，问最后小A。

思路：

是一道博弈论的题目，两个人都是在单调的路上走，并且对于$B$来说，肯定要想办法让A输，A肯定想找一条最长的路走，所以有下面几种情况：

如果两个以上的单调段，那么先手必然输，因为：

如果是全是一个方向的单调段，那么小$A$无论如何都会被小$B$堵截。
如果对于山峰段，即一个点左右分别为单调递增单调递减，有多个，那么$B$后手总能选到一个地方赢得比赛（画几个例子试试）。
如果对于山谷段，及一个点左右分别为单调递减单调递增，有多个，那么$B$后手也同样总能选到一个地方赢得比赛（画几个例子试试）。

如果就只有一个单调段，那么更不用说了，B只需要放在A旁边堵A即可，赢得比赛。

所以如果想要先手赢，那么必然是只要一个山峰段，同时山峰段还要左右恰好对称才可以，如果不对称那$B$也可以找一个地方拦截$A$，或者走的路比更长，如果对称情况下，$A$必然选择连接点，而这时小$B$只能选两端点，这时如果$A$躲避$B$走另一边，那么它无论如何都输，因此他只能跟$B$对着走，而这时如果$maxl % 2 == 0$，那么它依然输，所以只有$maxl % 2 ！= 0$情况下同时是对称的山峰段才赢，其余情况均输。

代码:

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cstdio>

#include <vector>

#include <map>

#include <cstring>

//#pragma GCC optimize(2)

//#pragma GCC optimize(3,"Ofast","inline")

using namespace std;

#define Inf 0x3f3f3f3f

#define PII pair<int, int>

#define P2LL pair<long long, long long>

#define endl '\n'

#define pub push_back

#define pob pop_back

typedef long long LL;

typedef unsigned long long ULL;

typedef vector<long long> VLL;

typedef vector<int> VI;

const int Mod = 1000000007;

LL gcd(LL a, LL b) {

    return b ? gcd(b, a % b) : a;

}

const int N = 1E5 + 10;

int n, p[N];

int pre[N], suff[N];

void solve() {

    scanf("%d", &n);

    for (int i = 1; i <= n; i++) scanf("%d", &p[i]);

    for (int i = 1; i <= n; i++) {

        if (p[i] > p[i - 1]) pre[i] = pre[i - 1] + 1;

        else pre[i] = 1;

    }

    for (int i = n; i >= 1; i--) {

        if (p[i] > p[i + 1]) suff[i] = suff[i + 1] + 1;

        else suff[i] = 1;

    }

    /* for (int i = 1; i <= n; i++) cout << pre[i] << " ";

    cout << endl;

    for (int i = 1; i <= n; i++) cout << suff[i] << " ";

    cout << endl; */

    int maxl = 0;

    for (int i = 1; i <= n; i++) maxl = max({maxl, pre[i], suff[i]});

    int cnt1 = 0, cnt2 = 0, idx1 = 0, idx2 = 0;

    for (int i = 1; i <= n; i++) {

        if (pre[i] == maxl) {

            cnt1++;

            idx1 = i;

        }

        if (suff[i] == maxl) {

            cnt2++;

            idx2 = i;

        }

    }

    if (cnt1 + cnt2 != 2) {

        puts("0");

        return;

    } else if (cnt1 + cnt2 == 2 && idx1 == idx2) {

        puts(maxl % 2 == 0 ? "0" : "1");

    } else puts("0");

}

int main()

{

    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

    solve();

    return 0;

}