WC2019 I 君的商店

交互题

一个 01 序列，告诉你其中 1 有奇数个还是偶数个，每次可以给定两个集合 $A$,$B$，系统会告诉你 $A \leq B$ 或者 $B \leq A$

求序列

交互次数要求 $5n + O(log_2 n)$

有一个 subtask 满足原序列是一条从不上升或者不下降的链，要求 $O(log_2n)$

sol：

首先有一个交互次数 $2n + 5n$ 的做法：首先 $2n$ 次找出最大值，最大的那个肯定是 $1$，之后每次问两个还不确定的（$a,b$），$a+b$ 是否大于等于 $1$

如果大于等于，那么 $a,b$ 中较大的是 $1$，否则 $a,b$ 中较小的是 $0$。最后特判一下奇偶性不符的情况即可

然后对于一条链的情况，首先，两个端点一定有一个 1，二分找出一个位置最小的 $x$ 使得 $p[x] + p[x+1] \geq 1$ 即可

分界线那里用奇偶性特判一下 $O(log_2n)$

正解

发现 5n 的部分不太好优化，考虑一边 5n 一边确定一个递增的关系，然后用 logn 次确定那条链

具体地，可以从三个数 $(x,y,z)$ 开始，先比较 $x,y$，不妨设大的那个是 $y$

如果 $x+y \leq z$，则 $x=0$，再找一个 $x$

否则 $y \geq z$，把 $y$ 放到 $z$ 的位置，再找一个 $y$

这样会确定若干个 $0$ ，剩一个比不出去的，和一条递增的链

容易知道比不出去的和链最大值中较大的那个是 $1$，可以直接上二分

二分之后还有一个不确定的分界线和一个比不出去的，$O(1)$ 讨论一下即可

#include <bits/stdc++.h>
#include "shop.h"
#define LL long long
#define rep(i, s, t) for (register int i = s, i##end = t; i <= i##end; ++i)
#define dwn(i, s, t) for (register int i = s, i##end = t; i >= i##end; --i)
using namespace std;
int arr[], brr[];
int ans[], que[], chain[];
int ask(int x, int y) {
    arr[] = x, brr[] = y;
    return query(arr, , brr, );
}
int ask2(int x, int fst, int scd) {
    arr[] = x, brr[] = fst, brr[] = scd;
    return query(arr, , brr, );
}
void find_price(int task_id, int N, int K, int ans[]) {
    auto solvechain = [&](int N, int K) {
        int l = , r = N - , res = N - ;
        while (l <= r) {
            int mid = (l + r) >> ;
            if (ask2(que[N - ], que[mid], que[mid + ]))
                res = mid, r = mid - ;
            else
                l = mid + ;
        }
        int val = res;
        if (K != ((N - res) & ))
            res++;
        rep(i, , res - ) ans[que[i]] = ;
        rep(i, res, N - ) ans[que[i]] = ;
        return val;
    };
    for (int i = ; i < N; ++i) ans[i] = ;
    if (task_id == ) {
        for (int i = ; i < N; ++i) que[i] = i;
        if (ask(N - , ))
            reverse(que, que + N);
        solvechain(N, K);
    } else if (task_id == ) {
        if (N == )
            ans[] = ;
        else if (N == ) {
            int mx = ask(, ) ?  : ;
            ans[mx] = ;
            if (!K)
                ans[!mx] = ;
        } else {
            int dfn = N - , cd = ;
            chain[] = ;
            for (int i = ; i < N; ++i) que[i] = i;
            while (dfn > ) {
                if (!ask2(chain[cd - ], que[dfn], que[dfn - ])) {
                    if (!ask(que[dfn], que[dfn - ]))
                        swap(que[dfn], que[dfn - ]);
                    ans[que[dfn]] = ;
                } else {
                    if (ask(que[dfn], que[dfn - ]))
                        swap(que[dfn], que[dfn - ]);
                    chain[cd++] = que[dfn];
                }
                dfn--;
            }
            if (ask(que[dfn], chain[cd - ])) {
                ans[chain[cd - ]] = ;
                int cmx = que[dfn];
                dfn = cd;
                for (int i = ; i < cd; ++i) que[i] = chain[i];
                int cur = solvechain(dfn, K);
                K ^= ((dfn - cur - ) & );
                cur = que[cur];
                if (!ask2(chain[cd - ], cmx, cur)) {
                    if (ask(cmx, cur))
                        ans[cmx] = ;
                    else
                        ans[cur] = ;
                } else {
                    if (ask(cur, cmx))
                        ans[cmx] = ;
                    else
                        ans[cur] = ;
                    K ^= ;
                }
                ans[cmx] = K;
            } else {
                ans[que[dfn]] = ;
                chain[cd++] = que[dfn];
                for (int i = ; i < cd; ++i) que[i] = chain[i];
                solvechain(cd, K);
            }
        }
    } else {
        int mx = ;
        for (int i = ; i < N; ++i)
            if (ask(mx, i) == )
                mx = i;
        ans[mx] = ;
        int dfn = ;
        K ^= ;
        for (int i = ; i < N; ++i) {
            if (i == mx)
                continue;
            que[++dfn] = i;
        }
        while (dfn > ) {
            if (ask2(mx, que[dfn], que[dfn - ]) == ) {
                if (ask(que[dfn - ], que[dfn]))
                    swap(que[dfn - ], que[dfn]);
                ans[que[dfn]] = ;
            } else {
                if (!ask(que[dfn - ], que[dfn]))
                    swap(que[dfn - ], que[dfn]);
                ans[que[dfn]] = ;
                K ^= ;
            }
            dfn--;
        }
        if (K && dfn)
            ans[que[dfn]] = ;
    }
}