QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#695934#7900. Gifts from KnowledgehanmxWA 12ms3632kbC++172.7kb2024-10-31 21:06:542024-10-31 21:06:54

Judging History

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

  • [2024-10-31 21:06:54]
  • 评测
  • 测评结果:WA
  • 用时:12ms
  • 内存:3632kb
  • [2024-10-31 21:06:54]
  • 提交

answer

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using i64=long long;
using u64=unsigned long long;
template<class T>
struct DSU{
    T n;
    vector<T> fa;
    vector<T> siz;
    DSU(int x):n(x),fa(x+1),siz(x+1){
        for(int i=0;i<=x;i++){
            fa[i]=i;
            siz[i]=1;
        }
    }
    T find(T x){
        if(x==fa[x]) return x;
        else{
            fa[x]=find(fa[x]);
            return fa[x];
        }
    }
    bool merge(T x,T y){
        x=find(x);
        y=find(y);
        if(x!=y){
            fa[y]=x;
            siz[x]+=siz[y];
            return 1;
        }
        return 0;
    }
    T ask_size(T x){
        x=find(x);
        return siz[x];
    }
};
const ll mod = 1e9+7;
i64 power(i64 a, i64 b, i64 m)
{
    i64 res = 1;
    a %= m;
    while (b > 0)
    {
        if (b & 1)
            res = (res % m * a % m) % m;
        a = (a % m * a % m) % m;
        b >>= 1;
    }
    return res;
}
void solve(){
    int n,m;
    cin>>n>>m;
    vector<string> s(n+1);
    for(int i=1;i<=n;i++) cin>>s[i],s[i]=' '+s[i];
    vector<pair<int,int>> ans;
    for(int i=1;i<=m/2;i++){
        int sum=0;
        int l=0;
        int r=0;
        for(int j=1;j<=n;j++){
            if(s[j][i]=='1'||s[j][m-i+1]=='1'){
                if(s[j][i]=='1'){
                    sum++;
                    if(!l) l=j;
                    else r=j;
                }
                if(s[j][m-i+1]=='1'){
                    sum++;
                    if(!l) l=j;
                    else r=j;
                }
            }
        }
        if(l&&r) ans.push_back({l,r});
        else if(l) ans.push_back({l,l});
        else if(r) ans.push_back({r,r});
        if(sum>2){
            cout<<"0"<<'\n';
            return;
        }
    }
    if(m%2){
        int sum=0;
        for(int i=1;i<=n;i++){
            if(s[i][(m+1)/2]=='1') sum++;
        }
        if(sum>1){
            cout<<"0"<<'\n';
            return;
        }
    }
    DSU<int> dsu(2*n+1);
    map<int,int> mp;
    for(auto [x,y]:ans){
        if(x==y){
            dsu.merge(x,y);
            dsu.merge(x+n,y+n);
        }
        else{
            dsu.merge(x+n,y);
            dsu.merge(x,y+n);
        }
    }
    for(int i=1;i<=n;i++){
        if(dsu.find(i)==dsu.find(i+n)){
            cout<<"0"<<"\n";
            return;
        }
    }
    ll sum=0;
    for(int i=1;i<=2*n;i++){
        if(dsu.find(i)==i) sum++;
    }
    sum/=2;
    cout<<power(2,sum,mod)<<"\n";
    
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t;
    cin>>t;
    while(t--) solve();
    return 0;
}

詳細信息

Test #1:

score: 100
Accepted
time: 0ms
memory: 3580kb

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: 11ms
memory: 3632kb

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: 12ms
memory: 3620kb

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
16
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
16384
8
512
32
2048
8
16
1024
2048
128
64
32
8
512
8
8192
256
8192
32768
2
8
512
512
256
32
2
2048
8192
8
64
8
2
16384
32768
32768
1024
4096
16384
16384
128
256
4...

result:

wrong answer 2380th numbers differ - expected: '0', found: '4'