ARC184 随便写点

最逆天的一集。

ARC184 A#

题目解析#

关键观察：注意到 $m$ 很小，只有 $10$，并且 $q = 950$。考虑有什么性质。

我们发现 $m$ 很小，我们考虑挖掘性质。

有一个关键观察：如果有大于 $10$ 个数的类型相等，那么他们一定都是好的。

如果我们知道了 $20$ 个数中的相对情况，假设有 $x$ 个数类型相等，其他 $n - x$ 个数类型相等，这两种数类型不同，由于上面的性质，当 $x \neq 10$ 时，数量较多的一类必定是好数，数量较少的一类必定是坏数。

按照上面的启发，我们考虑将 $1000$ 个数进行分组，每组内有 $20$ 个数。我们计算这 $20$ 个数的相对情况（这是容易的），然后根据上面的结论，我们就能知道当一组内两种类型数目不相等时它们的好坏之分。

因此，我们只需要考虑 $x = 10$ 的情况（这种组别显然最多只有一个）。这好办，我们只需要将在这组内的任意一个数和不在这组内的任意一个数比较，这样我们就能区分出哪一种类别是好数。

需要注意一个细节：这样算下来最多的询问次数会到达 $951$，所以需要轻微的调整来解决这一问题。具体比较简单，可以看代码。

void solve() {
    cin >> n >> m >> q;
    vector <int> ans;
    for (int i = 1; i <= 50; i ++) {
        int l = (i - 1) * 20 + 1, pos = 0, cnt0 = 1, cnt1 = 0;
        int tar = -1;
        for (int j = 2; j <= 20 && (i != 50 || !ans.empty()); j ++) {
            cout << "? " << l << ' ' << l + j - 1 << endl;
            cin >> col[l + j - 1];
            cnt0 += (col[l + j - 1] == 0);
            cnt1 += (col[l + j - 1] == 1);
        }
        if (i == 50 && ans.empty()) {
            for (int j = 1; j <= 19; j ++) {
                cout << "? " << 1 << ' ' << j + l - 1 << endl;
                cin >> col[j + l - 1];
                cnt0 += (col[l + j - 1] == 0);
                cnt1 += (col[l + j - 1] == 1);
                if (col[j + l - 1] == 1) ans.push_back(j + l - 1);
            }
            if (cnt1 == 9)
                ans.push_back(1000);
            break;
        }
        if (cnt0 < cnt1) {
            for (int j = 1; j <= 20; j ++)
                if (col[l + j - 1] == 0) ans.push_back(l + j - 1);
        } else if (cnt0 > cnt1) {
            for (int j = 1; j <= 20; j ++)
                if (col[l + j - 1] == 1) ans.push_back(l + j - 1);
        } else {
            pos = (i == 1 ? 1000 : 1);
            cout << "? " << l << ' ' << pos << endl;
            cin >> tar;
            tar ^= 1;
            for (int j = 1; j <= 20; j ++)
                if (col[l + j - 1] == tar) ans.push_back(l + j - 1);
            break;
        }
    }
    cout << "! ";
    for (int x : ans) cout << x << ' ';
    cout << endl;
}

ARC184 B#

ARC184 C#

ARC184 D#

关键转换：删点不是很好考虑，所以转换成选点。

首先我们考虑选择的点集有多少不同的。我们先对第一维 $x$ 坐标进行排序，然后容易想到 $dp$。

显然，选择的点集中相邻两个点 $(i, i + 1)$ 肯定需要满足 $y_i > y_{i + 1}$。据此，可以想到一种比较 naive 的 $dp$ 方法：设 $dp_i$ 表示当前考虑了前 $i$ 个点（选择了 $i$），枚举 $j$，如果 $y_j > y_i$ 则可以直接转移。

但是上面这个 $dp$ 有一个显然的漏洞：重复。因为对于一个删除的点集，可能有多个选择的点集能得到它。因此，我们需要在这些结果相同的点集中选择出一种具有代表性且容易计算的方案。

关键观察：我们再加一条限制，选择任意一个没被删除且没被操作的点，操作它之后一定会删除一个其他点。

通过上面这一个限制，我们就有了一个比较明确的 $dp$ 思路：设 $dp_i$ 表示当前考虑了前 $i$ 个点（选择了 $i$）的方案数，然后每次枚举 $j$，并且判断这一转移合不合法。

假设现在有一个选择的点集，我们要判断它是否合法。显然，我们设所有没被删除且没被操作的点所在的点集为 $T$，然后在点集 $T$ 中遍历每个点 $i$ 判断 前面是否存在 $j$ 使得 $y_j < y_i$ 或者 后面是否存在 $j$ 使得 $y_i < y_j$。

但是现在还有一个问题：在 $dp$ 的转移中如何判断该方案是否合法？

关键观察：我们称相邻两个已操作的点之间所有没被删除的点为一个段。那么，任意两个段之间没有任何关系。即，设左边的点集为 $S$，右边的段的点集为 $T$，那么 $\forall i \in S, j \in T, y_i > y_j$。

上面这个观察是显然的，但很重要。那么，我们就可以在转移的过程中，只判断当前这一段是否满足要求即可。

void solve() {
    n = read();
    for (int i = 1; i <= n; i ++)
        t[i].x = read(), t[i].y = read();
    sort(t + 1, t + n + 1);
    t[0] = {0, n + 1}, t[n + 1] = {n + 1, 0};
    dp[0] = 1;
    for (int i = 1; i <= n + 1; i ++) {
        for (int j = 0; j < i; j ++) {
            if (t[j].y <= t[i].y) continue;
            for (int k = 1; k <= n; k ++)
                vis[k] = 0;
            bool flg = 1;
            long long mn = 2e18, mx = -2e18;
            for (int k = j + 1; k < i; k ++) {
                if (!(t[j].y > t[k].y && t[k].y > t[i].y))
                    continue;
                vis[k] |= (mn < t[k].y);
                mn = min(mn, t[k].y);
            }
            for (int k = i - 1; k > j; k --) {
                if (!(t[j].y > t[k].y && t[k].y > t[i].y))
                    continue;
                vis[k] |= (mx > t[k].y);
                mx = max(mx, t[k].y);
            }
            for (int k = j + 1; k < i; k ++)  {
                if (!(t[j].y > t[k].y && t[k].y > t[i].y))
                    continue;
                flg &= (vis[k] == 1);
            }
            if (flg) {
                (dp[i] += dp[j]) %= mod;
            }
        }
    }
    cout << dp[n + 1];
}