codeforces Round 649(div. 2)

• XXXXX
• Most socially-distanced subsequence
• *Ehab and Prefix MEXs
• *Ehab's Last Corollary

---

A、XXXXX

题意：

在一个数组中找出连续的一段，使得其和不能被$x$整除，且长度尽可能长。

题解：

显然取全部的时候长度最长，如果这个时候不行，就分别枚举其前缀和和后缀和，取两边长度最大值，如果都找不到，输出$-1$。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];
void solve()
{
    int n, sum = 0, x;
    scanf("%d%d", &n, &x);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]), sum += a[i];
    if (sum % x)
    {
        printf("%d\n", n);
        return;
    }
    int tmp = sum, i, ans = -1;
    for (i = 1; i <= n && tmp % x == 0; ++i)
        tmp -= a[i];
    ans = max(ans, n - i + 1);
    tmp = sum;
    for (i = n; i && tmp % x == 0; --i)
        tmp -= a[i];
    ans = max(ans, i);
    printf("%d\n", ans ? ans : ans - 1);
}
int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
        solve();
    return 0;
}

B、Most socially-distanced subsequence

题意：

给出一个排列$p$，长度为$n$，求找出一个长度为$k$序列$s$，使$|s_1-s_2|+|s_2-s_3|+...+|s_{k-1}-s_k|$尽量大，满足前面条件，还要$s$的长度尽量小。

题解：

对于单调的子段，只取端点处是最优的，所以取所有的山峰，山谷的点，并且必取$p[1]$和$p[n]$。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];
vector<int> v;
void solve()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);
    v.clear();
    v.push_back(a[1]);
    for (int i = 2; i < n; ++i)
    {
        if (a[i] > a[i - 1] && a[i] > a[i + 1])
            v.push_back(a[i]);
        else if (a[i] < a[i - 1] && a[i] < a[i + 1])
            v.push_back(a[i]);
    }
    v.push_back(a[n]);
    printf("%d\n", (int)v.size());
    for (auto &i : v)
        printf("%d ", i);
    printf("\n");
}
int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
        solve();
    return 0;
}

*C、Ehab and Prefix MEXs

题意：

给出一个数组$a$，求相同长度的非负数组$b$，使得$b$中的每个元素都不大于$1e6$，且$mex(b_1,b_2,...,b_i)=a_i$。

题解：

自己想的时候总是往给$b$数组按顺序分配$1~n$再调整想了，然后发现好像不可做。因为这样子分配，如果有了冲突之后，修改的成本很大，会$TLE$。

注意到$a$数组是非递降的，且$a_i \leq i$，这就说明似乎可以考虑双指针？考虑在当前位置，$a_i$和$b_i$必不相同，所以我们考虑把出现在$a$数组的数，和不出现在$a$数组的数分成两组，都按升序排，分别称为$1$，组$2$，如果组$1$当前没有选完，并且$a_i>group1[pos1]$，说明当前的组$1$这个数已经在$a$中出现了（重复的话，这个位置直接填$a$中没出现过的或者无穷大（$1e6$））,所以自然可以尝试填进去。然后填完之后检查可行性即可。可行性的检查就是直接遍历从$0$开始的每一个数，然后看看是不是$a_i-1$就是当前的遍历结果，如果出现一个失败，就是不存在。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 1e5 + 1;
int buc[N << 4];
int a[N], b[N], g1[N], g2[N];
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
    {
        scanf("%d", &a[i]);
        ++buc[a[i]];
    }
    int cnt1 = 0, cnt2 = 0;
    for (int i = 0; i <= a[n]; ++i)
    {
        if (buc[i])
            g1[++cnt1] = i;
        else
            g2[++cnt2] = i;
    }
    int pos1 = 1, pos2 = 1;
    for (int i = 1; i <= n; ++i)
    {
        if (pos1 <= cnt1 && a[i] > g1[pos1])
            b[i] = g1[pos1++];
        else if (pos2 <= cnt2)
            b[i] = g2[pos2++];
        else
            b[i] = INF;
    }
    memset(buc, 0, sizeof(buc));
    int tmp = -1;
    for (int i = 1; i <= n; ++i)
    {
        buc[b[i]] = 1;
        while (buc[tmp + 1])
            ++tmp;
        if (a[i] != tmp + 1)
            return printf("-1\n"), 0;
    }
    for (int i = 1; i <= n; ++i)
        printf("%d%c", b[i], " \n"[i == n]);
    return 0;
}

注意：还是要多注意题目的条件，这样子可以找到正解的切入点。

*D、Ehab's Last Corollary

题意：

给出一个图，找出一个至多有$k$个点的环或者找到一个有$\lceil \frac{k}{2} \rceil$个点的独立集（即集中任何两个元素没有边直接相连）。

题解：

找环是比较简单的，所以考虑先找环。然后注意到：如果找到的最小环都比$k$大，那么只要我对这个环隔一个点输出一个点，一定能找到这个独立集。所以题目就转化成，找个环就行了。找最小环通过$dfs树$即可，考虑到图可能会变成树，但是树的$dfs树$是它本身，所以我们万一找不到适合的环，我们可以考虑如何在树上找独立集，然后推广到图的$dfs$树上。对于树的每一层的结点数一定比它的下一层的结点数少，所以我们回溯的时候把所有叶节点染白，然后白点的邻接点全部染黑，在白色的结点中找这个独立集。

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> G[N];
bool vis[N];
vector<int> cyc;
int dep[N];
int n, m, k;
void dfs(int u, int fa)
{
    cyc.push_back(u);
    dep[u] = dep[fa] + 1;
    for (auto i : G[u])
    {
        if (i == fa)
            continue;
        if (!dep[i])
            dfs(i, u);
        else
        {
            if (dep[u] - dep[i] + 1 >= 0 && dep[u] - dep[i] + 1 <= k)
            {
                printf("2\n%d\n", dep[u] - dep[i] + 1);
                for (int j = dep[i] - 1; j < dep[u]; ++j)
                    printf("%d%c", cyc[j], " \n"[j == dep[u] - 1]);
                exit(0);
            }
        }
    }
    if (!vis[u])
        for (auto i : G[u])
            vis[i] = 1;
    cyc.pop_back();
}
int main()
{
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 1; i <= m; ++i)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    dfs(1, 0);
    printf("1\n");
    for (int i = 1, cnt = 1; i <= n && cnt <= (k + 1) / 2; ++i)
        if (!vis[i])
            printf("%d%c", i, " \n"[cnt == (k + 1) / 2]), ++cnt;
    return 0;
}