QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#608710#7900. Gifts from KnowledgeDoubeecatWA 13ms7844kbC++202.7kb2024-10-04 01:24:372024-10-04 01:24:38

Judging History

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

  • [2024-10-04 01:24:38]
  • 评测
  • 测评结果:WA
  • 用时:13ms
  • 内存:7844kb
  • [2024-10-04 01:24:37]
  • 提交

answer

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cctype>
#include <vector>
#include <cmath>
#include <queue>
using namespace std;
#define ll long long
#define pii pair <int,int>
#define endl '\n'
#define mp make_pair
const int N = 2e6 + 10;
const ll mod=1e9+7;
vector <vector<int> > a;
vector <bool> vis;
vector <int> col;
vector <vector<pii > > G;
int r,c;
char s[N];
int ck[N];
int p[N];
int find(int x){
    if(x!=p[x]){
        p[x]=find(p[x]);
    }
    return p[x];
}
ll qsm(ll a,ll b){
    ll res=1;
    while(b){
        if(b&1)res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
bool dfs(int x) {
    vis[x] = 1;
    bool flag = 1;
    for (auto [y,w] : G[x]) {
        if (!vis[y]) {
            if (w == 1) col[y] = col[x];
            else col[y] = 3 - col[x];
            dfs(y);
        } else {
            int now = 0;
            if (w == 1) {
                now = col[y] == col[x];
            } else {
                now = col[y] == (3 - col[x]);
            }
            if (!now) flag = 0;
        }
    }
    return flag;
}
void solve() {
    cin >> r >> c;
    a.clear();G.clear();vis.clear();col.clear();
    for(int i=1;i<=2*r;i++){
        ck[i]=0;
        p[i]=i;
    }
    a.resize(r+1);
    vis.resize(r+1);
    G.resize(r+1);
    col.resize(r+1);
    for (int i = 1;i <= r;++i) {
        cin >> s;
        a[i].resize(c+1);
        for (int j = 0;j < c;++j) {
            a[i][j+1] = s[j] - '0';
        }
    }
    for(int i=1;i<=c;i++){
        int cnt=0;
        for(int j=1;j<=r;j++){
            if(a[j][i]==1)cnt++;
            if(a[j][c-i+1]==1)cnt++;
        }
        if(cnt>2){
            cout<<0<<endl;
            return;
        }
    }
    for(int i=1;i<=c;i++){
        if(a[1][i]==1){
            ck[i]=1;
        }
    }
    for(int i=2;i<=r;i++){
        for(int j=1;j<=c;j++){

            int x=j,y=c-j+1;
            int pd1=ck[y];

            if(a[i][j]&&ck[y]){
                //i和ck[y]只能同时选,颜色一样
                G[i].push_back(mp(y,1));
                G[y].push_back(mp(i,1));

                ck[j]=i;
            }else if(a[i][j]&&ck[j]){
                G[i].push_back(mp(y,2));
                G[y].push_back(mp(i,2));
            }
        }
    }
    int cnt=0;
    for(int i=1;i<=r;i++){
        if (!vis[i]) {
            col[i] = 1;
            bool flag = dfs(i);
            if (flag) ++cnt;
        }
    }
    cout<<qsm(2,cnt)<<endl;
}
signed main() {
    ios::sync_with_stdio(false);
    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: 1ms
memory: 7828kb

input:

3
3 5
01100
10001
00010
2 1
1
1
2 3
001
001

output:

4
0
2

result:

ok 3 number(s): "4 0 2"

Test #2:

score: 0
Accepted
time: 4ms
memory: 7724kb

input:

15613
10 10
0000000000
0000000000
0000000000
0000000000
0000000000
0000000000
0000000000
0000000000
0000000000
0000000000
15 8
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
1 5
00000
5 9
000000000
000000000
0000...

output:

1024
32768
2
32
32768
128
32
16
16
2
16384
16384
128
128
32768
8192
128
64
16384
2
4
2
4096
16
4096
1024
32768
32768
16384
8
128
2
16
4096
8192
32768
8192
8192
16
16384
16384
256
128
8
256
8
4096
512
2
4
32
32
2
64
512
1024
32768
32768
2
64
16384
16
8192
16
256
16
64
8192
8192
64
1024
2
32768
2
4
51...

result:

ok 15613 numbers

Test #3:

score: -100
Wrong Answer
time: 13ms
memory: 7844kb

input:

15759
9 6
000000
000000
000000
000000
000000
000000
000000
000000
000000
5 15
010000000000000
000000000000000
000000000000000
000100000000000
000100000000000
14 12
000000000000
000000000000
000000000000
000000000000
000000000000
000000000000
000000000000
000000000000
000000000000
000000000000
000000...

output:

512
32
16384
512
1024
4096
32768
4
2
512
512
512
512
8
2
256
16
4096
512
64
16
4096
512
32
32768
8192
32
2048
128
16
4096
64
32768
256
32
32768
8
512
32
2048
8
16
1024
2048
128
64
32
8
512
8
8192
256
8192
32768
2
8
512
1024
256
32
2
2048
8192
8
64
8
2
16384
32768
32768
1024
4096
16384
16384
128
256
...

result:

wrong answer 2nd numbers differ - expected: '16', found: '32'