QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#579335#7900. Gifts from KnowledgeMaster640WA 38ms107024kbC++143.2kb2024-09-21 12:33:302024-09-21 12:33:31

Judging History

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

  • [2024-09-21 12:33:31]
  • 评测
  • 测评结果:WA
  • 用时:38ms
  • 内存:107024kb
  • [2024-09-21 12:33:30]
  • 提交

answer

//
// Created by 35263 on 2024/9/20.
//
//每次选择是否反转一行,每一行最多进行一次反转,只有转和不转两种情况
//观察到r*c这是一个矩阵
//感觉像是一个dp
//给定相同相反关系,求方案数的题目,那么就必然是建图解决
//决定做就去做
//二分图染色 3 - color[x]
//连线+二分图染色说明两个不能同时选
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll maxn = 1000005;
const ll mod = 1e9 + 7;
string str[maxn];
ll n,m,cnt[maxn],vis[maxn*2];
vector<ll>pos[maxn],g[maxn*2];
//有意识地去突破
//i代表第i行不反转,i+n代表第i行反转
//所以连接的话,如果1都在第j列,那么(i->i'+n,i'->i+n);
//如果两个1不在同一列,那么(i->i',i+n->i’+n);
//最后普dfs一遍计算连通块个数,ksm一下即可
ll ksm(ll x,ll b){
    ll ans=1;
    while(b){
        if(b&1)ans=(ans*x)%mod;
        b>>=1;
        x=(x*x)%mod;
    }
    return ans;
}
void update(){
   for(ll i=1;i<=m;i++)pos[i].clear(),cnt[i]=0;
   for(ll i=1;i<=2*n;i++)g[i].clear();
   for(ll i=1;i<=2*n;i++)vis[i]=0;
}
void add(ll x,ll y){
    g[x].push_back(y);g[y].push_back(x);
}
ll get_color(ll x){
    for(auto v:g[x]){
        if(vis[v]) {
            if (vis[v] == vis[x])return false;
        }
        else {
            vis[v] = 3 - vis[x];
            get_color(v);
        }
    }
    return true;
}
void init(){
    cin>>n>>m;
    update();
    for(ll i=1;i<=n;i++)cin>>str[i],str[i]=" "+str[i];
    for(ll i=1;i<=m;i++){
        for(ll j=1;j<=n;j++){
            if(str[j][i]=='1') {
                cnt[i] += (str[j][i] == '1');
                pos[i].push_back(j);
            }
        }
    }
    ll flag=true;
    for(ll i=1;i<=(m+1)/2;i++){
        if(i==m-i+1){
            if(cnt[i]>1){
                flag=false;
                break;
            }
            continue;
        }
        if(cnt[i]+cnt[m-i+1]>2){
            flag=false;
            break;
        }
    }
    if(!flag){
        cout<<0<<endl;
        return;
    }
    for(ll i=1;i<=n;i++)add(i,i+n);
    for(ll i=1;i<=(m+1)/2;i++){
        if(i==m-i+1)continue;
        if(pos[i].size()==2){
            ll u=pos[i][0],v=pos[i][1];
            add(u,v);add(u+n,v+n);
        }
        else{
            if(pos[i].size()==1&&pos[m-i+1].size()==1){
            ll u=pos[i][0],v=pos[m-i+1][0];
                add(u,v+n);add(v,u+n);
            }
            else{
                if(pos[m-i+1].size()>=2) {
                    ll u = pos[m - i + 1][0], v = pos[m - i + 1][1];
                    add(u, v);
                    add(u + n, v + n);
                }
            }
        }
    }
    ll cnt_blocks=0,ans=1;
    flag=true;
    for(ll i=1;i<=2*n;i++){
        if(!vis[i]){
            vis[i]=1;
            if(get_color(i))ans=ans*2%mod;
            else flag=false;
        }
    }
   // cout<<cnt_blocks<<endl;
    if(flag)
    cout<<ans%mod<<endl;
    else
    cout<<0<<endl;
}
int main(){
    ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
    ll t;
    cin>>t;
    while(t--){
        update();
        init();
    }
    return 0;
}

详细

Test #1:

score: 100
Accepted
time: 16ms
memory: 107024kb

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: 24ms
memory: 106604kb

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: 0
Accepted
time: 38ms
memory: 105820kb

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:

ok 15759 numbers

Test #4:

score: -100
Wrong Answer
time: 28ms
memory: 105900kb

input:

15734
3 6
000101
010000
001110
5 7
0010010
1000000
0101000
0000000
0000000
10 9
000000000
100000000
000000000
000000000
000010000
000000001
000000000
000000000
000000000
000000000
5 14
10000000000000
00001001000000
00000100000000
00000000000000
00000100000000
5 14
00000000000000
00010000000100
00000...

output:

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

result:

wrong answer 1479th numbers differ - expected: '0', found: '32'