QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#99093#6309. AqreFanch100WA 215ms12088kbC++142.8kb2023-04-21 10:44:092023-04-21 10:44:10

Judging History

你现在查看的是最新测评结果

  • [2023-08-10 23:21:45]
  • System Update: QOJ starts to keep a history of the judgings of all the submissions.
  • [2023-04-21 10:44:10]
  • 评测
  • 测评结果:WA
  • 用时:215ms
  • 内存:12088kb
  • [2023-04-21 10:44:09]
  • 提交

answer

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int a[4][4]={
    {1,1,1,0},
    {1,0,1,1},
    {1,1,0,1},
    {0,1,1,1}
};
int n, m;
int b[N][N], c[N][N], id[N][N];
int nxt[N];
int get(int x){return x==nxt[x]?x:nxt[x]=get(nxt[x]);}
int solve(int x,int y){
    int ans=0;
    for (int i=1;i<=n;++i){
        for (int j=1;j<=m;++j){
            b[i][j]=a[(i+x)%4][(j+y)%4];
            ans+=b[i][j];
        }
    }
    int idx=0;
    for (int i=1;i<=n;++i){
        for (int j=1;j<=m;++j) id[i][j]=++idx, nxt[idx]=idx;
    }
    for (int i=1;i<=n;++i){
        for (int j=1;j<=m;++j){
            if (b[i][j]){
                int cnt=0;
                if (i>1 && b[i-1][j]==1) nxt[get(id[i-1][j])]=get(id[i][j]);
                if (j>1 && b[i][j-1]==1) nxt[get(id[i][j-1])]=get(id[i][j]);
                if (i<n && b[i+1][j]==1) nxt[get(id[i+1][j])]=get(id[i][j]);
                if (j<m && b[i][j+1]==1) nxt[get(id[i][j+1])]=get(id[i][j]);
            }
        }
    }
    int cnt=0;
    for (int i=1;i<=n;++i){
        for (int j=1;j<=m;++j) cnt+=(b[i][j] && get(id[i][j])==id[i][j]);
    }
    if (cnt>1) ans=0;
    return ans;
}
void solve(){
    cin>>n>>m;
    if (n<=3 && m<=3){
        printf("%d\n",n*m);
        for (int i=1;i<=n;++i){
            for (int j=1;j<=m;++j) printf("%d",1); puts("");
        }
        return;
    }
    bool rev=0;
    if (n>m) swap(n,m),rev=1;
    int ans=0;
    if (n==3 && m%4==3){
        for (int i=1;i<=n;++i){
            for (int j=1;j<=m;++j){
                if (j<=3){
                    if (j==2 && i==2) b[i][j]=0;
                    else b[i][j]=1,ans++;
                }
                else if (i==1 || i==3){
                    if ((j-3)%4==1) b[i][j]=0;
                    else b[i][j]=1,ans++;
                }
                else{
                    if ((j-3)%4==3) b[i][j]=0;
                    else b[i][j]=1,ans++;
                }
            }
        }
        if (rev) swap(n,m);
        for (int i=1;i<=n;++i){
            for (int j=1;j<=m;++j) c[i][j]=(rev?b[j][i]:b[i][j]);
        }

    }
    else{
        if (rev) swap(n,m);
        for (int i=0;i<4;++i){
            for (int j=0;j<4;++j){
                int mx=solve(i,j);
                if (mx>ans){
                    ans=mx;
                    for (int k=1;k<=n;++k){
                        for (int l=1;l<=m;++l) c[k][l]=b[k][l];
                    }
                }
            }
        }
    }

    printf("%d\n",ans);
    for (int i=1;i<=n;++i){
        for (int j=1;j<=m;++j) printf("%d",c[i][j]);
        puts("");
    }
}
int main(){
//    for (int i=0;i<4;++i){
//        for (int j=0;j<4;++j) printf("%d ",a[i][j]); puts("");
//    }
    int t; 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: 7808kb

input:

3
2 2
3 4
3 8

output:

4
11
11
9
0111
1011
1110
18
01110111
10111011
11101110

result:

ok ok (3 test cases)

Test #2:

score: 0
Accepted
time: 19ms
memory: 7668kb

input:

361
2 2
2 3
2 4
2 5
2 6
2 7
2 8
2 9
2 10
2 11
2 12
2 13
2 14
2 15
2 16
2 17
2 18
2 19
2 20
3 2
3 3
3 4
3 5
3 6
3 7
3 8
3 9
3 10
3 11
3 12
3 13
3 14
3 15
3 16
3 17
3 18
3 19
3 20
4 2
4 3
4 4
4 5
4 6
4 7
4 8
4 9
4 10
4 11
4 12
4 13
4 14
4 15
4 16
4 17
4 18
4 19
4 20
5 2
5 3
5 4
5 5
5 6
5 7
5 8
5 9
5 1...

output:

4
11
11
6
111
111
6
1110
0111
8
10111
11101
9
101110
111011
11
1011101
1110111
12
10111011
11101110
14
101110111
111011101
15
1011101110
1110111011
17
10111011101
11101110111
18
101110111011
111011101110
20
1011101110111
1110111011101
21
10111011101110
11101110111011
23
101110111011101
1110111011101...

result:

ok ok (361 test cases)

Test #3:

score: -100
Wrong Answer
time: 215ms
memory: 12088kb

input:

100
91 91
91 92
91 93
91 94
91 95
91 96
91 97
91 98
91 99
91 100
92 91
92 92
92 93
92 94
92 95
92 96
92 97
92 98
92 99
92 100
93 91
93 92
93 93
93 94
93 95
93 96
93 97
93 98
93 99
93 100
94 91
94 92
94 93
94 94
94 95
94 96
94 97
94 98
94 99
94 100
95 91
95 92
95 93
95 94
95 95
95 96
95 97
95 98
95 9...

output:

6211
1110111011101110111011101110111011101110111011101110111011101110111011101110111011101110111
1011101110111011101110111011101110111011101110111011101110111011101110111011101110111011101
0111011101110111011101110111011101110111011101110111011101110111011101110111011101110111011
1101110111011101110...

result:

wrong answer (0, 99) to (3, 99) are the same (test case 10)