codeforces 870d Something with XOR Queries

http://www.elijahqi.win/archives/1294
This is an interactive problem.

Jury has hidden a permutation p of integers from 0 to n - 1. You know only the length n. Remind that in permutation all integers are distinct.

Let b be the inverse permutation for p, i.e. pbi = i for all i. The only thing you can do is to ask xor of elements pi and bj, printing two indices i and j (not necessarily distinct). As a result of the query with indices i and j you’ll get the value , where denotes the xoroperation. You can find the description of xor operation in notes.

Note that some permutations can remain indistinguishable from the hidden one, even if you make all possible n2 queries. You have to compute the number of permutations indistinguishable from the hidden one, and print one of such permutations, making no more than 2nqueries.

The hidden permutation does not depend on your queries.

Input
The first line contains single integer n (1 ≤ n ≤ 5000) — the length of the hidden permutation. You should read this integer first.

Output
When your program is ready to print the answer, print three lines.

In the first line print “!”.

In the second line print single integer answers_cnt — the number of permutations indistinguishable from the hidden one, including the hidden one.

In the third line print n integers p0, p1, …, pn - 1 (0 ≤ pi < n, all pi should be distinct) — one of the permutations indistinguishable from the hidden one.

Your program should terminate after printing the answer.

Interaction
To ask about xor of two elements, print a string “? i j”, where i and j — are integers from 0 to n - 1 — the index of the permutation element and the index of the inverse permutation element you want to know the xor-sum for. After that print a line break and make flushoperation.

After printing the query your program should read single integer — the value of .

For a permutation of length n your program should make no more than 2n queries about xor-sum. Note that printing answer doesn’t count as a query. Note that you can’t ask more than 2n questions. If you ask more than 2n questions or at least one incorrect question, your solution will get “Wrong answer”.

If at some moment your program reads -1 as an answer, it should immediately exit (for example, by calling exit(0)). You will get “Wrong answer” in this case, it means that you asked more than 2n questions, or asked an invalid question. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.

Your solution will get “Idleness Limit Exceeded”, if you don’t print anything or forget to flush the output, including for the final answer .

To flush you can use (just after printing line break):

fflush(stdout) in C++;
System.out.flush() in Java;
stdout.flush() in Python;
flush(output) in Pascal;
For other languages see the documentation.
Hacking

For hacking use the following format:

n

p0 p1 … pn - 1

Contestant programs will not be able to see this input.

Examples
input
3
0
0
3
2
3
2
output
? 0 0
? 1 1
? 1 2
? 0 2
? 2 1
? 2 0
!
1
0 1 2
input
4
2
3
2
0
2
3
2
0
output
? 0 1
? 1 2
? 2 3
? 3 3
? 3 2
? 2 1
? 1 0
? 0 0
!
2
3 1 2 0
Note
xor operation, or bitwise exclusive OR, is an operation performed over two integers, in which the i-th digit in binary representation of the result is equal to 1 if and only if exactly one of the two integers has the i-th digit in binary representation equal to 1. For more information, see here.

In the first example p = [0, 1, 2], thus b = [0, 1, 2], the values are correct for the given i, j. There are no other permutations that give the same answers for the given queries.

The answers for the queries are:

,
,
,
,
,
.
In the second example p = [3, 1, 2, 0], and b = [3, 1, 2, 0], the values match for all pairs i, j. But there is one more suitable permutation p = [0, 2, 1, 3], b = [0, 2, 1, 3] that matches all n2 possible queries as well. All other permutations do not match even the shown queries.

我们首先考虑如果有n^2个询问 这时候我们枚举p[0]的值是不是可以得到所有的b数组的值和p数组的值 然后可以验证是否满足答案

因为这是一个排列 所以生成出的值不可以大于等于n 并且最后还要检查下p和b的对应性 因为是排列 所以枚举p[0]都不相同所以 生成的排列一定不相同

#include<cstdio>
#define N 5500
inline int read(){
    int x=0;char ch=getchar();
    while (ch<'0'||ch>'9') ch=getchar();
    while (ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();}
    return x;
}
int n,b[N],p[N],ans[N],map[N][N<<1];
int main(){
    freopen("cf.in","r",stdin);
    n=read();
    for (int i=0;i<n;++i) {printf("? %d %d\n",0,i);fflush(stdout);map[0][n+i]=read();}
    for (int i=0;i<n;++i) {printf("? %d %d\n",i,0);fflush(stdout);map[n][i]=read();}
    int cnt=0;
    for (int x=0;x<n;++x){
        bool flag=false;
        p[0]=x;for (int i=1;i<n;++i) {
            p[i]=x^map[0][n]^map[n][i];if (p[i]>=n) {
                flag=true;break;
            }
        }
        b[0]=x^map[0][n];
        for (int i=1;i<n;++i){
            b[i]=b[0]^map[n][0]^map[0][n+i];if (b[i]>=n) {
                flag=true;break;
            }
        } if (flag) continue;
        flag=false;
        for (int i=0;i<n;++i){
            if (p[b[i]]!=i) {
                flag=true;break;
            }
        }
        if (!flag){
            cnt++;for (int i=0;i<n;++i) ans[i]=p[i];
        }
    }
    printf("!\n%d\n",cnt);
    for (int i=0;i<n;++i) printf("%d ",ans[i]);
    return 0;
}