codeforces 1521C Nastia and a Hidden Permutation

题目大意

交互题，有一个1~n的排列，有两种询问方式
q1：t=1: max(min(x,pi),min(x+1,pj));
q2：t=2: min(max(x,pi),max(x+1,pj));
其中 x的取值范围在1~n-1
要求在 $\lfloor \frac{3}{2}n\rfloor +30$ 的次数内查询得到结论

思路分析

由Q1可知 ，当x = INF的时候，max(min(inf,pi),min(inf,pj)) = min(pi,pj)
由Q2可知，当x= 0 的是时候 min(max(0,pi),max(1,pj)) = max(pi,pj)

然而，考虑到题目中x的取值范围。inf,0都是不可行的解。因此，我们尝试用n-1和1代入

对于大多数情况来说，我们两两分组，查询Q1,Q2求出任意两数的最大值和最小值，此时的复杂度为O(n)

然后为了确定两数之间的顺序，有很多种办法。

第一种：我们找另外两个数，各取其中一个位置再比一下。就可以得出结论。（这个做法的好处是：非常容易想到，缺点是：特殊情况非常多，需要写很多啰嗦的代码）

第二种，我们考虑把两个数中的最小值，再带入Q2中查询一次

我们记 $mq=min(pi,pj)=min(ti,tj)$
$s=min(max(mq,pi),max(mq+1,pj))$
当 pi = mq 时， s = mq;
当pj = mq 是，s = min(mq+1 ,pi) 且 pi >mq的
所以，如果我们询问的结果恰好为mq时，就可以确定 pi = mq;
否认 pj = mq

对于任意两数查询一次，复杂度为O(n/2)

此时会出现两种异常情况

根据Q1 max(min(x-1,pi),min(x,pj)) = n-1时，存在三种情况 pi = n, pi = n-1, pj = n-1

同理可知Q2 也存在这样的特殊情况。
在这种情况下，pi=x 是可以通过交换pi,pj的位置，再查询一次可以获知的。

若交换后查询 max(min(x-1,pj),min(x,pi)) = x ,说明 pi = x 的，否则 (pi,pj) max = n-1

会出现这些情况的组数最多不会超过4组，8个数，因此我们每组查询一边，确定 1,n的位置。
剩余的采用方法二询问一边，

总询问次数应该小于30次

接下来贴一个非常丑陋的代码

#include <bits/stdc++.h>
using namespace std;
struct node{
    int x,y;
    int t1,t2;
    node(int a,int b,int c,int d){
    x = a;
    y= b;
    t1= c;
    t2 = d;
    }
};
vector<node>ans;
vector<node>wait;
const int maxn = 1e4+50;
int num[maxn];
int n;
int checknode(node a){
    if(a.t1 == n){
        num[a.y] =n;
        num[a.x] = a.t2;
        return -1;
    }
    if(a.t2 == 1){
        num[a.x] =1;
        num[a.y] = a.t1;
        return -1;
    }
    if(a.t1 != n-1 && a.t2 != 2){
        return 1;
    }
    return 0;
}

class Game{
public:
    std::vector<int> l;
    Game(int n){
        for(int i=0;i<n;i++){
            l.push_back(i+1);
        }
        unsigned seed = std::chrono::system_clock::now ().time_since_epoch ().count ();
        std::shuffle(l.begin(),l.end(),std::default_random_engine (seed));
        for(int i=0;i<n;i++){
            //printf("%d  ",l[i]);
        }
         //printf("\n");
    }
    Game(std::vector<int> ll){
        l=ll;
    }
public:
    int Q1(int i,int j,int x){
        printf("? 1 %d %d %d\n",i,j,x);
        fflush(stdout);
        int read;
       //printf("%d\n",std::max(std::min(x,l[i-1]),std::min(x+1,l[j-1])));
        /*scanf("%d",&read);
        return read;//*/
        return std::max(std::min(x,l[i-1]),std::min(x+1,l[j-1]));
    }
    int Q2(int i,int j,int x){
        printf("? 2 %d %d %d\n",i,j,x);
        fflush(stdout);
        int read;
        //printf("%d\n",std::min(std::max(x,l[i-1]),std::max(x+1,l[j-1])));
       /* scanf("%d",&read);
        return read;//*/

        return std::min(std::max(x,l[i-1]),std::max(x+1,l[j-1]));
    }
};
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        wait.clear();
        ans.clear();
        Game g(n);
        for(int i =0;i<=n+1;i++){
            num[i] = 0;
        }
        for(int i=1;i<n;i+=2){
            int t1 = g.Q1(i,i+1,n-1);
            int t2 = g.Q2(i,i+1,1);
            node tmp = node(i,i+1,t1,t2);
            int checknum = checknode(tmp);
            if(checknum == 1){
                ans.push_back(tmp);
            }
            else if(checknum == 0){
                wait.push_back(tmp);
            }
           // printf("i=%d,i+1=%d,t1=%d,t2=%d\n",i,i+1,t1,t2);
        }
        int index = 0,con = 0;
        if(ans.size()>1){
            for(int i=0;i<ans.size()-1;i+=2){
                if(checknode(ans[i])&&checknode(ans[i+1])){
                   for(int j = i;j<=i+1;j++){
                        num[ans[j].x] = ans[j].t1;
                        num[ans[j].y] = ans[j].t2;
                   }
                  // printf("x1= %d ,x2 = %d, t1 = %d,t2 = %d\n",ans[i].x,ans[i].y,ans[i].t1,ans[i].t2);
                  // printf("x1= %d ,x2 = %d, t1 = %d,t2 = %d\n",ans[i+1].x,ans[i+1].y,ans[i+1].t1,ans[i+1].t2);
                   int maxofmin =  g.Q1(ans[i].x,ans[i+1].x,n-1);
                   int minofmax = g.Q2(ans[i].x,ans[i+1].x,1);
                  //  printf("x1= %d ,x2 = %d, t1 = %d,t2 = %d\n",ans[i].x,ans[i+1].x,maxofmin,minofmax);
                   if(maxofmin == ans[i].t2||minofmax == ans[i].t2){
                        swap(num[ans[i].x],num[ans[i].y]);
                   }
                   if(maxofmin == ans[i+1].t2||minofmax == ans[i+1].t2){
                        swap(num[ans[i+1].x],num[ans[i+1].y]);
                   }
                }
            }
        }

        for(int i= 0;i<wait.size();i++){
            int t1 = g.Q1(wait[i].y,wait[i].x,n-1);
            int t2 = g.Q2(wait[i].y,wait[i].x,1);
          // printf("x= %d ,y = %d, t1 = %d,t2 = %d\n",wait[i].x,wait[i].y,t1,t2);
            if(t1 == n){
                num[wait[i].x] = n;
                num[wait[i].y] = t2;
                wait[i].t1 = t1;
                wait[i].t2 = t2;

            }
            else if(t2 == 1){
                num[wait[i].y] = 1;
                num[wait[i].x] = t1;
                wait[i].t1 = t1;
                wait[i].t2 = t2;
            }
        }

        if(ans.size()%2 == 1){
            wait.push_back(ans[ans.size()-1]);
        }
       // printf("wait size = %d index = %d, con = %d\n",wait.size(),index,con);
        for(int i=0;i<wait.size();i++){
           // printf("%d\n",i);
            num[wait[i].x] = wait[i].t1;
            num[wait[i].y] = wait[i].t2;
           int minofmax = g.Q2(wait[i].x,wait[i].y,wait[i].t2);
           // printf("x1= %d ,x2 = %d, t1 = %d,t2 = %d\n",wait[i].x,wait[i].y,wait[i].t1,minofmax);
           if(minofmax == wait[i].t2){
                swap(num[wait[i].x],num[wait[i].y]);
           }
        }
        int x = 0;
        for(int i = 1;i<=n;i++)
        {
            x = x^i;
            x = x^num[i];
        }
        if(n%2 == 1){
            num[n] = x;
        }
       // num[n] = x;
        printf("!");
        for(int i = 1;i<=n;i++)
        {
            printf(" %d",num[i]);
        }
        printf("\n");
        fflush(stdout);

    }

    return 0;
}

进阶2

当然，优秀的代码还有更优秀的做法

首先我们可知 min(max(1,pi),max(2,pj)) = max(pi,pj)
假设pi = 1 那么，这个值就应该 = pj
因此我们可以先第一遍找到1的位置

然后遍历，用1带入，就可以找到pj分别等于多少了

复杂度也为O($\frac{3}{2}n$)