Codeforces Round #751 (Div. 2)/CodeForces1602

CodeForces1602

Two Subsequences

解析：

题目大意

给你一个字符串 \(s\)。你需要两个非空字符串 \(a\) 和 \(b\) 并且满足下面的条件：

1. 字符串 \(a\) 和 \(b\) 都是 \(s\) 的子序列。
2. 对于原字符串的每一个字符，必须属于 \(a\) 和 \(b\) 之一。
3. \(a\) 是所有满足条件的字符串中字典序最小的。

给你 \(s\)，输出 \(a\) 和 \(b\)。

---

思路：

字典序最小，首先需要长度最小，所以 \(a\) 字符串最多只要一个字符就行，那么只在字符串中选择字典序最小的字符当做 \(a\) 即可，剩余作为 \(b\) 即可。

---

code

#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 10;
const int INF = 0x3f3f3f3f;
inline int read ()
{
    int x = 0, f = 1;
    char ch = getchar ();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
    while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
    return x * f;
}
int n;
char s[N];
void solve ()
{
    scanf ("%s", s + 1);
    n = strlen (s + 1);
    int mn = INF;
    for (int i = 1; i <= n; i++) mn = min (mn, int(s[i] - 'a'));
    printf ("%c ", char (mn + 'a'));
    bool flag = false;
    for (int i = 1; i <= n; i++) { if (!flag && int(s[i] - 'a') == mn) { flag = true; continue; } printf ("%c", s[i]); }
    printf ("\n");
}
signed main()
{
    int t = read ();
    while (t--) solve ();
    return 0;
}

Divine Array

解析：

题目大意：

给定一个序列，一次转换是将一个数变成这个数在这个序列中出现的次数。

序列 \(\{2,1,1,4,3,1,2\}\) 中，\(2\) 出现 \(2\) 次，\(1\) 出现 \(3\) 次，\(3\) 和 \(4\) 出现 \(1\) 次，那么这个序列进行一次转换之后就变成了 \(\{2,3,3,1,1,3,2\}\)，同理，进行两次转换后是 \(\{2,3,3,2,2,3,2\}\)，进行三次转换后是 \(\{4,3,3,4,4,3,4\}\)。

有 \(q\) 次询问，每次询问第 \(x\) 个位置的元素经过 \(k\) 次转换之后是什么。

---

思路：

先给出个显然的结论：这个序列在变化 \(\log n\) 次后就会稳定。

考虑每次变化，实际上是两个出现次数相同的数合并的过程，那么每次合并完成新数的出现次数就会变成原数的两倍，即最多 \(\log\) 次就会令整个序列变成一个数。

证毕。

考虑暴力 \(\log\) 次变化后的序列，离线处理答案即可。

时间复杂度 \(\mathcal O(n\log n+q)\)。

---

code：

#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 10;
const int M = 1e5 + 10;
const int INF = 0x3f3f3f3f;
const int mods = 998244353;
typedef pair <int, int> pii;
inline int read ()
{
    int x = 0, f = 1;
    char ch = getchar ();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
    while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
    return x * f;
}
int n, m;
int a[N];
struct Query {
    int x, k, id;
    bool operator < (const Query &A) const {
        return k < A.k;
    }
}q[M];
int buttle[N], ans[M];
void solve ()
{
    n = read ();
    for (int i = 1; i <= n; i++) a[i] = read ();
    m = read ();
    for (int i = 1; i <= m; i++) q[i].x = read (), q[i].k = read (), q[i].id = i;
    sort (q + 1, q + m + 1);
    int now = 1;
    for (int cnt = 0; ; cnt++)
    {
        while (now <= m && q[now].k <= cnt) ans[q[now].id] = a[q[now].x], now++;
        for (int i = 1; i <= n; i++) buttle[i] = 0;
        for (int i = 1; i <= n; i++) buttle[a[i]]++;
        bool flag = true;
        for (int i = 1; i <= n; i++) if (buttle[i] != i && buttle[i]) flag = false;
        if (flag) break;
        for (int i = 1; i <= n; i++) a[i] = buttle[a[i]];
    }
    while (now <= m) ans[q[now].id] = a[q[now].x], now++;
    for (int i = 1; i <= m; i++) printf ("%lld\n", ans[i]);
}
signed main()
{
    int t = read ();
    while (t--) solve ();
    return 0;
}

Array Elimination

解析：

题目大意

给你一个由非负整数组成的长度为 \(n\) 的序列 \(a_1,a_2,\cdots,a_n\)，你可以先选择一个整数 \(k\)，并在原序列中选择 \(k\) 个位置 \(i_1,i_2,\cdots i_k\)，设 \(x=a_{i_1}\) & \(a_{i_2}\) & \(\cdots\) & \(a_{i_k}\)，令它们全部减去 \(x\)，求可以通过若干次操作使得序列中每个元素都等于 \(0\) 的所有可行的 \(k\)。

---

思路：

考虑拆位，对于每一个二进制位分开考虑，很明显，如果当前二进制位有 \(cnt\) 个 \(1\)，那么选择的 \(k\) 必定需要是 \(cnt\) 的因子，因为如果剩余 \(1\) 的个数小于 \(k\) 那么这 \(cnt\) 个 \(1\) 就不可能被消掉了。

原问题转化为 \(\log\) 位的 \(cnt\) 的公约数，可以先求出来所有 \(cnt\) 的 \(\gcd\)，答案为 \(\gcd\) 的所有因数。

---

code

#include <bits/stdc++.h>
#define eb emplace_back
using namespace std;
const int N = 2e5 + 10;
const int INF = 0x3f3f3f3f;
typedef pair <int, int> pii;
inline int read ()
{
    int x = 0, f = 1;
    char ch = getchar ();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
    while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
    return x * f;
}
int n;
int a[N];
vector <int> vec, ans;
int gcd (int a, int b) { return !b ? a : gcd (b, a % b); }
void solve ()
{
    vec.clear (), ans.clear ();
    n = read ();
    int Or = 0;
    for (int i = 1; i <= n; i++) a[i] = read (), Or |= a[i];
    if (!Or)
    {
        for (int i = 1; i <= n; i++) printf ("%lld ", i);
        puts ("");
        return ;
    }
    int k;
    for (int i = 30; i >= 0; i--) if (Or & (1 << i)) { k = i; break; }
    for (; k >= 0; k--)
    {
        int cnt = 0;
        for (int i = 1; i <= n; i++) cnt += ((a[i] >> k) & 1);
        if (cnt) vec.eb (cnt);
    }
    int g = vec[0];
    for (int i = 1; i < vec.size (); i++) g = gcd (g, vec[i]);
    for (int i = 1; i * i <= g; i++)
        if (g % i == 0)
        {
            ans.eb (i);
            if (i * i != g) ans.eb (g / i);
        }
    sort (ans.begin (), ans.end ());
    for (int i = 0; i < ans.size (); i++) printf ("%d ", ans[i]);
    puts ("");
}
signed main()
{
    int t = read ();
    while (t--) solve ();
    return 0;
}

Frog Traveler

解析：

题目大意：

你是一直青蛙，最一开始在井底深 \(d\) 处，当你处于深度 \(i\) 时，你每次可以跳 \(h\in[0,a_i]\) 米，但当你跳到深度 \(j\) 米后，你将会下滑 \(b_j\) 米，请问最少要跳多少次才能到达井外（0 处）。

---

思路：

平衡树优化bfs，我们考虑暴力的过程，每次从当前点往前枚举 \([i-a_i,i-1]\)，更新跳到这些位置后下滑到的深度所需要的跳跃次数，并把这些的新的位置加入队列。

我们发现，这样如果枚举的复杂度上限是 \(\mathcal O(n^2)\)（虽然达不到这标准并且这题可以卡常过去，但我们应追求正解），无法通过，考虑每次枚举跳到的位置实际上是一个区间，这就启发了可以用平衡树维护当前还没有被跳到的过的深度，那么在每次枚举完成后将这段区间直接在平衡树上删除，这样每个点最多会被删除一次。

优化完的代码时间复杂度 \(\mathcal O(n\log n)\)（细节较多，非常阴间的题）。

---

code：

#include <bits/stdc++.h>
#define eb emplace_back
using namespace std;
const int N = 3e5 + 10;
const int INF = 0x3f3f3f3f3f3f3f3f;
typedef pair <int, int> pii;
inline int read ()
{
    int x = 0, f = 1;
    char ch = getchar ();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
    while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
    return x * f;
}
int n, root;
int a[N], b[N];
int dp[N];
queue <int> que;
int lst[N], lst2[N];
vector <int> ans;
struct fhq_treap {
	int node;
    int x, y, z;
	struct Tree {
		int ls, rs;
		int key, val, siz, pos;
		#define ls(x) tree[x].ls
		#define rs(x) tree[x].rs
		#define key(x) tree[x].key
		#define val(x) tree[x].val
		#define siz(x) tree[x].siz
        #define pos(x) tree[x].pos
	} tree[N];
	inline void pushup (int x) { siz(x) = siz(ls(x)) + siz(rs(x)) + 1; }
	int new_node (int v, int x)
	{
		siz(++node) = 1;
		key(node) = rand ();
		val(node) = v;
        pos(node) = x;
		return node;
	}
	int merge (int x, int y)
	{
		if (!x || !y) return x + y;
		if (key(x) < key(y)) { rs(x) = merge (rs(x), y); pushup (x); return x; }
		else { ls(y) = merge (x, ls(y)); pushup (y); return y; }
	}
	void split (int now, int k, int &x, int &y)
	{
		if (!now) {x = y = 0; return ; }
		if (val(now) <= k) x = now, split (rs(now), k, rs(x), y);
		else y = now, split (ls(now), k, x, ls(y));
		pushup (now);
	}
	void insert (int v, int p)
	{
		x = y = 0;
		split (root, v, x, y);
		root = merge (merge (x, new_node (v, p)), y);
	}
    void dfs (int now, int x)
    {
        if (!now) return ;
        if (dp[pos(now)] > dp[x] + 1)
            que.push (pos(now)), lst[pos(now)] = x, lst2[pos(now)] = val(now);
        dp[pos(now)] = min (dp[pos(now)], dp[x] + 1);
        if (!val(now)) { lst[pos(now)] = x; return ; }
        dfs (ls(now), x);
        dfs (rs(now), x);
    }
    void solve (int p)
    {
        int l = p - a[p] - 1, r = p - bool(a[p]);
        split (root, l, x, y);
        split (y, r, y, z);
        dfs (y, p);
        root = merge (x, z);
    }
} T;
signed main()
{
    n = read ();
    for (int i = 1; i <= n; i++) a[i] = read ();
    for (int i = 1; i <= n; i++) b[i] = read (), T.insert (i, i + b[i]);
    memset (dp, 0x3f, sizeof (dp));
    dp[n] = 0;
    que.push (n); T.insert (0, 0);
    while (!que.empty ())
    {
        int x = que.front (); que.pop ();
        T.solve (x);
        if (dp[0] != INF) break;
    }
    if (dp[0] == INF) printf ("-1\n");
    else
    {
        printf ("%d\n", dp[0]);
        int now = 0;
        while (now != n)
        {
            ans.eb (lst2[now]);
            now = lst[now];
        }
        for (int i = ans.size () - 1; i >= 0; i--) printf ("%d ", ans[i]);
    }
    return 0;
}

Optimal Insertion

解析：

题目大意：

给你两个序列 \(a,b\)，长度分别为 \(n,m\)。现在要把 \(b\) 序列中的每个数插入 \(a\)，得到一个长度为 \(n+m\) 的序列 \(c\)，求逆序对个数最少的插入方法。逆序对的定义为点对 \((i,j)\) 满足 \(i<j\)，\(a_i>a_j\)。

注意，\(b\) 序列可以随意插入，但 \(a\) 序列对应顺序不应发生改变。

---

思路：

我们定义 \(b_i\) 的最优决策位置的意义是满足在只把 \(b_i\) 插入原序列 \(a\) 中后，形成的逆序对个数最少的位置。

那么有一个结论：大数的最优决策点一定在较小数的最优决策点后面，那么最优解所对应的 \(b\) 在 \(a\) 中的顺序也应为升序排列，这样就可以对 \(b\) 按升序排序后依次插入 \(a\)。

考虑证明一下这个结论：设 \(b_i\) 的最优决策点为 \(p_i\)，\(b_j\) 的最优决策点为 \(p_j\)，满足 \(b_i>b_j\) 且 \(p_i<p_j\)，那么考虑 \(p_i\) 之前以及 \(p_j\) 之后的数都不会对逆序对产生贡献，所以考虑 \([p_i,p_j]\) 之间的数，我们考虑分为三类：\(x> b_i\) 的个数记为 \(cnt_1\)，\(b_j\leq x\leq b_i\) 的个数记为 \(cnt_2\)，以及 \(x<p_j\) 的记为 \(cnt_3\)，那么根据最优决策点的定义，有：\(cnt_1+cnt_2<cnt_3\)，即 \(b_j\) 放在 \(p_j\) 的位置产生的逆序对小于放在 \(p_i\) 位置逆序对的个数。那么同样有 \(cnt_2+cnt_3<cnt_1\)（考虑 \(b_i\) 放在 \(p_i,p_j\)），那么与 \(cnt_1+cnt_2\) 矛盾，\(b_i>b_j\) 且 \(p_i<p_j\) 的假设不成立，则有 \(p_i>p_j\)。

这个结论并不能提供具体算法，但可以告诉我们插入的时候的顺序，并且 \(b\) 序列之间不会产生逆序对，也就是说我们只需要计算 \(a\) 内部的逆序对以及 \(a\) 与 \(b\) 产生的逆序对。

前者的计算是平凡的，可以直接 \(\mathcal O(n\log n)\) 树状数组计算，我们考虑如何计算后者。

我们维护一个长度为 \(n+1\) 的线段树，维护放当前 \(b_i\) 时在序列 \(a\) 对应位置产生的贡献，那么对于 \(a_j>b_i\) 的贡献将贡献在 \([j+1,n+1]\)，对于 \(a_j<b_i\) 的贡献区间应为 \([1,j]\)。

由于 \(b\) 是单调不降的，所以我们可以动态维护 \(a_j\) 产生贡献的方向，具体看代码。

原问题变为区间 \(\pm 1\)，全局最小值。

总时间复杂度 \(\mathcal O((n+m)\log n+n\log n)\)。

---

code：

#include <bits/stdc++.h>
#define eb emplace_back
#define lob lower_bound
using namespace std;
const int N = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const int mods = 1e9 + 7;
typedef pair <int, int> pii;
inline int read ()
{
    int x = 0, f = 1;
    char ch = getchar ();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar (); }
    while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar (); }
    return x * f;
}
int n, m;
int a[N], b[N];
int ls[N << 1], len;
vector <int> vec[N << 1];
int buttle[N << 1];
struct Seg_tree {
    #define lson rt << 1
    #define rson rt << 1 | 1
    struct seg_tree {
        int mn, tag;
        #define mn(rt) tree[rt].mn
        #define tag(rt) tree[rt].tag
    } tree[N << 2];
    inline void pushup (int rt) { mn(rt) = min(mn(lson), mn(rson)); }
    inline void spread (int rt)
    {
        if (tag(rt) != 0)
        {
            mn(lson) += tag(rt); mn(rson) += tag(rt);
            tag(lson) += tag(rt); tag(rson) += tag(rt);
            tag(rt) = 0;
        }
    }
    void modify (int rt, int l, int r, int L, int R, int k)
    {
        if (L <= l && r <= R) { mn(rt) += k; tag(rt) += k; return ; }
        int mid = (l + r) >> 1;
        spread (rt);
        if (L <= mid) modify (lson, l, mid, L, R, k);
        if (R > mid) modify (rson, mid + 1, r, L, R, k);
        pushup (rt);
    }
} T;
struct BIT {
    #define lowbit(x) x & (-x)
    int tree[N << 1];
    void add (int x, int val) { for (; x <= len; x += lowbit(x)) tree[x] += val; }
    int query (int x) { int res = 0; for (; x > 0; x -= lowbit(x)) res += tree[x]; return res; }
} T2;
void solve ()
{
    len = 0;
    n = read (), m = read ();
    for (int i = 1; i <= n; i++) a[i] = read (), ls[++len] = a[i];
    for (int i = 1; i <= m; i++) b[i] = read (), ls[++len] = b[i];
    sort (ls + 1, ls + len + 1);
    sort (b + 1, b + m + 1);
    len = unique (ls + 1, ls + len + 1) - ls - 1;
    long long ans = 0;
    for (int i = n; i >= 1; i--)
    {
        a[i] = lob (ls + 1, ls + len + 1, a[i]) - ls;
        vec[a[i]].eb (i);
        T.modify (1, 1, n + 1, i + 1, n + 1, 1);
        ans += (long long)T2.query(a[i] - 1); T2.add (a[i], 1);
    }
    for (int i = 1; i <= m; i++) b[i] = lob (ls + 1, ls + len + 1, b[i]) - ls, buttle[b[i]]++;
    int now = 1;
    for (int i = 1; i <= m; i += buttle[b[i]])
    {
        while (now < b[i] && !vec[now].empty ())
        {
            for (int j = 0; j < vec[now].size (); j++)
                T.modify (1, 1, n + 1, vec[now][j] + 1, n + 1, -1),
                T.modify (1, 1, n + 1, 1, vec[now][j], 1);
            now++;
        }
        if (now == b[i])
            for (int j = 0; j < vec[now].size (); j++)
                T.modify (1, 1, n + 1, vec[now][j] + 1, n + 1, -1);
        ans += 1ll * T.tree[1].mn * buttle[b[i]];
        if (now == b[i])
            for (int j = 0; j < vec[now].size (); j++)
                T.modify (1, 1, n + 1, 1, vec[now][j], 1);
        now++;
    }
    for (int i = 1; i <= n + m; i++) T2.tree[i] = 0, buttle[i] = 0, vec[i].clear ();
    for (int i = 1; i <= (n << 2); i++) T.tree[i].mn = T.tree[i].tag = 0;
    printf ("%lld\n", ans);
}
signed main()
{
    int t = read ();
    while (t--) solve ();
    return 0;
}

6

解析：

题目大意：

咕咕咕

---

思路：

---

code：