Codeforces Round 1020 div3 个人题解(A~G2)

Codeforces Round 1020 div3 个人题解(A~G1)

Dashboard - Codeforces Round 1020 (Div. 3) - Codeforces

---

A. Dr. TC

题目大意

给定一个01字符串 $s$ ，由这个字符串生成一个字符串数组，字符串数组中第 $i$ 个字符串即对 $s$ 的第 $i$ 个字符进行01翻转 后得到的字符串，问字符串数组中有多少个1。

解题思路

我们先统计出原始串中的0和1的数量 $cnt0,cnt1$ ，答案即为 $cnt0\times (cnt1+1)+cnt1\times (cnt1-1)$ 。

代码实现

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
    int n;
    cin >> n;
    string s;
    cin >> s;
    int cnt1 = 0, cnt0 = 0;
    for (auto &c : s)
    {
        cnt1 += (c == '1');
        cnt0 += (c == '0');
    }
    cout << cnt0 * (cnt1 + 1) + cnt1 * (cnt1 - 1) << "\n";
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：

---

B. St. Chroma

题目大意

给你一个长度为 $n$ 的排列 $p$，元素是 $0$ 到 $n-1$。定义第 $i$ 个前缀的上色值为 $\mathrm{MEX}(p_1,\dots ,p_i)$。现在希望选一个喜欢的颜色 $x$，构造一个排列，使得在所有前缀中涂成颜色 $x$ 的格子数量最大化。

解题思路

要使第 $i$ 个前缀的上色为 $\mathrm{MEX}=x$，这个前缀中必须恰好包含 $0,1,\dots ,x-1$ ，否则小于 $x$ 的某个数没出现，MEX 会更小，且不包含 $x$，否则 MEX 会大于 $x$ 。

令 $L$ 为 $0,1,\dots ,x-1$ 中最后一个出现的位置，令 $P$ 为元素 $x$ 在全排列中的位置，则对于所有 $i$ 满足 $L\le i<P$ 时，前缀 $[\mathrm{1..}i]$ 恰好包含 $0,\dots ,x-1$ 且不含 $x$，因而 $\mathrm{MEX}=x$。所以可获得的次数为 $\max (0,P-L)$。要最大化 $P-L$，就应当让所有 $0,\dots ,x-1$ 尽可能集中在最前面，让 $x$ 放到 $n$ 。这样 $L=x$，$P=n$，获得次数 $n-x$，已是可行的最大值。

当 $x=0$ 时，前缀要 MEX=0，必须不含 0，直到看到 0 前的所有前缀都算。最优做法是把 0 放在最后，得到次数 $n-1$ 。

当 $x=n$ 时，MEX 想要 $n$，只有在前缀包含了所有 $0\dots n-1$ 时才行，即只有完整前缀长度 $n$ 一次。此时任意排列都能达到最多一次。

代码实现

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
    int n, x;
    cin >> n >> x;
    if (x == 0)
    {
        for (int i = 1; i < n; i++)
        {
            cout << i << " ";
        }
        cout << 0 << "\n";
        return;
    }

    if (x == n)
    {
        for (int i = 0; i < n; i++)
        {
            cout << i << " \n"[i == n - 1];
        }
        return;
    }
    for (int i = 0; i < x; i++)
    {
        cout << i << " ";
    }
    for (int i = x + 1; i < n; i++)
    {
        cout << i << " ";
    }
    cout << x << "\n";
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：

C. Cherry Bomb

题目大意

给定两个长度为 $n$ 的整型数组 $a$ 和 $b$，其中 $a_i$ 和 $b_i$ 的取值范围为 $[0,k]$，且有些 $b_i$ 丢失，用 $-1$ 表示。我们称 $a$ 和 $b$ 是互补的，当且仅当存在一个常数 $x$，使得对所有 $1\le i\le n$ 都有$a_i+b_i=x$,现在要为所有丢失的 $b_i$ 填上一个值，使得填完后数组 $b$ 与 $a$ 互补。问有多少种方案。

解题思路

遍历一遍 $a,b$ ，如果 $b_i\ne -1$，则可以算出一个候选值 $x=a_i+b_i$ 。若后续出现不同的 $a_j+b_j\ne x$，则不可能互补，答案为 0，如果确定了唯一的 $x$，则对每个缺失位置需要填入 $x-a_i$ （ $0\le x-a_i\le k$ )，若都满足，则方案数为 1。

如果所有 $b_i=-1$，那么 $x$ 可以在一个区间内任意取值。对 $b_i$ 来说， $0\le x-a_i\le k⟹a_i\le x\le a_i+k$ 。答案即为$ \min{a_i} -\max{a_i}+ k+1$。

代码实现

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
    int n;
    ll k;
    cin >> n >> k;
    vl a(n);
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    vl b(n);
    for (int i = 0; i < n; i++)
    {
        cin >> b[i];
    }

    ll x = -1;
    for (int i = 0; i < n; i++)
    {
        if (b[i] != -1)
        {
            ll cur = a[i] + b[i];
            if (x == -1)
            {
                x = cur;
            }
            else if (x != cur)
            {
                cout << 0 << "\n";
                return;
            }
        }
    }

    if (x != -1)
    {
        for (int i = 0; i < n; i++)
        {
            if (b[i] == -1)
            {
                ll need = x - a[i];
                if (need < 0 || need > k)
                {
                    cout << 0 << "\n";
                    return;
                }
            }
        }
        cout << "1\n";
        return;
    }

    ll mx = 0, mn = infll;
    for (int i = 0; i < n; i++)
    {
        mx = max(mx, a[i]);
        mn = min(mn, a[i] + k);
    }
    ll ans = 0;
    if (mx <= mn)
        ans = mn - mx + 1;
    cout << ans << "\n";
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：

---

D. Flower Boy

题目大意

给两个序列长度为 $n$ 和 $m$ 的序列 $a,b$ ，要求在 $a$ 中恰好选出一个长度为 $m$ 的子序列 $c$，使得$c_i\ge b_i,i=1,2,\dots ,m$

在选之前，允许你在 $a$ 的任意位置插入恰好一个值为 $k$ 的元素，问最小的 $k$ 应取何值，使得上述选取可行；若原序列已可满足，输出 $0$；若无论 $k$ 取何值都不可行，输出 $-1$。

解题思路

我们用 $pre[i]$ 表示在不插花的情况下，只看原序列前 $i$ 个花，最多能匹配需求数组 $b$ 的前多少个：
$$\text{pre}[0]=0,\text{pre}[i]=\{\begin{array}{ll}\text{pre}[i-1]+1,& \text{若 }\text{pre}[i-1]<m\text{ 且 }{a}_i\ge b_{\text{pre}[i-1]+1},\\ \text{pre}[i-1],& \text{否则.}\end{array}$$
我们用 $suf[i]$ 表示只看原序列从第 $i$ 个到末尾，最多能从 $b$ 的末尾匹配多少个：
$$\text{suf}[n+1]=0,\text{suf}[i]=\{\begin{array}{ll}\text{suf}[i+1]+1,& \text{若 }\text{suf}[i+1]<m\text{ 且 }{a}_i\ge b_{m-\text{suf}[i+1]},\\ \text{suf}[i+1],& \text{否则.}\end{array}$$
这样我们就能快速知道，在插入点右侧还能匹配需求的多少尾部。

枚举所有插入点，计算最小 $k$
插在第 $i$ 和第 $i+1$ 个花之间，前半段最多已匹配 $p=\text{pre}[i]$ 个需求；若要让插入的那朵花去匹配需求的第 $p+1$ 项，必须满足 $k\ge b_{p+1}$ ,并且右侧还能匹配剩余 $m-(p+1)$ ，即 $\text{suf}[i+1]\ge m-p-1$ 。

遍历所有 $i\in [0,n]$，取能满足的最小 $b_{p+1}$ 即为答案。如果前缀本身就能匹配 $m$ 个，则输出 0，遍历后没有可行解则输出 $-1$。

代码实现

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
    int n, m;
    cin >> n >> m;
    vl a(n + 1);
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    vl b(m + 1);
    for (int i = 1; i <= m; i++)
    {
        cin >> b[i];
    }

    vl pre(n + 1);
    for (int i = 1; i <= n; i++)
    {
        if (pre[i - 1] < m && a[i] >= b[pre[i - 1] + 1])
            pre[i] = pre[i - 1] + 1;
        else
            pre[i] = pre[i - 1];
    }
    if (pre[n] >= m)
    {
        cout << 0 << "\n";
        return;
    }

    vl suf(n + 2);
    for (int i = n; i >= 1; i--)
    {
        if (suf[i + 1] < m && a[i] >= b[m - suf[i + 1]])
            suf[i] = suf[i + 1] + 1;
        else
            suf[i] = suf[i + 1];
    }

    ll ans = infll;
    for (int i = 0; i <= n; i++)
    {
        if (pre[i] >= m)
            continue;
        if (suf[i + 1] >= m - pre[i] - 1)
            ans = min(ans, b[pre[i] + 1]);
    }

    if (ans == infll)
        ans = -1;
    cout << ans << "\n";
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：

---

E. Wolf

题目大意

有一个长度为 $n$ 的排列 $p$ ，以及 $q$ 次独立查询。每次查询给定区间 $[l,r]$ 和目标值 $x$。在对这个区间上模拟二分查找时，如果当前中点值与 $x$ 比较的结果和数组实际顺序不一致，就会失败。允许在查询前任意选取 $d$ 个 不是 $x$ 的下标，将它们对应的值重新任意重排，来保证查找成功。求每次查询的最小 $d$，若无法通过任何重排成功则输出 $-1$。

解题思路

阅读理解题，理解题意后不难。

首先预处理出每个值在排列中的位置，对 $i=1,2,\dots ,n$ 记录 $pos[i]$。

对于每个查询 $L,R,x$，令 $k=\text{pos}[x]$，若 $k\notin [L,R]$ 则直接输出 $-1$，否则在区间 $[l=L,r=R]$ 上模拟二分查找，维护4个值：

$cnt0$ ：访问到且无需替换的 $p[mid]<x$ 次数

$cnt1$ ：访问到且无需替换的 $p[mid]>x$ 次数

$cntL$ ：必须将 $p[mid]$ 当作 > $x$ 来替换的次数

$cntR$ ：必须当作 < $x$ 来替换的次数

令 $l=L,R=r,mid=\frac{l+r}{2}$

• 当 $mid<k$ 且 $p[mid]<x$ 时，向右搜索，累加小于 $x$ 的访问数 $cnt0+1$ 。
• 当 $mid<k$ 且 $p[mid]>x$ 时，本来会向右但 $p[mid]$ 又不小于 $x$，因此必须把它当成大于 $x$ 来替换，$cntL+1,cnt1+1$ ，并令 $l=mid+1$ 。
• 当 $mid>k$ 且 $p[mid]>x$ 时，向左搜索，累加大于 $x$ 的访问数 $cnt1+1$ 。
• 当 $mid>k$ 且 $p[mid]<x$ 时，本来会向左但 $p[mid]$ 又不大于 $x$，因此必须把它当成小于 $x$ 来替换， $cntR+1,cnt0+1$ ，并令 $r=mid-1$。

当 $mid=k$ 停止。此时 $cntL$ 是需要替换成大于 $x$ 的次数，$cntR$ 是需要替换成小于 $x$ 的次数，$cnt0$ ／ $cnt1$ 分别是整个过程中访问到的小于／大于 $x$ 的点数。可用的小于 $x$ 的数目为 $(x-1)-cnt0$，可用的大于 $x$ 的数目为 $(n-x)-cnt1$；若它们无法分别覆盖 $\max (0,cntR-cntL)$ 或 $\max (0,cntL-cntR)$ 这两种多余替换需求，就输出 $-1$，否则最少替换次数为 $2\max (cntL,cntR)$。

代码实现

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
void solve()
{
    int n, q;
    cin >> n >> q;
    vi p(n + 1);
    vi pos(n + 1);
    for (int i = 1; i <= n; i++)
    {
        cin >> p[i];
        pos[p[i]] = i;
    }

    while (q--)
    {
        int L, R, x;
        cin >> L >> R >> x;
        int k = pos[x];
        if (k < L || k > R)
        {
            cout << "-1 ";
            continue;
        }

        int l = L, r = R;
        int cntL = 0, cntR = 0, cnt0 = 0, cnt1 = 0;
        vector<bool> vis(n + 1);
        while (l <= r)
        {
            int mid = (l + r) >> 1;
            vis[mid] = true;
            if (mid == k)
                break;
            if (mid < k)
            {
                if (p[mid] < x)
                    cnt0++;
                else
                    cntL++, cnt1++;
                l = mid + 1;
            }
            else
            {
                if (p[mid] > x)
                    cnt1++;
                else
                    cntR++, cnt0++;
                r = mid - 1;
            }
        }

        if (x - 1 - cnt0 < max(0, cntL - cntR) || n - x - cnt1 < max(0, cntR - cntL))
            cout << "-1 ";
        else
            cout << 2 * max(cntL, cntR) << " ";
    }
    cout << '\n';
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：

---

F. Goblin

题目大意

给定二值向量
s = ( s 1 , s 2 , … , s n ) ∈ { 0 , 1 } n , s=(s_1,s_2,\dots,s_n)\in\{0,1\}^n, s=(s1​,s2​,…,sn​)∈{0,1}n,
构造二值矩阵 G ∈ { 0 , 1 } n × n G\in\{0,1\}^{n\times n} G∈{0,1}n×n：
$$G_{i,j}=\{\begin{array}{ll}1-s_i,& i=j,\\ s_j,& i\ne j.\end{array}$$
视矩阵中值为 0 的单元格以四连通（上下左右）方式连通，求这些连通分量中的最大的联通分量大小。

解题思路

对于每个下标 $j$ 满足 $s_j=0$，将该列分为三部分：

• 上半段：所有 $G_{i,j}$ 使 $1\le i<j$；共 $j-1$ 个格子，记作节点 $U_j$ ，联通块大小为 $j-1$ 。
• 下半段：所有 $G_{i,j}$ 使 $ j$；共 $n-j$ 个格子，记作节点 $D_j$ ，联通块大小为 $n-j$ 。

对于每个下标 $j$ 满足 $s_j=1$ ， $G_{j,j}$ 为零，记作节点 $T_j$，联通块大小为 1。

对于每个 $1\le j<n$，若 $s_j=s_{j+1}=0$，则：

• 合并 $U_j$ 与 $U_{j+1}$（它们在行方向上上下段相连）
• 合并 $D_j$ 与 $D_{j+1}$ （同理）

对每个 $j$ 使 $s_j=1$：

• 若 $j>1$ 且 $s_{j-1}=0$，合并 $T_j$ 与 $D_{j-1}$ ， $G_{j,j}$ 可向左下连通。
• 若 $j<n$ 且 $s_{j+1}=0$，合并 $T_j$ 与 $U_{j+1}$ ， $G_{j,j}$ 可向右上连通。

所有列遍历合并后，遍历所有联通分量，联通分量大小最大值即为答案。

代码实现

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL

struct DSU
{
    vector<int> f;  // 父节点
    vector<ll> siz; // 按秩（近似）维护子树大小，用于合并优化

    DSU() {}
    DSU(int n) { init(n); }

    // 初始化并查集，n 为节点总数
    void init(int n)
    {
        f.resize(n);
        iota(f.begin(), f.end(), 0);
        siz.assign(n, 1);
    }

    // 路径压缩查找根
    int find(int x)
    {
        while (x != f[x])
            x = f[x] = f[f[x]];
        return x;
    }

    // 合并两个集合，并把权重累加到新的根
    bool merge(int x, int y)
    {
        x = find(x);
        y = find(y);
        if (x == y)
            return false;
        // 保证 siz[x] >= siz[y]
        if (siz[x] < siz[y])
            swap(x, y);
        f[y] = x;
        siz[x] += siz[y];
        return true;
    }

    ll size(int x)
    {
        return siz[find(x)];
    }
};
void solve()
{
    int n;
    string s;
    cin >> n >> s;
    vi U(n, -1);
    vi D(n, -1);
    vi T(n, -1);
    int idx = 0;
    for (int j = 0; j < n; j++)
    {
        if (s[j] == '0')
        {
            U[j] = idx++;
            D[j] = idx++;
        }
        else
        {
            T[j] = idx++;
        }
    }

    DSU dsu(idx);
    for (int i = 0; i < n; i++)
    {
        if (s[i] == '0')
        {
            dsu.siz[U[i]] = i;
            dsu.siz[D[i]] = n - i - 1;
        }
    }

    for (int i = 0; i + 1 < n; i++)
    {
        if (s[i] == '0' && s[i + 1] == '0')
        {
            dsu.merge(U[i], U[i + 1]);
            dsu.merge(D[i], D[i + 1]);
        }
    }

    for (int i = 0; i < n; i++)
    {
        if (s[i] == '1')
        {
            int x = T[i];
            if (i - 1 >= 0 && s[i - 1] == '0')
                dsu.merge(x, D[i - 1]);
            if (i + 1 < n && s[i + 1] == '0')
                dsu.merge(x, U[i + 1]);
        }
    }

    ll ans = 0;
    for (int i = 0; i < idx; i++)
    {
        if (dsu.find(i) == i)
            ans = max(ans, dsu.size(i));
    }

    cout << ans << "\n";
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：

---

G1. Baudelaire (easy version)

题目大意

给定一棵特殊的树（简单版本条件）树，树中每个节点都与节点 1 相连，但节点 1 不一定是根，共有 $n$ 个节点。每个节点有一个初始权值，只有两种可能： $+1$ 或 $-1$。

树有一个隐藏的根节点 $\text{rt}$，定义 $f(u)={\sum }_{x\in \text{rt}⇝u}\text{val}[x]$ ，即为从根到节点 $u$ 路径上所有节点权值之和。

你可以进行两种交互式操作，总次数不能超过 $n+200$：

1. ? 1 k a_1 a_2 … a_k，会返回 $f(a_1)+f(a_2)+\dots +f(a_k)$ 。
2. ? 2 u，将节点 $u$ 的权值从 $+1$ ↔ $-1$ 互换，为永久修改。

在交互结束后，你要输出所有节点最终的权值。

解题思路

询问? 1 1 1 得到$F_0=f(1).$

接着对每个 $v=2,3,\dots ,n$ 分别询问 ? 1 1 v 得到 $F_0(v)=f(v).$

由于树为星形，类似菊花图，如果 $v\ne \mathrm{rt}$，必有 $f(v)=f(1)+\mathrm{val}(v)⟹\mathrm{val}(v)=F_0(v)-F_0.$ ，当 $v=\mathrm{rt}$ 时上述等式不成立，需要后续操作加以区分。

发送? 2 1，将节点 1 的权值取反，再次发送? 1 1 1得到$F_1=f^{\prime }(1).$

设翻转前 $\mathrm{val}(1)=x$，隐藏根的权值为 $\mathrm{val}(\mathrm{rt})$，则 $F_0=\mathrm{val}(\mathrm{rt})+x,F_1=\mathrm{val}(\mathrm{rt})-x⟹x=\frac{F_0-F_1}{2}$ ，此时节点 1 的最终权值为 $-x$。

如果 $F_0=x$ ， 则隐藏根即为 1，此时直接令$\mathrm{val}(1)=-x,\mathrm{val}(v)=F_0(v)-F_0(v\ge 2)$ 。

如果 $F_0\ne x$ ， 则隐藏根即不为 1，它在集合 $2,3,\dots ,n$ 中。

假设对叶子进行翻转，那么路径和应该为 $\mathrm{pre}(v)=F_0(v)-2x.$

令候选集合 C = { x i } C=\{x_i\} C={xi​}，初始时 $x_i=i+1,1\le i\le n-1$ 。

进行二分，取一半候选集合为 S = { x i } , 1 ≤ i < ∣ C ∣ 2 S=\{x_i\} ,1\le i\lt \frac{|C|}{2} S={xi​},1≤i<2∣C∣​ ，另一半为 $T={x_i},\frac{|C|}{2}\le i\le |C| $

询问? 1 |S| S，得到实测总和 $real$，计算预测总和 $ex={\sum }_{v\in S}f(v)$ 。

如果 $real-ex=2x$ ， 则根在集合 $S$，否则在 $T$。更新 $C$ 为对应子集，直到 $|C|=1$ 。此时唯一元素即为隐藏根，再令 $\mathrm{val}(\mathrm{rt})=F_0-x$ ， 连同先前存储的其他节点 $\mathrm{val}(v)$ 一并输出。

最多查询次数 $1+(n-1)+1+1+\lceil {\log }_2(n-1)\rceil \le n+12<n+200$ 。

代码实现

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL
ll op1(const vi &v)
{
    int n = v.size();
    cout << "? 1 " << n << " ";
    for (int i = 0; i < n; i++)
    {
        cout << v[i] << " \n"[i == n - 1];
    }
    cout << flush;
    ll res;
    cin >> res;
    return res;
}

void op2(int u)
{
    cout << "? 2 " << u << "\n";
    cout << flush;
}

void solve()
{
    int n;
    cin >> n;
    for (int i = 1; i < n; i++)
    {
        int u, v;
        cin >> u >> v;
    }

    ll f0 = op1({1});
    vl f(n + 1);
    for (int i = 2; i <= n; i++)
    {
        f[i] = op1({i});
    }
    op2(1);
    ll f1 = op1({1});
    ll x = (f0 - f1) / 2;
    vl ans(n + 1);
    ans[1] = -x;
    for (int i = 2; i <= n; i++)
    {
        ans[i] = f[i] - f0;
    }
    if (f0 == x)
    {
        cout << "! ";
        for (int i = 1; i <= n; i++)
        {
            cout << ans[i] << " \n"[i == n];
        }
        cout << flush;
        return;
    }
    vi C;
    for (int i = 2; i <= n; i++)
    {
        C.push_back(i);
    }

    auto calc = [&](int v) -> ll
    {
        return f[v] - 2 * x;
    };

    while (C.size() > 1)
    {
        int m = C.size() / 2;
        vi S(C.begin(), C.begin() + m);
        ll sum = 0;
        for (auto &x : S)
        {
            sum += calc(x);
        }
        ll aim = S.empty() ? 0 : op1(S);
        if (aim == sum)
            C.erase(C.begin(), C.begin() + m);
        else
            C.resize(m);
    }
    int rt = C[0];
    ans[rt] = f0 - x;
    cout << "! ";
    for (int i = 1; i <= n; i++)
    {
        cout << ans[i] << " \n"[i == n];
    }
    cout << flush;
}

int main()
{
    ios::sync_with_stdio(false), std::cin.tie(0);
    // freopen("test.in", "r", stdin);
    // freopen("test.out", "w", stdout);
    int _ = 1;
    std::cin >> _;
    while (_--)
    {
        solve();
    }
    return 0;
}

/*######################################END######################################*/
// 链接：

---

G2. Baudelaire (hard version)

题目大意

与简单版本相比，树不再有特殊形式，不一定所有节点都与点 1 相连，其它不变。

解题思路

其实大体上与简单版本思路相同，只不过增加了一步重心分治

整套方案与简单版本一样分为两部分：确定根、恢复权值。

先解释单个节点 $u$ 的“邻居二分”原理。设 $p_u$ 为父亲，其余相邻节点记作 $c_1,c_2,\dots ,c_k$。翻转 $u$ 后，父亲的路径和保持 $s_{p_u}$ 不变，而每个非父亲邻居的路径和统一变化 $\pm 2$，于是有

$s_{c_i}^{\prime }-s_{c_i}=\pm 2(i\ne p_u),s_{p_u}^{\prime }-s_{p_u}=0.$

若一次查询某个邻居子集 $\Sigma$ 的路径和并记为 $S_1$，翻转 $u$ 再查询同一子集得到 $S_2$，则差值满足

$|S_1-S_2|=\{\begin{array}{ll}2|\Sigma |,& p_u\notin \Sigma ,\\ <2|\Sigma |,& p_u\in \Sigma .\end{array}$

因此用二分法：把邻居按任意顺序分成左右两段，三次查询（求和、翻转、再求和）即可判断父亲在哪一侧，重复 $\lceil {\log }_{2}k\rceil$ 轮后得到唯一父亲；若过程中发现邻居集合为空，则 $u$ 本身即为根。一次找父亲总查询次数为 $3\log k$。

要保证总查询量不超标，需要在小而优的节点上调用“找父亲”。树的重心 $c$ 具有删除后所有连通块大小 $\le \frac{|S|}{2}$ 的性质，其中 $|S|$ 是当前候选根集合大小。取当前候选集合的重心 $c$ 并对 $c$ 执行上述二分：
若找不到父亲，则 $c$ 就是真根；若找到父亲 $p_c$，真实根必位于包含 $p_c$ 的那一侧，只需一次 DFS 将另一侧整块节点标记为非候选。候选集合大小至少减半，所以重心过程至多进行 $\lceil {\log }_{2}n\rceil$ 轮；每轮用到的查询数上界为 $3\log (\mathrm{deg}c)$，当 $n\le 1000$ 时总计严格小于 $165$ 。

根 $rt$ 确定后，再对每个结点单点查询一次? 1 1 u即可得到所有路径和 $s_u$，共用 $n$ 次查询。随后 DFS 构建父子关系并利用$v_r=s_r,v_u=s_u-s_{p_u}(u\ne r)$ ，就能还原整棵树的最终取值，它们必然落在 $+1,-1$，因为对真实父子边 $(p,u)$ 有 s u − s p u = v u ∈ { ± 1 } s_u-s_{p_u}=v_u\in\{\pm1\} su​−spu​​=vu​∈{±1} 。

总的查询复杂度为 $n+165<n+200$

代码实现

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;

#define inf 0x3f3f3f3f
#define infll 0x3f3f3f3f3f3f3f3fLL

ll op1(const vi &v)
{
    cout << "? 1 " << v.size() << ' ';
    for (int i = 0; i < (int)v.size(); i++)
    {
        cout << v[i] << " \n"[i + 1 == (int)v.size()];
    }
    cout << flush;
    ll res;
    cin >> res;
    return res;
}

void op2(int u)
{
    cout << "? 2 " << u << '\n'
         << flush;
}

void solve()
{
    int n;
    cin >> n;

    vector<vi> adj(n + 1);
    for (int i = 1; i < n; i++)
    {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    vector<bool> sta(n + 1, true);
    vi siz(n + 1);

    // DFS 计算子树大小
    auto dfs1 = [&](auto self, int u, int fa) -> void
    {
        siz[u] = 1;
        for (auto &v : adj[u])
        {
            if (v == fa)
                continue;
            if (sta[v])
            {
                self(self, v, u);
                siz[u] += siz[v];
            }
        }
    };

    // 寻找重心，先算子树大小，随后不断走向“超半子树”
    auto findCentr = [&](int u) -> int
    {
        dfs1(dfs1, u, 0);
        int tot = siz[u];
        int res = u, pa = 0;
        bool moved = true;
        while (moved)
        {
            moved = false;
            for (auto &v : adj[res])
            {
                if (v != pa && sta[v] && siz[v] * 2 > tot)
                {
                    pa = res;
                    res = v;
                    moved = true;
                    break;
                }
            }
        }
        return res; // cur 即重心
    };

    auto hasParent = [&](const vi &seg, int u) -> bool
    {
        if (seg.empty())
            return false;
        ll before = op1(seg);
        op2(u); // 翻转一次
        ll after = op1(seg);
        return llabs(before - after) < 2LL * seg.size();
    };

    // 二分定位 u 的父亲（若返回 0 则 u 为根）,每次判定只 3 次查询，父亲唯一，log(deg) 轮
    auto findParent = [&](int u) -> int
    {
        vi nbr;
        for (auto &v : adj[u])
        {
            if (!sta[v])
                continue;
            nbr.push_back(v);
        }
        if (nbr.empty())
            return 0; // 没邻居 → 根

        vi cand = nbr;
        while (cand.size() > 1)
        {
            int m = cand.size() / 2;
            vi left(cand.begin(), cand.begin() + m);
            if (hasParent(left, u))
                cand.erase(cand.begin() + m, cand.end()); // 父亲在左半
            else
                cand.erase(cand.begin(), cand.begin() + m); // 父亲在右半
        }
        /* 此时 cand.size() == 1 */
        return hasParent({cand[0]}, u) ? cand[0] : 0;
    };

    // 从结点 bad 出发 DFS，把与 keep 不连通的部分.全部标记为“死”（sta=0）。
    auto eraseSide = [&](int bad, int keep) -> void
    {
        vi stk{bad};
        while (!stk.empty())
        {
            int x = stk.back();
            stk.pop_back();
            sta[x] = false; // 删除
            for (auto &v : adj[x])
            {
                if (sta[v] && v != keep)
                    stk.push_back(v);
            }
        }
    };

    // 重心分治 + 二分找父  来锁定真实根, 最坏 query ≈ 3 Σ log(deg) ≤ 165
    int rt = -1;
    while (true)
    {
        int entry = int(find(sta.begin() + 1, sta.end(), true) - sta.begin());
        int cen = findCentr(entry); // 当前重心
        int par = findParent(cen);  // 父亲 (0 ⇒ cen 为根)

        if (!par)
        {
            rt = cen;
            break;
        } // 已确定根
        eraseSide(cen, par); // 只保留父亲那一侧
    }

    // 单点查询所有 sum_u , n 次查询
    vl sum(n + 1);
    for (int i = 1; i <= n; i++)
    {
        sum[i] = op1({i});
    }

    // DFS得到 父节点p数组
    vi p(n + 1);
    auto dfs2 = [&](auto self, int u, int fa) -> void
    {
        p[u] = fa;
        for (auto &v : adj[u])
        {
            if (v == fa)
                continue;
            self(self, v, u);
        }
    };
    dfs2(dfs2, rt, 0);

    // 根据前缀和差分出结点实际取值
    vi ans(n + 1);
    ans[rt] = sum[rt];
    for (int i = 1; i <= n; i++)
    {
        if (i == rt)
            continue;
        ans[i] = sum[i] - sum[p[i]];
    }

    cout << "! ";
    for (int i = 1; i <= n; i++)
    {
        cout << ans[i] << " \n"[i == n];
    }
    cout << flush;
}

int main()
{
    ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);

    int _ = 1;
    cin >> _;
    while (_--)
        solve();
    return 0;
}

/*######################################END######################################*/
// 链接：

---

G题挺有意思的，一开始想直接开G2，想了一会没思路，然后回头开G1，模拟玩了一下，想到可以集合二分判根，写了一下就过了。挺有意思的交互题。