QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#570175#7900. Gifts from Knowledgemhw#WA 35ms3736kbC++232.6kb2024-09-17 14:30:032024-09-17 14:30:04

Judging History

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

  • [2024-09-17 14:30:04]
  • 评测
  • 测评结果:WA
  • 用时:35ms
  • 内存:3736kb
  • [2024-09-17 14:30:03]
  • 提交

answer

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int, int>
#define inf 0x3f3f3f3f
#define db double
#define il inline
#define x first
#define y second
#define endl '\n'
const int N = 2e6 + 5;
const int mod = 1e9 + 7;
vector<int> a[N];
int fa[N], n, m;
int get(int x)
{
    return fa[x] == x ? x : fa[x] = get(fa[x]);
}
ll qm(ll a, ll b){
    ll base = 1ll;
    while(b){
        if(b & 1) base = base * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return base % mod;
}
void solve()
{
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
    {
        a[i].resize(m + 1);
        string s;
        cin >> s;
        int j = 0;
        for (auto c : s)
        {
            a[i][++j] = c - '0';
        }
    }
    if (m & 1)
    {
        int cnt = 0;
        for (int i = 1; i <= n; ++i)
        {
            if (a[i][m / 2 + 1] == 1)
                cnt++;
            if (cnt == 2)
            {
                puts("0");
                return;
            }
        }
    }
    for (int i = 1; i <= n * 2; ++i)
        fa[i] = i;
    for (int j = 1; j * 2 <= m; ++j)
    {
        int cnt = 0, cnt2 = 0;
        for (int i = 1; i <= n; ++i)
        {
            if (a[i][j] == 1)
                cnt++;
            if (a[i][m + 1 - j] == 1)
                cnt++;
            if (a[i][j] == 1 && a[i][m + 1 - j])
                cnt2++;
        }
        if (cnt > 2)
        {
            puts("0");
            return;
        }
        if (cnt2 == 1 || cnt <= 1)
        {
            continue;
        }
        int l = 0, r = 0;
        for (int i = 1; i <= n; ++i)
        {
            if (a[i][j] == 1 || a[i][m + 1 - j] == 1)
            {
                if (!l)
                    l = i;
                else
                    r = i;
            }
        }
        int fx = get(l), fy = get(r);
        int fxx = get(l + n), fyy = get(r + n);
        if (a[l][j] == a[r][j])
        { // 不能在一个集合
            fa[fx] = fyy;
            fa[fxx] = fy;
        }
        else{//需要放在一个集合
            fa[fx] = fy;
            fa[fxx] = fyy;
        }
    }
    ll ans = 0;
    for(int i = 1; i <= n; ++i){
        if(fa[i] == i) ans++;
    }
    cout << qm(2, ans) << endl;
}
signed main()
{
    // freopen(" D:\\3022244240\\vscode\\txt\\in.txt", "r", stdin);
    // freopen(" D:\\3022244240\\vscode\\txt\\out.txt", "w", stdout);
    // ios::sync_with_stdio(false);
    // cin.tie(0);
    // cout.tie(0);
    int T = 1;
    cin >> T;
    while (T--)
        solve();
    return 0;
}

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 2ms
memory: 3736kb

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: 26ms
memory: 3584kb

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: 35ms
memory: 3548kb

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: '2'