QOJ.ac
QOJ
The 2nd Universal Cup Finals is coming! Check out our event page, schedule, and competition rules!
ID | Problem | Submitter | Result | Time | Memory | Language | File size | Submit time | Judge time |
---|---|---|---|---|---|---|---|---|---|
#539257 | #9114. Black or White 2 | Max_FWL | WA | 176ms | 3660kb | C++14 | 1.1kb | 2024-08-31 14:22:33 | 2024-08-31 14:22:33 |
Judging History
answer
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
int T, n, m, k, fl1 = 0, fl2 = 0, a[N][N];
int row;
void Solve(){
cin >> n >> m >> k;
fl1 = fl2 = 0;
if (n < m){
swap(n, m);
fl1 = 1;
}
if (k > ((n * m) >> 1)){
k = n * m - k;
fl2 = 1;
}
for (int i = 1; i <= m; i += 2){
if (!k)
break;
a[1][i] = 1;
k--;
}
for (int i = 2; i <= n; i++){
if (k < m)
break;
for (int j = 1; j <= m; j += 2)
a[i][j] = 1;
for (int j = 2; j <= m; j += 2)
a[i - 1][j] = 1;
k -= m;
row = i;
}
for (int i = 2; i <= m; i += 2){
if (k < 2)
break;
a[row][i] = 1;
a[row + 1][i] = 1;
k -= 2;
}
a[n][m] = k;
for (int i = 1; i <= (fl1 ? m : n); i++){
for (int j = 1; j <= (fl1 ? n : m); j++)
cout << ((fl1 ? a[j][i] : a[i][j]) ^ fl2) ;
cout << endl;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
a[i][j] = 0;
}
signed main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> T;
while (T--)
Solve();
return 0;
}
Details
Tip: Click on the bar to expand more detailed information
Test #1:
score: 100
Accepted
time: 0ms
memory: 3588kb
input:
2 2 2 2 2 3 0
output:
10 01 000 000
result:
ok Output is valid. OK.
Test #2:
score: -100
Wrong Answer
time: 176ms
memory: 3660kb
input:
27520 2 2 0 2 2 1 2 2 2 2 2 3 2 2 4 2 3 0 2 3 1 2 3 2 2 3 3 2 3 4 2 3 5 2 3 6 3 2 0 3 2 1 3 2 2 3 2 3 3 2 4 3 2 5 3 2 6 3 3 0 3 3 1 3 3 2 3 3 3 3 3 4 3 3 5 3 3 6 3 3 7 3 3 8 3 3 9 2 4 0 2 4 1 2 4 2 2 4 3 2 4 4 2 4 5 2 4 6 2 4 7 2 4 8 3 4 0 3 4 1 3 4 2 3 4 3 3 4 4 3 4 5 3 4 6 3 4 7 3 4 8 3 4 9 3 4 10...
output:
00 00 10 00 10 01 01 11 11 11 000 000 100 000 100 001 110 100 011 110 011 111 111 111 00 00 00 10 00 00 10 00 01 11 10 00 01 11 10 01 11 11 11 11 11 000 000 000 100 000 000 101 000 000 101 000 001 101 010 010 010 101 101 010 111 110 010 111 111 011 111 111 111 111 111 0000 0000 1000 0000 1000 0001 1...
result:
wrong answer Output doesn't minimize loss.