QOJ.ac
QOJ
ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
---|---|---|---|---|---|---|---|---|---|
#328179 | #7788. Rook Detection | AFewSuns | AC ✓ | 309ms | 5020kb | C++14 | 4.2kb | 2024-02-15 17:55:03 | 2024-02-15 17:55:03 |
Judging History
answer
#include<bits/stdc++.h>
using namespace std;
namespace my_std{
#define ll long long
#define bl bool
ll my_pow(ll a,ll b,ll mod){
ll res=1;
if(!b) return 1;
while(b){
if(b&1) res=(res*a)%mod;
a=(a*a)%mod;
b>>=1;
}
return res;
}
ll qpow(ll a,ll b){
ll res=1;
if(!b) return 1;
while(b){
if(b&1) res*=a;
a*=a;
b>>=1;
}
return res;
}
#define db double
#define pf printf
#define pc putchar
#define fr(i,x,y) for(register ll i=(x);i<=(y);i++)
#define pfr(i,x,y) for(register ll i=(x);i>=(y);i--)
#define go(u) for(ll i=head[u];i;i=e[i].nxt)
#define enter pc('\n')
#define space pc(' ')
#define fir first
#define sec second
#define MP make_pair
#define il inline
#define inf 8e18
#define random(x) rand()*rand()%(x)
#define inv(a,mod) my_pow((a),(mod-2),(mod))
il ll read(){
ll sum=0,f=1;
char ch=0;
while(!isdigit(ch)){
if(ch=='-') f=-1;
ch=getchar();
}
while(isdigit(ch)){
sum=sum*10+(ch^48);
ch=getchar();
}
return sum*f;
}
il void write(ll x){
if(x<0){
x=-x;
pc('-');
}
if(x>9) write(x/10);
pc(x%10+'0');
}
il void writeln(ll x){
write(x);
enter;
}
il void writesp(ll x){
write(x);
space;
}
}
using namespace my_std;
#define fl fflush(stdout)
ll t,n,L[550],R[550];
bl ck[550][550],c1[550][550],c2[550][550],ans[550][550];
bl nd[550],vis[550],ban[550];
char s[550];
il void query(){
pf("?\n");
fr(i,1,n){
fr(j,1,n) write(ck[i][j]);
enter;
}
fl;
ll tmp=read();
fr(i,1,n){
scanf("%s",s+1);
fr(j,1,n) ck[i][j]=s[j]-'0';
}
}
il void clr(){
fr(i,1,n) nd[i]=vis[i]=ban[i]=0;
fr(i,1,n) fr(j,1,n) ck[i][j]=c1[i][j]=c2[i][j]=ans[i][j]=0;
}
il void report(){
pf("!\n");
fr(i,1,n){
fr(j,1,n) write(ans[i][j]);
enter;
}
fl;
ll tmp=read();
clr();
}
il void solve1(ll x){
fr(i,1,n){
L[i]=1;
R[i]=n;
}
while(1){
bl pd=0;
fr(i,1,n) fr(j,1,n) ck[i][j]=0;
fr(i,1,n){
if(L[i]<R[i]){
pd=1;
ll mid=(L[i]+R[i])/2;
fr(j,L[i],mid) ck[j][i]=1;
}
}
if(!pd) break;
fr(i,1,n) ck[x][i]=1;
query();
fr(i,1,n){
if(L[i]<R[i]){
ll mid=(L[i]+R[i])/2;
if(ck[x][i]) R[i]=mid;
else L[i]=mid+1;
}
}
}
fr(i,1,n) ans[L[i]][i]=1;
report();
}
il void solve2(){
fr(i,1,n) fr(j,1,n) ck[i][j]=0;
fr(i,2,n) ck[i][i]=1;
query();
fr(i,2,n){
if(ck[i][i]) ans[i][i]=1;
else ans[i][1]=1;
}
ll l=1,r=n;
while(l<r){
ll mid=(l+r)>>1;
fr(i,1,n) fr(j,1,n) ck[i][j]=0;
fr(i,1,mid) ck[1][i]=1;
query();
if(ck[1][1]) r=mid;
else l=mid+1;
}
ans[1][l]=1;
report();
}
il void solve3(){
fr(i,1,n){
L[i]=1;
R[i]=n;
}
while(1){
bl pd=0;
fr(i,1,n) fr(j,1,n) ck[i][j]=0;
fr(i,1,n) ban[i]=0;
fr(i,1,n){
if(!nd[i]||L[i]>=R[i]) continue;
pd=1;
ll mid=(L[i]+R[i])/2;
fr(j,L[i],mid) ck[i][j]=ban[j]=1;
ck[i][1]=1;
}
fr(i,1,n) if(!nd[i]&&!vis[i]&&!ban[i]) ck[i][i]=pd=1;
if(!pd) break;
query();
fr(i,1,n){
if(!nd[i]||L[i]>=R[i]) continue;
ll mid=(L[i]+R[i])/2;
if(ck[i][1]) R[i]=mid;
else L[i]=mid+1;
}
fr(i,1,n){
if(!nd[i]&&!vis[i]&&!ban[i]){
if(ck[i][i]) ans[i][i]=1;
else ans[i][1]=1;
vis[i]=1;
}
}
}
fr(i,1,n) if(nd[i]) ans[i][L[i]]=1;
report();
}
int main(){
t=read();
while(t--){
n=read();
fr(i,1,n) fr(j,1,n) ck[i][j]=0;
fr(i,2,n) ck[i][1]=ck[i][i]=1;
query();
fr(i,1,n) fr(j,1,n) c1[i][j]=ck[i][j];
if(!c1[1][1]){
solve1(1);
continue;
}
bl pd=0;
fr(i,1,n) if(!c1[i][i]) pd=1;
if(!pd){
solve2();
continue;
}
fr(i,1,n) fr(j,1,n) ck[i][j]=0;
ck[1][1]=1;
fr(i,2,n){
if(!c1[i][i]) ck[i][i]=ck[1][i]=1;
else ck[i][1]=1;
}
query();
fr(i,1,n) fr(j,1,n) c2[i][j]=ck[i][j];
pd=0;
fr(i,2,n){
if(!c1[i][i]&&!c2[i][1]){
solve1(i);
pd=1;
break;
}
}
if(pd) continue;
fr(i,2,n) if(!c1[i][i]&&c2[i][i]) ans[1][i]=pd=1;
if(!pd){
fr(i,2,n) if(!c1[i][i]&&c2[1][i]) ans[1][1]=1;
}
pd=0;
fr(i,1,n) if(ans[1][i]) pd=1;
if(!pd) nd[1]=1;
else vis[1]=1;
fr(i,2,n) if(!c1[i][i]) nd[i]=1;
solve3();
}
}
/*
2
5
10110
00100
01000
00000
00001
5
01000
00010
01000
10000
10010
*/
这程序好像有点Bug,我给组数据试试?
详细
Test #1:
score: 100
Accepted
time: 1ms
memory: 3884kb
input:
1 3 0 111 101 111 0 111 111 101 0 111 001 110 0
output:
? 000 110 101 ? 110 010 100 ? 000 110 001 ! 010 001 100
result:
ok correct! (1 test case)
Test #2:
score: 0
Accepted
time: 52ms
memory: 3884kb
input:
9898 3 0 111 110 111 0 111 111 111 0 111 111 111 0 111 111 111 0 3 0 111 111 111 0 111 101 111 0 111 111 111 0 011 111 111 0 3 0 111 111 111 0 111 111 111 0 001 111 111 0 3 0 111 101 111 0 101 101 111 0 001 001 110 0 3 0 111 111 010 0 111 111 111 0 111 111 111 0 111 111 011 0 3 0 111 111 111 0 111 1...
output:
? 000 110 101 ? 000 010 001 ? 110 000 000 ? 100 000 000 ! 100 010 001 ? 000 110 101 ? 000 010 001 ? 110 000 000 ? 100 000 000 ! 010 100 001 ? 000 110 101 ? 000 010 001 ? 110 000 000 ! 001 010 001 ? 000 110 101 ? 110 010 100 ? 110 110 001 ! 001 001 100 ? 000 110 101 ? 101 100 001 ? 000 000 110 ? 000 ...
result:
ok correct! (9898 test cases)
Test #3:
score: 0
Accepted
time: 85ms
memory: 3888kb
input:
10000 4 0 1111 1011 1111 1111 0 1111 1111 1111 1111 0 1111 0011 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1110 0 1111 1111 1111 1111 0 1111 1111 1101 1111 0 1111 1111 1111 0111 0 4 0 1111 1011 1111 1111 0 1111 1111 1111 1111 0 1111 0011 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1011 1111...
output:
? 0000 1100 1010 1001 ? 1100 0100 1000 1000 ? 0000 1100 0010 0001 ? 0000 1010 0000 0000 ! 0100 0010 0010 0001 ? 0000 1100 1010 1001 ? 1001 1000 1000 0001 ? 0000 0000 0010 1100 ? 0000 0100 0000 1000 ! 0001 0100 1000 0100 ? 0000 1100 1010 1001 ? 1100 0100 1000 1000 ? 0000 1100 0010 0001 ? 0000 1010 00...
result:
ok correct! (10000 test cases)
Test #4:
score: 0
Accepted
time: 86ms
memory: 3904kb
input:
10000 4 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 4 0 1111 1011 1111 1111 0 1111 1011 1111 1111 0 1111 0011 1111 1110 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1111 0 1111 1011 1101 1111 0 0011 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111...
output:
? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1000 0000 0000 0000 ! 0100 0100 0010 0001 ? 0000 1100 1010 1001 ? 1100 0100 1000 1000 ? 0000 1100 0010 0001 ? 0000 1010 0000 0000 ! 1000 0010 0010 1000 ? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1110 0000 00...
result:
ok correct! (10000 test cases)
Test #5:
score: 0
Accepted
time: 62ms
memory: 3832kb
input:
10000 4 0 1111 1111 1111 1111 0 1111 1011 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1101 1111 0 1111 1111 1111 1111 0 1111 1111 0011 1110 0 1111 1011 0101 1111 0 4 0 1111 1111 1111 1101 0 1111 1011 1111 1110 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1101 1011...
output:
? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1000 0000 0000 0000 ! 1000 1000 0010 0001 ? 0000 1100 1010 1001 ? 1010 1000 0010 1000 ? 0000 0000 1100 0001 ? 0000 0100 1010 0000 ! 0010 1000 0001 1000 ? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1000 0000 00...
result:
ok correct! (10000 test cases)
Test #6:
score: 0
Accepted
time: 73ms
memory: 3888kb
input:
10000 4 0 1111 1111 1111 1111 0 1111 1111 1101 1111 0 0011 1111 1111 1111 0 1111 1111 1111 1111 0 4 0 1111 1111 1111 1110 0 1111 1111 1111 1111 0 1111 1111 1111 0011 0 1111 1011 1111 1111 0 4 0 1111 1111 1111 1110 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 0111 0 4 0 1111 1111 1111...
output:
? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1110 0000 0000 0000 ! 0010 0100 1000 0001 ? 0000 1100 1010 1001 ? 1001 1000 1000 0001 ? 0000 0000 0010 1100 ? 0000 0100 0000 1010 ! 0001 1000 0010 0010 ? 0000 1100 1010 1001 ? 1001 1000 1000 0001 ? 0000 0000 0010 1100 ? 0000 0100 00...
result:
ok correct! (10000 test cases)
Test #7:
score: 0
Accepted
time: 174ms
memory: 4896kb
input:
7368 4 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 4 0 1111 1111 1111 1111 0 1111 1011 1111 1111 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 4 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 0111 1111 1111 1111 0 4 0 1111 1111 1111 ...
output:
? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1000 0000 0000 0000 ! 0100 0100 0010 0001 ? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1000 0000 0000 0000 ! 0100 1000 0010 0001 ? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1000 0000 00...
result:
ok correct! (7368 test cases)
Test #8:
score: 0
Accepted
time: 207ms
memory: 4960kb
input:
10000 9 0 111111111 101111111 110111111 111111111 111101111 111110111 111111111 111111111 111111111 0 111111111 111111111 110111111 111111111 111101111 111110111 111111111 111111111 111111111 0 111111111 111111110 000111111 111111111 000111111 111111111 111111011 111111101 111111111 0 111111111 0001...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111011000 010000000 001000000 100000000 000010000 000001000 100000000 100000000 100000000 ? 000000000 111110000 111110000 000000000 111110000 111110000 000000100 000000010 000000001 ? 000000000 111000000 10...
result:
ok correct! (10000 test cases)
Test #9:
score: 0
Accepted
time: 176ms
memory: 4892kb
input:
10000 5 0 11111 10111 11111 11111 11111 0 11111 10111 11111 11111 11111 0 11111 00011 11111 11111 11110 0 11111 11111 11011 11111 11111 0 8 0 11111111 10111111 11111111 11111111 11110111 11111011 11111111 11111111 0 11111111 10111111 11111111 11111111 11110111 11111011 11111111 11111111 0 11111111 1...
output:
? 00000 11000 10100 10010 10001 ? 11000 01000 10000 10000 10000 ? 00000 11100 00000 00010 00001 ? 00000 10010 00100 00000 00000 ! 10000 00010 10000 00010 10000 ? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11001100 01000000 10000000 10000000 00001000 00000100 10000000 1...
result:
ok correct! (10000 test cases)
Test #10:
score: 0
Accepted
time: 184ms
memory: 4972kb
input:
10000 9 0 111111111 111111111 111111111 111011111 111101111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111101111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100110000 100000000 100000000 000100000 000010000 100000000 100000000 100000000 100000000 ? 000000000 000000000 000000000 111110000 111110000 000001000 000000100 000000010 000000001 ? 000000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #11:
score: 0
Accepted
time: 168ms
memory: 4976kb
input:
10000 4 0 1111 1111 1111 1111 0 1111 1011 1111 1111 0 1111 1111 1111 1111 0 1111 1111 1111 1111 0 6 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 1...
output:
? 0000 1100 1010 1001 ? 0000 0100 0010 0001 ? 1100 0000 0000 0000 ? 1000 0000 0000 0000 ! 1000 1000 0010 0001 ? 000000 110000 101000 100100 100010 100001 ? 000000 010000 001000 000100 000010 000001 ? 111000 000000 000000 000000 000000 000000 ? 110000 000000 000000 000000 000000 000000 ? 100000 00000...
result:
ok correct! (10000 test cases)
Test #12:
score: 0
Accepted
time: 194ms
memory: 4848kb
input:
10000 6 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111...
output:
? 000000 110000 101000 100100 100010 100001 ? 000000 010000 001000 000100 000010 000001 ? 111000 000000 000000 000000 000000 000000 ? 110000 000000 000000 000000 000000 000000 ? 100000 000000 000000 000000 000000 000000 ! 100000 010000 001000 000100 000010 000001 ? 000000000 110000000 101000000 1001...
result:
ok correct! (10000 test cases)
Test #13:
score: 0
Accepted
time: 172ms
memory: 4948kb
input:
10000 6 0 111111 101111 110111 111011 100010 111110 0 111111 101111 110111 111011 100010 111110 0 111111 000111 000111 000111 111101 000111 0 111111 100110 100110 100110 111111 100110 0 111111 011011 011011 011011 111111 011011 0 8 0 11111111 11000110 10100110 11101111 10001110 11111011 10000110 111...
output:
? 000000 110000 101000 100100 100010 100001 ? 111101 010000 001000 000100 100000 000001 ? 000000 111000 111000 111000 000010 111000 ? 000000 100110 100110 100110 000000 100110 ? 000000 100100 100100 100100 000000 100100 ! 100000 000010 000010 000010 100000 000010 ? 00000000 11000000 10100000 1001000...
result:
ok correct! (10000 test cases)
Test #14:
score: 0
Accepted
time: 166ms
memory: 4748kb
input:
10000 6 0 111111 001111 010111 011011 011101 011110 0 111111 010101 111111 000001 000111 000100 0 111111 111111 111111 000000 000000 000000 0 111111 111010 111111 000101 000101 000101 0 111111 111010 111111 000101 000101 000101 0 9 0 011101111 101101111 110101111 111001111 111111111 111100111 111101...
output:
? 000000 110000 101000 100100 100010 100001 ? 111111 010000 001000 000100 000010 000001 ? 111111 111111 111111 000000 000000 000000 ? 111111 111111 000000 000000 000000 000000 ? 111010 111111 000000 000000 000000 000000 ! 111010 000000 000101 000000 000000 000000 ? 000000000 110000000 101000000 1001...
result:
ok correct! (10000 test cases)
Test #15:
score: 0
Accepted
time: 142ms
memory: 4888kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111110111 111111011 111111111 111111110 0 111111111 111111111 111111111 111111111 111111111 111110111 011111011 111111111 011111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 110111011 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100001101 100000000 100000000 100000000 100000000 000001000 000000100 100000000 000000001 ? 111111111 111111111 111111111 111111111 111111111 000000000 111111111 000000000 000000000 ? 111111111 111111111 11...
result:
ok correct! (10000 test cases)
Test #16:
score: 0
Accepted
time: 145ms
memory: 4824kb
input:
10000 7 0 1111111 1111111 1010000 1111111 1111111 1111111 1111111 0 1111111 1011111 1111111 1110111 1111011 1111101 1111110 0 1111000 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 0000000 0100000 0010000 0001000 0000100 0000010 0000001 ? 1111000 0000000 0000000 0000000 0000000 0000000 0000000 ? 1100000 0000000 0000000 0000000 0000000 0000000 0000000 ? 1000000 0000000 0000000 0000000 0000000 0000000 0000000 ! 1000000 ...
result:
ok correct! (10000 test cases)
Test #17:
score: 0
Accepted
time: 155ms
memory: 4844kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111011111 111111111 111111111 111111111 111111111 111111110 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 000000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ? 111110000 000000000 000000000 000000000 000000000 000000000 000000000 000000000 000000000 ? 111000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #18:
score: 0
Accepted
time: 224ms
memory: 4944kb
input:
10000 9 0 010111111 100111111 111111111 111011111 110101111 110110111 110111011 110111101 110111110 0 111111111 111111111 111111111 111111111 111111111 000000000 000000000 000000000 000000000 0 101101110 101101110 111111111 111111111 010010001 010010001 010010001 010010001 010010001 0 010010001 0000...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111111111 111111111 111111111 111111111 111111111 000000000 000000000 000000000 000000000 ? 111111111 111111111 111111111 000000000 000000000 000000000 000000000 000000000 000000000 ? 111111111 101101110 00...
result:
ok correct! (10000 test cases)
Test #19:
score: 0
Accepted
time: 208ms
memory: 4912kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11111111 10110111 11111101 11111111 0 11110111 10111111 11011111 11101111 11111111 11111111 11111101 11111111 0 11111111 11111111 00111111 11110111 11110111 11111111 11110111 11111110 0 11111111 00111111 01110011 00111111 11111111 11111111 00111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11110010 01000000 00100000 00010000 10000000 10000000 00000010 10000000 ? 00000000 11110000 11110000 11110000 00001000 00000100 11110000 00000001 ? 00000000 11000000 10001100 11000000 00000000 00000000 11000000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #20:
score: 0
Accepted
time: 252ms
memory: 4980kb
input:
10000 7 0 1111111 0011111 0101111 0110111 0111011 0111101 0111110 0 1111111 1011111 1111111 1110111 1111111 1111101 1111110 0 1111111 1111101 0010111 1111111 1111101 0010111 0010111 0 1111111 0011111 1111111 0011111 0011111 1010111 1010111 0 1111111 1010101 1111111 1111111 1010101 1010101 1010101 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1111111 0100000 0010000 0001000 0000100 0000010 0000001 ? 0000000 1111000 1111000 1111000 1111000 1111000 1111000 ? 0000000 1100000 1000110 1100000 1100000 1000110 1000110 ? 0000000 1010000 1000100 1010000 1010000 1000100 1000100 ! 0010100 ...
result:
ok correct! (10000 test cases)
Test #21:
score: 0
Accepted
time: 205ms
memory: 4912kb
input:
10000 9 0 010111111 100111111 111111111 110011111 110101111 110110111 110111011 110111101 110111110 0 111111111 111111111 111111111 111111111 111111111 000000000 000000000 000000000 000000000 0 111111111 111111111 111111111 000000000 000000000 000000000 000000000 000000000 000000000 0 000000000 0000...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111111111 111111111 111111111 111111111 111111111 000000000 000000000 000000000 000000000 ? 111111111 111111111 111111111 000000000 000000000 000000000 000000000 000000000 000000000 ? 111111111 111111111 00...
result:
ok correct! (10000 test cases)
Test #22:
score: 0
Accepted
time: 239ms
memory: 4852kb
input:
10000 9 0 111111111 111111111 111111111 100101000 111111111 100001000 111111111 111111111 111111111 0 111111111 101111111 110111111 111011111 111101111 111111111 111111011 111111101 111111110 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 000000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ? 111110000 000000000 000000000 000000000 000000000 000000000 000000000 000000000 000000000 ? 111000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #23:
score: 0
Accepted
time: 236ms
memory: 4896kb
input:
10000 6 0 111111 111111 111111 111011 111101 111110 0 111111 111111 111111 011111 011111 011111 0 111111 111111 111111 111111 000000 000000 0 111111 111111 111111 111111 111111 111111 0 111111 111111 111111 111111 111111 111111 0 7 0 0111111 1011111 1101111 1110111 1111011 1111111 1111111 0 0000000 ...
output:
? 000000 110000 101000 100100 100010 100001 ? 100111 100000 100000 000100 000010 000001 ? 111111 111111 111111 111111 000000 000000 ? 111111 111111 000000 111111 000000 000000 ? 111111 000000 000000 111111 000000 000000 ! 111111 000000 000000 000000 000000 000000 ? 0000000 1100000 1010000 1001000 10...
result:
ok correct! (10000 test cases)
Test #24:
score: 0
Accepted
time: 83ms
memory: 4436kb
input:
10000 5 0 11111 00111 01011 01101 01110 0 11111 10111 11011 11101 11110 0 11111 11111 11111 01111 01111 0 11111 01111 11101 01111 10111 0 11111 11111 01111 11111 11111 0 5 0 11111 10111 11011 11101 11111 0 11111 10111 11011 11111 11101 0 11111 11111 11111 01111 11110 0 11111 01111 11111 01101 11111 ...
output:
? 00000 11000 10100 10010 10001 ? 11111 01000 00100 00010 00001 ? 00000 11100 11100 11100 11100 ? 00000 11000 11000 10010 10010 ? 00000 00000 10000 00000 00000 ! 10000 00100 01000 00001 00010 ? 00000 11000 10100 10010 10001 ? 11110 01000 00100 00010 10000 ? 00000 11100 11100 11100 00001 ? 00000 1100...
result:
ok correct! (10000 test cases)
Test #25:
score: 0
Accepted
time: 143ms
memory: 4388kb
input:
10000 6 0 111111 101111 110111 111111 111011 111110 0 111111 101111 111111 111111 110111 111110 0 111111 010111 010111 101111 111101 111011 0 111111 101111 011011 111111 111111 111101 0 111111 011011 111111 111111 111111 011111 0 6 0 111111 111111 110111 111011 111101 111110 0 111111 110111 111111 1...
output:
? 000000 110000 101000 100100 100010 100001 ? 111001 010000 001000 100000 100000 000001 ? 000000 111000 111000 000100 000010 111000 ? 000000 100110 100110 000000 000000 110000 ? 000000 100100 000000 000000 000000 100000 ! 001000 000010 000001 000100 100000 010000 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #26:
score: 0
Accepted
time: 118ms
memory: 4436kb
input:
10000 7 0 1111111 1111111 1101111 1110111 1111011 1111101 1011111 0 1111111 1111111 1101111 1110111 1111111 1111101 1111011 0 1111111 1111111 0011111 1111111 1111111 0011111 1111110 0 1111111 1111111 1111111 0011111 0011111 0111011 1111111 0 1111111 1101111 0111011 1011111 0111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1011110 1000000 0010000 0001000 0000100 0000010 1000000 ? 0000000 0000000 1111000 1111000 1111000 1111000 0000001 ? 0000000 0000000 1000110 1100000 1100000 1000110 0000000 ? 0000000 0100000 1000100 1010000 1010000 0000000 0000000 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #27:
score: 0
Accepted
time: 252ms
memory: 4968kb
input:
10000 8 0 11111111 00111111 01011111 01101111 01110111 01111011 01111101 01111110 0 11111111 10111111 11011111 11101111 11110111 11111011 11111101 11111110 0 11111111 01111111 01111111 11111111 01111111 11111111 01111111 11111111 0 11111111 01111111 10111111 11110011 01111111 01111111 10111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11111111 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ? 00000000 11110000 11110000 11110000 11110000 11110000 11110000 11110000 ? 00000000 10001100 10001100 11000000 10001100 11000000 10001100 11000000 ? 00...
result:
ok correct! (10000 test cases)
Test #28:
score: 0
Accepted
time: 217ms
memory: 4972kb
input:
10000 8 0 11111111 10111111 11011111 11110100 11111100 11111011 11110110 11110101 0 11111111 10111111 11111111 11011111 11111111 11111011 11111111 11111111 0 11111111 01011111 11110100 11111111 10101100 11110100 10100110 10100101 0 11111111 10111111 11111011 11101111 11111111 01111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11100100 01000000 00100000 10000000 10000000 00000100 10000000 10000000 ? 00000000 11110000 11110000 00000000 00001000 11110000 00000010 00000001 ? 00000000 10001100 11000000 00010000 00000000 11000000 00000000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #29:
score: 0
Accepted
time: 210ms
memory: 4900kb
input:
10000 8 0 11111111 10111111 11011111 11111011 11110111 11111111 11111101 11111110 0 11111111 10111111 11011111 11110111 11111111 11111111 11111101 11111110 0 11111111 11111011 11111011 11111111 01111111 10001111 01111111 11111011 0 11111111 01111111 11111111 11101111 01110011 11111111 01110011 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11101011 01000000 00100000 10000000 00001000 10000000 00000010 00000001 ? 00000000 11110000 11110000 00000000 11110000 00000100 11110000 11110000 ? 00000000 11000000 11000000 00010000 10001100 00000000 10001100 11000000 ? 00...
result:
ok correct! (10000 test cases)
Test #30:
score: 0
Accepted
time: 239ms
memory: 4964kb
input:
10000 8 0 11111111 10111111 11101101 11011101 11110111 11001101 11001111 11111110 0 11111111 10111111 11111111 11111111 11110111 11111110 11111111 11111111 0 11111111 01001111 11111111 11111111 11111101 11111011 10111111 01001111 0 11111111 10001111 10100011 10010011 11000011 11111111 11111111 10001...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11001001 01000000 10000000 10000000 00001000 10000000 10000000 00000001 ? 00000000 11110000 00000000 00000000 11110000 00000100 00000010 11110000 ? 00000000 10001100 00100000 00010000 11000000 00000000 00000000 10001100 ? 00...
result:
ok correct! (10000 test cases)
Test #31:
score: 0
Accepted
time: 224ms
memory: 4956kb
input:
10000 8 0 11111111 00111111 01011111 01101111 01110111 01111011 01111101 01111110 0 11111111 10111111 11011111 11101111 11110111 11111011 11111101 11111110 0 11111111 11111111 01111111 01111111 11111111 01111111 01111111 11111111 0 11111111 01111111 01111111 01111111 11110011 10111111 10111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11111111 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ? 00000000 11110000 11110000 11110000 11110000 11110000 11110000 11110000 ? 00000000 11000000 10001100 10001100 11000000 10001100 10001100 11000000 ? 00...
result:
ok correct! (10000 test cases)
Test #32:
score: 0
Accepted
time: 286ms
memory: 4912kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111111111 111110111 111111011 111111101 111111110 0 111111111 111111111 110111111 111011111 101111111 111110111 111111011 111111101 111111110 0 111111111 001111111 001111111 111111111 111111111 001111111 111111111 111111111 001111111 0 111111111 1101...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111101111 010000000 001000000 000100000 100000000 000001000 000000100 000000010 000000001 ? 000000000 111110000 111110000 111110000 000000000 111110000 111110000 111110000 111110000 ? 000000000 100001100 10...
result:
ok correct! (10000 test cases)
Test #33:
score: 0
Accepted
time: 248ms
memory: 4956kb
input:
10000 9 0 111111111 111111111 010111111 011011111 011101111 011110111 011111011 011111101 011111110 0 111111111 111111111 110111111 111011111 111101111 111110111 111111011 111111101 111111110 0 111111111 111111111 111111111 001111111 001111111 111111111 001111111 001111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101111111 100000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ? 000000000 000000000 111110000 111110000 111110000 111110000 111110000 111110000 111110000 ? 000000000 000000000 11...
result:
ok correct! (10000 test cases)
Test #34:
score: 0
Accepted
time: 296ms
memory: 4896kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111111111 111110111 111111011 111111101 111111110 0 111111111 101111111 110111111 111111111 111011111 111110111 111111011 111111101 111111110 0 111111111 011011111 111111111 111111111 111111111 011011111 011011111 111111111 011011111 0 111111111 1001...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111101111 010000000 001000000 000100000 100000000 000001000 000000100 000000010 000000001 ? 000000000 111110000 111110000 111110000 000000000 111110000 111110000 111110000 111110000 ? 000000000 100001100 11...
result:
ok correct! (10000 test cases)
Test #35:
score: 0
Accepted
time: 239ms
memory: 4964kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111111 111111111 110111111 111011111 111101111 111110111 101111111 111111101 111111110 0 111111111 001111111 111111111 001111111 111111111 111111111 111111011 001111111 001111111 0 111111111 0111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111111011 010000000 001000000 000100000 000010000 000001000 100000000 000000010 000000001 ? 000000000 111110000 111110000 111110000 111110000 111110000 000000100 111110000 111110000 ? 000000000 100001100 11...
result:
ok correct! (10000 test cases)
Test #36:
score: 0
Accepted
time: 279ms
memory: 4896kb
input:
10000 9 0 111111111 111111011 110111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111111 111101111 110111111 111011111 111111111 111110111 111111111 111111101 111111110 0 111111111 111111111 011101111 011101111 111111011 011101111 100011111 111111011 111111011 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101111011 100000000 001000000 000100000 000010000 000001000 100000000 000000010 000000001 ? 000000000 000000000 111110000 111110000 111110000 111110000 000000100 111110000 111110000 ? 000000000 000000000 10...
result:
ok correct! (10000 test cases)
Test #37:
score: 0
Accepted
time: 157ms
memory: 4412kb
input:
10000 7 0 1111111 1011111 1111111 1110111 1111011 1111101 1111110 0 1111111 0011011 1111111 1110111 1111111 1111101 1111110 0 1111111 1010101 1111111 1111111 1111111 1111111 1111111 0 1010111 0111100 1111111 1111111 1111011 1111111 1111111 0 0110111 1011100 1111111 1111111 0111011 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1101111 0100000 1000000 0001000 0000100 0000010 0000001 ? 1111111 1111111 1111111 1111111 0000000 0000000 0000000 ? 1010101 1111111 0000000 0000000 0101010 0101010 0000000 ? 0010100 1111111 1000001 0000000 0101000 0000000 0000000 ! 0010100 ...
result:
ok correct! (10000 test cases)
Test #38:
score: 0
Accepted
time: 113ms
memory: 4444kb
input:
10000 8 0 11111111 10111111 11111111 11111111 11110111 11111011 11111101 11111110 0 11111111 11111111 11111111 11111111 11110111 11111011 11111101 11111110 0 11111111 11111111 11111111 11111111 00111111 00111111 11111111 00111111 0 11111111 00111111 11011111 11111011 11111111 01110111 00111111 01110...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11001111 01000000 10000000 10000000 00001000 00000100 00000010 00000001 ? 00000000 11110000 00000000 00000000 11110000 11110000 11110000 11110000 ? 00000000 11000000 00100000 00010000 10001100 10001100 11000000 10001100 ? 00...
result:
ok correct! (10000 test cases)
Test #39:
score: 0
Accepted
time: 164ms
memory: 4376kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11110111 11111011 11111111 11111110 0 11111111 10111111 11111111 11101111 11110111 11111111 11111111 11111111 0 11111111 11111111 01111111 01111111 01111111 11111111 11111101 11111111 0 11111111 01111111 10111111 10111111 01111111 11110111 11111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11111101 01000000 00100000 00010000 00001000 00000100 10000000 00000001 ? 00000000 11110000 11110000 11110000 11110000 11110000 00000010 11110000 ? 00000000 11000000 10001100 10001100 10001100 11000000 00000000 11000000 ? 00...
result:
ok correct! (10000 test cases)
Test #40:
score: 0
Accepted
time: 116ms
memory: 4388kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11110111 11111111 11111101 11111101 0 11111111 10111111 11111111 11101111 11110111 11111111 11111101 11111101 0 11111111 01011111 11111101 01011111 11111101 11111111 01011111 11111110 0 11111111 11111101 01111111 11111101 11111101 11111111 01111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11111010 01000000 00100000 00010000 00001000 10000000 00000010 10000000 ? 00000000 11110000 11110000 11110000 11110000 00000100 11110000 00000001 ? 00000000 10001100 11000000 10001100 11000000 00000000 10001100 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #41:
score: 0
Accepted
time: 239ms
memory: 4852kb
input:
10000 9 0 111111111 111110111 010111111 011011111 111111111 111111111 011111011 011111101 011111110 0 111111111 111111111 110111111 111011111 111111111 111111111 111111011 111111101 111111110 0 111111111 111111111 011011111 011011111 111111111 110111111 111111111 111110111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101100111 100000000 001000000 000100000 100000000 100000000 000000100 000000010 000000001 ? 000000000 000000000 111110000 111110000 000000000 000001000 111110000 111110000 111110000 ? 000000000 000000000 10...
result:
ok correct! (10000 test cases)
Test #42:
score: 0
Accepted
time: 228ms
memory: 4952kb
input:
10000 9 0 111111111 110111101 101111101 100111101 111101111 100111101 111111011 111111101 111111111 0 111101001 111111111 111111111 111111111 111101111 111111101 111111011 111111101 111111111 0 000011111 111111111 111111111 111111111 000011111 111110111 111111101 000011111 111111111 0 011111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100010110 100000000 100000000 100000000 000010000 100000000 000000100 000000010 100000000 ? 111110000 000000000 000000000 000000000 111110000 000001000 111110000 111110000 000000001 ? 100001100 000000000 00...
result:
ok correct! (10000 test cases)
Test #43:
score: 0
Accepted
time: 210ms
memory: 4952kb
input:
10000 9 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111101 111111110 0 101000100 101111111 111111111 111011111 111101111 111110111 111111111 111111101 111111110 0 111111111 111111111 111111111 111111111 011111111 111111111 111111011 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110111011 010000000 100000000 000100000 000010000 000001000 100000000 000000010 000000001 ? 111110000 111110000 000000000 111110000 111110000 111110000 000000100 111110000 111110000 ? 111000000 111000000 00...
result:
ok correct! (10000 test cases)
Test #44:
score: 0
Accepted
time: 128ms
memory: 4360kb
input:
10000 7 0 1111111 1111111 1101111 1110111 1111011 1111111 1111110 0 1111111 1111111 1101111 1111111 1111011 1111111 1111110 0 1111111 1111111 1111111 0111111 1111111 1111101 0111111 0 1111111 1111111 1111111 1111111 0111111 1111111 1111111 0 1111111 1111111 0111111 0111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1011101 1000000 0010000 0001000 0000100 1000000 0000001 ? 0000000 0000000 1111000 1111000 1111000 0000010 1111000 ? 0000000 0000000 1100000 1000110 1100000 0000000 1000110 ? 0000000 0100000 1000000 1000100 1010000 0000000 1000100 ! 0001000 ...
result:
ok correct! (10000 test cases)
Test #45:
score: 0
Accepted
time: 163ms
memory: 4428kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11111011 11111101 11111110 0 11111111 11111111 11011111 11101111 11111111 11111111 11111101 11111110 0 11111111 11111111 01111111 01111111 11110111 11111111 11111111 11111111 0 11111111 11111111 01111011 10111111 11111111 11110111 01111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10110111 10000000 00100000 00010000 10000000 00000100 00000010 00000001 ? 00000000 00000000 11110000 11110000 00001000 11110000 11110000 11110000 ? 00000000 00000000 10001100 10001100 00000000 11000000 11000000 11000000 ? 00...
result:
ok correct! (10000 test cases)
Test #46:
score: 0
Accepted
time: 100ms
memory: 4392kb
input:
10000 8 0 11111111 00111111 11111111 01101111 11111111 01111011 01111101 11111111 0 11111111 10111111 11111111 11101111 11111111 11111011 11111101 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 01111111 10101111 0 11111111 01111111 11111111 11111111 11111111 01111111 10111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11010110 01000000 10000000 00010000 10000000 00000100 00000010 10000000 ? 00000000 11110000 00000000 11110000 00001000 11110000 11110000 00000001 ? 00000000 11000000 00100000 11000000 00000000 11000000 10001100 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #47:
score: 0
Accepted
time: 113ms
memory: 4456kb
input:
10000 8 0 11111111 10111111 11011111 11111111 11110111 11111011 11111101 11111110 0 11111111 10111111 11011111 11111111 11110111 11111111 11111101 11111110 0 11111111 11111111 01101111 11111111 11111111 01101111 01101111 11111111 0 11111111 01111111 10111111 11101111 11111111 10111111 11111111 01111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11101111 01000000 00100000 10000000 00001000 00000100 00000010 00000001 ? 00000000 11110000 11110000 00000000 11110000 11110000 11110000 11110000 ? 00000000 11000000 10001100 00010000 11000000 10001100 10001100 11000000 ? 00...
result:
ok correct! (10000 test cases)
Test #48:
score: 0
Accepted
time: 309ms
memory: 4912kb
input:
10000 9 0 111111111 101111111 110111111 111011111 111101111 111110111 111111111 111111101 111111111 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111101 111111111 0 111111111 001111111 001111111 111111111 001111111 111111111 111111011 111111111 111111110 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111111010 010000000 001000000 000100000 000010000 000001000 100000000 000000010 100000000 ? 000000000 111110000 111110000 111110000 111110000 111110000 000000100 111110000 000000001 ? 000000000 100001100 10...
result:
ok correct! (10000 test cases)
Test #49:
score: 0
Accepted
time: 265ms
memory: 4900kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111101111 111110111 111111011 111111111 111111111 0 111111111 111111111 111111111 111111111 111101111 111110111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111101 111111101 011101111 111111111 111111110 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100011100 100000000 100000000 100000000 000010000 000001000 000000100 100000000 100000000 ? 000000000 000000000 000000000 000000000 111110000 111110000 111110000 000000010 000000001 ? 000000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #50:
score: 0
Accepted
time: 251ms
memory: 5020kb
input:
10000 9 0 111111111 111111111 110111111 111111111 111111111 111110111 111111011 111111101 111111111 0 111111111 111111111 110111111 111111111 111111111 111110111 111111111 111111101 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101001110 100000000 001000000 100000000 100000000 000001000 000000100 000000010 100000000 ? 000000000 000000000 111110000 000000000 000000000 111110000 111110000 111110000 000000001 ? 000000000 000000000 11...
result:
ok correct! (10000 test cases)
Test #51:
score: 0
Accepted
time: 135ms
memory: 4424kb
input:
10000 7 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111011 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 0000000 0100000 0010000 0001000 0000100 0000010 0000001 ? 1111000 0000000 0000000 0000000 0000000 0000000 0000000 ? 1100000 0000000 0000000 0000000 0000000 0000000 0000000 ? 1000000 0000000 0000000 0000000 0000000 0000000 0000000 ! 1000000 ...
result:
ok correct! (10000 test cases)
Test #52:
score: 0
Accepted
time: 76ms
memory: 4428kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111110 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 00000000 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ? 11110000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ? 11000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #53:
score: 0
Accepted
time: 136ms
memory: 4392kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 10111111 11011111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 00000000 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ? 11110000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ? 11000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #54:
score: 0
Accepted
time: 147ms
memory: 4492kb
input:
10000 8 0 11111111 10111111 11111111 11101111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 00111111 11111111 11111111 11111111 11111110 0 11111111 00111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11010000 01000000 10000000 00010000 10000000 10000000 10000000 10000000 ? 00000000 11110000 00000000 11110000 00001000 00000100 00000010 00000001 ? 00000000 11000000 00100000 10001100 00000000 00000000 00000000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #55:
score: 0
Accepted
time: 120ms
memory: 4452kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 10111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 00000000 01000000 00100000 00010000 00001000 00000100 00000010 00000001 ? 11110000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ? 11000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #56:
score: 0
Accepted
time: 286ms
memory: 4980kb
input:
10000 9 0 111111111 111111111 111111111 111011111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 000001111 111111111 111110111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100100000 100000000 100000000 000100000 100000000 100000000 100000000 100000000 100000000 ? 000000000 000000000 000000000 111110000 000000000 000001000 000000100 000000010 000000001 ? 000000000 010000000 00...
result:
ok correct! (10000 test cases)
Test #57:
score: 0
Accepted
time: 250ms
memory: 5012kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 101111111 111111111 111111111 111111111 111111111 111111111 111111111 111111110 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 000000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ? 111110000 000000000 000000000 000000000 000000000 000000000 000000000 000000000 000000000 ? 111000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #58:
score: 0
Accepted
time: 263ms
memory: 4984kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111110111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111011 111111101 111111110 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 100001000 100000000 100000000 100000000 100000000 000001000 100000000 100000000 100000000 ? 000000000 000000000 000000000 000000000 000000000 111110000 000000100 000000010 000000001 ? 000000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #59:
score: 0
Accepted
time: 260ms
memory: 4956kb
input:
10000 9 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 000000000 010000000 001000000 000100000 000010000 000001000 000000100 000000010 000000001 ? 111110000 000000000 000000000 000000000 000000000 000000000 000000000 000000000 000000000 ? 111000000 000000000 00...
result:
ok correct! (10000 test cases)
Test #60:
score: 0
Accepted
time: 218ms
memory: 4976kb
input:
10000 7 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111011 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 0000000 0100000 0010000 0001000 0000100 0000010 0000001 ? 1111000 0000000 0000000 0000000 0000000 0000000 0000000 ? 1100000 0000000 0000000 0000000 0000000 0000000 0000000 ? 1000000 0000000 0000000 0000000 0000000 0000000 0000000 ! 1000000 ...
result:
ok correct! (10000 test cases)
Test #61:
score: 0
Accepted
time: 215ms
memory: 4956kb
input:
10000 7 0 1111111 1011111 1111110 1110111 1111111 1111111 1111111 0 1111111 1111111 1111111 1110111 1111111 1111111 1111111 0 1111111 1111111 1111111 0011111 1111011 1111111 1111111 0 1111111 0011111 1101111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1101000 0100000 1000000 0001000 1000000 1000000 1000000 ? 0000000 1111000 0000000 1111000 0000100 0000010 0000001 ? 0000000 1100000 0010000 1000110 0000000 0000000 0000000 ? 0000000 1010000 0000000 1000100 0000000 0000000 0000000 ! 0100000 ...
result:
ok correct! (10000 test cases)
Test #62:
score: 0
Accepted
time: 246ms
memory: 4976kb
input:
10000 9 0 111111111 101111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111110111 111111111 111111111 111111111 0 111111111 0001...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110000000 010000000 100000000 100000000 100000000 100000000 100000000 100000000 100000000 ? 000000000 111110000 000000000 000000000 000000000 000001000 000000100 000000010 000000001 ? 000000000 111000000 00...
result:
ok correct! (10000 test cases)
Test #63:
score: 0
Accepted
time: 252ms
memory: 4984kb
input:
10000 8 0 11111111 11111111 11111111 11111111 11111111 11111011 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 00111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10000100 10000000 10000000 10000000 10000000 00000100 10000000 10000000 ? 00000000 00000000 00000000 00000000 00001000 11110000 00000010 00000001 ? 00000000 00000000 00100000 00010000 00000000 11000000 00000000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #64:
score: 0
Accepted
time: 277ms
memory: 4952kb
input:
10000 9 0 111111111 101111111 111111111 111011111 111101111 111110111 111111111 111111111 111111110 0 111111111 101111111 111111111 111111111 111101111 111110111 111111111 111111111 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111101 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110111001 010000000 100000000 000100000 000010000 000001000 100000000 100000000 000000001 ? 000000000 111110000 000000000 111110000 111110000 111110000 000000100 000000010 111110000 ? 000000000 111000000 00...
result:
ok correct! (10000 test cases)
Test #65:
score: 0
Accepted
time: 166ms
memory: 4788kb
input:
10000 6 0 111111 101111 110111 111100 111101 111101 0 100101 101111 110111 111111 111101 111111 0 011111 111100 111100 100100 011111 111111 0 101111 011111 111101 111111 101111 111111 0 111101 111111 011111 111111 111101 111111 0 6 0 111111 001111 010111 011011 011101 011110 0 111111 101111 110111 1...
output:
? 000000 110000 101000 100100 100010 100001 ? 111010 010000 001000 100000 000010 100000 ? 111000 111000 111000 000100 111000 000001 ? 100110 110000 110000 000000 100110 000000 ? 100100 000000 100000 000000 100100 000000 ! 000100 001000 010000 000100 000100 000001 ? 000000 110000 101000 100100 100010...
result:
ok correct! (10000 test cases)
Test #66:
score: 0
Accepted
time: 118ms
memory: 4444kb
input:
10000 7 0 1111111 1110010 1101111 1111010 1111011 1111101 1110011 0 1111110 1111010 1101111 1111111 1111011 1111101 1111010 0 1111111 1111111 0110111 1111111 1111010 1111010 1111110 0 1111111 1111111 1010110 1011000 0111111 1110000 1111111 0 1111111 1011111 0111011 1111111 1111010 0111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1010110 1000000 0010000 1000000 0000100 0000010 1000000 ? 0000000 0000000 1111000 0000000 1111000 1111000 0000001 ? 0000000 0000000 1000110 0001000 1100000 1100000 0000000 ? 0000000 0100000 1000100 0000000 1010000 1000000 0000000 ! 1000000 ...
result:
ok correct! (10000 test cases)
Test #67:
score: 0
Accepted
time: 125ms
memory: 4424kb
input:
10000 7 0 1111111 0011111 0101111 0110111 1111101 1111111 0111110 0 0000110 1011111 1101111 1110111 0111111 0111111 1111110 0 0000111 0000111 0000111 0000111 0111101 1111111 0000111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 1111111 1111111 1111111 1111111 1111111 1111111 1111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1111001 0100000 0010000 0001000 1000000 1000000 0000001 ? 1111000 1111000 1111000 1111000 0000100 0000010 1111000 ? 1000110 1000110 1000110 1000110 0000000 0000000 1000110 ? 1000100 1000100 1000100 1000100 0000000 0000000 1000100 ! 0000100 ...
result:
ok correct! (10000 test cases)
Test #68:
score: 0
Accepted
time: 145ms
memory: 4424kb
input:
10000 7 0 1111111 0011111 0101111 0110111 0111011 0111101 0111110 0 1111111 1111111 1101111 1110111 1111111 1111101 1111111 0 1111111 1111101 1111101 1111101 1111101 1111101 1111101 0 1111111 0011111 0011111 0011111 0011111 0011111 0011111 0 1111111 1111101 0111111 1111101 1111101 0111111 0111111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1111111 0100000 0010000 0001000 0000100 0000010 0000001 ? 0000000 1111000 1111000 1111000 1111000 1111000 1111000 ? 0000000 1100000 1100000 1100000 1100000 1100000 1100000 ? 0000000 1010000 1010000 1010000 1010000 1010000 1010000 ! 0100101 ...
result:
ok correct! (10000 test cases)
Test #69:
score: 0
Accepted
time: 134ms
memory: 4380kb
input:
10000 7 0 1111111 1011111 1101111 1001111 1111011 1001111 1111110 0 1001010 1011111 1101111 1001111 1111011 1111111 1111110 0 0001111 1111111 0001111 1111111 0001111 1000111 0001111 0 1001111 0011111 0111111 1110111 1001111 1111111 1001111 0 0111111 0101111 1111111 1111111 0111111 1111111 1001111 0 ...
output:
? 0000000 1100000 1010000 1001000 1000100 1000010 1000001 ? 1110101 0100000 0010000 1000000 0000100 1000000 0000001 ? 1111000 1111000 1111000 0000000 1111000 0000010 1111000 ? 1000110 1100000 1000110 0001000 1000110 0000000 1000110 ? 1000100 1010000 0000000 0000000 1000100 0000000 1000100 ! 0000010 ...
result:
ok correct! (10000 test cases)
Test #70:
score: 0
Accepted
time: 157ms
memory: 4432kb
input:
10000 8 0 11111111 10111111 11011111 11111100 11110111 11111011 11111110 11111110 0 10010010 10111111 11011111 11111110 11110111 11111011 11111111 11111110 0 11111100 01111111 01111111 11111111 11111100 11111100 10001110 11111100 0 01111111 10111110 10111110 11101111 01111111 01111111 11111111 11110...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11101101 01000000 00100000 10000000 00001000 00000100 10000000 00000001 ? 11110000 11110000 11110000 00000000 11110000 11110000 00000010 11110000 ? 11000000 10001100 10001100 00010000 11000000 11000000 00000000 11000000 ? 10...
result:
ok correct! (10000 test cases)
Test #71:
score: 0
Accepted
time: 154ms
memory: 4392kb
input:
10000 8 0 11111111 10111111 11011111 11101111 11111111 11111011 11111101 11111110 0 11110111 11111111 11011111 11101111 10110111 11111011 11111101 11111110 0 11111111 11110111 00111111 00111111 11110111 00111111 11110111 11110111 0 11111111 00111111 11111111 01110111 11111111 01110111 00111111 00111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11110111 01000000 00100000 00010000 10000000 00000100 00000010 00000001 ? 00000000 11110000 11110000 11110000 00001000 11110000 11110000 11110000 ? 00000000 11000000 10001100 10001100 00000000 10001100 11000000 11000000 ? 00...
result:
ok correct! (10000 test cases)
Test #72:
score: 0
Accepted
time: 156ms
memory: 4432kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11111011 11111111 11111111 0 11111111 11111111 11111111 11101111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10110100 10000000 00100000 00010000 10000000 00000100 10000000 10000000 ? 00000000 00000000 11110000 11110000 00001000 11110000 00000010 00000001 ? 00000000 00000000 11000000 11000000 00000000 11000000 00000000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #73:
score: 0
Accepted
time: 155ms
memory: 4424kb
input:
10000 8 0 01011111 10011111 11111111 11001111 11110111 11011111 11011101 11011110 0 01111110 01111110 11111111 01111110 11111111 11111111 10010001 10010001 0 10000001 00000000 11111111 01111110 11111111 11111111 01111110 01111110 0 01111111 10010000 11111110 10010000 11111111 11111111 10010000 10010...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11111111 11111111 11111111 11111111 00000000 00000000 00000000 00000000 ? 11111111 01111110 00000000 00000000 10000001 10000001 00000000 00000000 ? 11111111 00000000 01111110 00000000 10000001 00000000 00000000 00000000 ! 00...
result:
ok correct! (10000 test cases)
Test #74:
score: 0
Accepted
time: 126ms
memory: 4440kb
input:
10000 8 0 11111111 11111111 11011111 11101111 11111111 11011101 11111111 11111111 0 11001111 11111111 11011111 11101111 11111111 11111111 11111111 11111111 0 11111111 11111111 11111111 11111111 11111111 11111111 11111101 11111110 0 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 10110000 10000000 00100000 00010000 10000000 10000000 10000000 10000000 ? 11110000 00000000 11110000 11110000 00001000 00000100 00000010 00000001 ? 11000000 00000000 11000000 11000000 00000000 00000000 00000000 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #75:
score: 0
Accepted
time: 142ms
memory: 4428kb
input:
10000 8 0 11111111 10111101 11111101 11101101 11110101 11111001 11111111 11111100 0 11111111 00110011 11110011 01100011 01111011 01110111 11111111 01110010 0 11111111 10001100 11111111 10001100 01110011 01110011 11111111 01110011 0 11111111 00001100 11111111 11110011 10000000 10000000 11111111 11110...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11011101 01000000 10000000 00010000 00001000 00000100 10000000 00000001 ? 11111111 11111111 11111111 11111111 00000000 00000000 00000000 00000000 ? 10001100 11111111 00000000 00000000 01110011 01110011 00000000 00000000 ? 00...
result:
ok correct! (10000 test cases)
Test #76:
score: 0
Accepted
time: 159ms
memory: 4388kb
input:
10000 8 0 11111111 00111111 01011111 11111111 01110111 01111011 11111111 11111111 0 11111111 00011111 01111111 11111111 11110111 01011011 11111111 11111111 0 11111111 10111001 10111001 11111111 11111111 01011111 11111111 11111111 0 11111111 11100110 01011111 11111111 01011111 01011111 11111111 11111...
output:
? 00000000 11000000 10100000 10010000 10001000 10000100 10000010 10000001 ? 11101100 01000000 00100000 10000000 00001000 00000100 10000000 10000000 ? 11111111 11111111 11111111 11111111 00000000 00000000 00000000 00000000 ? 10111001 11111111 00000000 00000000 01000110 01000110 00000000 00000000 ? 10...
result:
ok correct! (10000 test cases)
Test #77:
score: 0
Accepted
time: 262ms
memory: 4976kb
input:
10000 9 0 111111111 101111111 110111111 110111111 111101111 111110111 111111011 111111101 111111110 0 111111111 101111111 110111111 110101110 111111111 111110111 111111011 111111101 111111111 0 111111111 010101111 010101111 111111111 111111111 111111111 010101111 010101111 010101111 0 111111111 0111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111011111 010000000 001000000 100000000 000010000 000001000 000000100 000000010 000000001 ? 000000000 111110000 111110000 000000000 111110000 111110000 111110000 111110000 111110000 ? 000000000 100001100 10...
result:
ok correct! (10000 test cases)
Test #78:
score: 0
Accepted
time: 245ms
memory: 4956kb
input:
10000 9 0 111111111 101111111 110111111 111111111 111101111 111110111 111111011 111111111 111111110 0 111111111 101111111 111111111 111111111 111101111 111110111 111111011 111111111 111111110 0 111111111 111111111 011111111 111111111 111111111 111111111 111111111 101001111 011111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 111011101 010000000 001000000 100000000 000010000 000001000 000000100 100000000 000000001 ? 000000000 111110000 111110000 000000000 111110000 111110000 111110000 000000010 111110000 ? 000000000 111000000 10...
result:
ok correct! (10000 test cases)
Test #79:
score: 0
Accepted
time: 239ms
memory: 4956kb
input:
10000 9 0 111111111 001111111 101111101 100111101 011101111 011110111 111111111 011111101 011111110 0 001100100 101111111 011111111 011111111 111101111 111110111 011111111 111111101 111111110 0 111111101 000101111 111111111 111111111 000101111 111111101 111111111 111111101 111111101 0 000111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 110011011 010000000 100000000 100000000 000010000 000001000 100000000 000000010 000000001 ? 111110000 111110000 000000000 000000000 111110000 111110000 000000100 111110000 111110000 ? 111000000 100001100 00...
result:
ok correct! (10000 test cases)
Test #80:
score: 0
Accepted
time: 255ms
memory: 4884kb
input:
10000 9 0 111111111 111111111 110111111 111011111 111101111 111111111 111111111 111111101 111111111 0 111111111 111111111 110111111 111111111 111111111 111111111 111111111 111111101 111111111 0 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 111111111 0 111111111 1111...
output:
? 000000000 110000000 101000000 100100000 100010000 100001000 100000100 100000010 100000001 ? 101110010 100000000 001000000 000100000 000010000 100000000 100000000 000000010 100000000 ? 000000000 000000000 111110000 111110000 111110000 000001000 000000100 111110000 000000001 ? 000000000 000000000 11...
result:
ok correct! (10000 test cases)
Extra Test:
score: 0
Extra Test Passed