QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#628043#7900. Gifts from KnowledgeadivseWA 84ms40620kbC++204.3kb2024-10-10 18:21:242024-10-10 18:21:26

Judging History

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

  • [2024-10-10 18:21:26]
  • 评测
  • 测评结果:WA
  • 用时:84ms
  • 内存:40620kb
  • [2024-10-10 18:21:24]
  • 提交

answer

#include<bits/stdc++.h>
#define endl '\n'
#define int long long
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define rep2(i,a,b) for(int i=(a);i>=(b);i--)
using namespace std;
template<typename... Args>
void bubu(Args... args) { cout << ":: "; ((cout << args << " "), ...); cout << endl; }
void bubu(vector<int> tem) { for (auto x : tem) cout << x << ' '; cout << endl; }
void kuaidu() { ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); }
inline int max(int a, int b) { if (a < b) return b; return a; }
inline int min(int a, int b) { if (a < b) return a; return b; }
using PII = pair<int, int>;
using i128 = __int128;
struct DSU {
    struct Info {
        int fa;
        int siz;
        vector<int> A;
    };
    vector<Info> dsu;
    Info& operator[](int x) { return dsu[find(x)]; }
    DSU(int n_) { init(n_); }
    void init(int n) {
        dsu.resize(n + 100);
        //TO DO 记得初始化
        rep(i, 1, n) {
            dsu[i].fa = i, dsu[i].siz = 1;
            dsu[i].A.clear();
            dsu[i].A.push_back(i);
        }
    }
    int find(int x) { if (x == dsu[x].fa) return x; return dsu[x].fa = find(dsu[x].fa); }
    void merge(int x, int y) {
        x = find(x), y = find(y);
        if (x == y) return; if (dsu[x].siz < dsu[y].siz) swap(x, y);
        dsu[y].fa = x, dsu[x].siz += dsu[y].siz;
        for (auto y1 : dsu[y].A) {
            dsu[x].A.push_back(y1);
        }
        dsu[y].A.clear();
        dsu[y].siz = 0;
    }
    bool same(int x, int y) {
        x = find(x), y = find(y);
        if (x == y) return 1; return 0;
    }
    int size(int x) { return dsu[find(x)].siz; }
};
//=======================================================================
const int N = 1e6 + 10;
const int M = 1e6 + 10;
const int mod = 1e9 + 7;
const int INF = 1e16;
int n, m, T;
int in[N];
string s[N];
vector<int> A[N], B[N];
bool vis[N];
//=======================================================================
int kuai(int a, int b) {
    int l = 1;
    while (b) {
        if (b % 2) l = l * a % mod;
        a = a * a % mod; b /= 2;
    }
    return l;
}
int dnf[N];
int co[N];
bool dfs(int x, vector<int>& A) {
    if (dnf[x] >= 2) return 0;
    int las, fl = 1;
    for (auto y : A) {
        if (co[y]) { fl = 0; las = co[y]; break; }
    }
    if (las == x) { return 0; }
    if (fl) {
        for (auto y : A) {
            co[y] = x;
        }
        return 1;
    }
    dnf[las]++;
    if (dnf[las] >= 2) return 0;
    if (dfs(las, B[las])) {
        for (auto y : A) {
            co[y] = x;
        }
        return 1;
    }
    return 0;
}

signed main() {
    kuaidu();
    cin >> T;
    while (T--) {
        cin >> n >> m;
        rep(i, 1, n + m) {
            in[i] = 0, vis[i] = 0; co[i] = 0; dnf[i] = 0;
            A[i].clear();
            B[i].clear();
        }
        DSU dsu(n + m + 100);

        rep(i, 1, n) {
            cin >> s[i];
            rep(j, 0, m - 1) {
                if (s[i][j] == '1') {
                    in[j + 1]++;
                    in[m - j]++;
                }
            }
        }

        int flag = 1;
        rep(i, 1, m + n) {
            if (in[i] >= 3) {
                cout << 0 << endl;
                flag = 0;
                break;
            }
        }
        if (flag == 0) continue;

        rep(i, 1, n) {
            rep(j, 0, m - 1) {
                if (s[i][j] == '1') {
                    dsu.merge(i, j + 1 + n);
                    dsu.merge(i, m - j + n);
                    A[i].push_back(j + 1);
                    B[i].push_back(m - j);
                }
            }
        }

        rep(i, 1, n) {
            if (i != dsu.find(i)) continue;
            for (auto x : dsu[i].A) {
                if (x > n) continue;
                if (dfs(x, A[x])) continue;
                dnf[x]++;
                if (dfs(x, B[x])) continue;
                flag = 0;
                goto Z;
            }
        }
    Z:;
        if (flag == 0) {
            cout << 0 << endl;
            continue;
        }
        set<int> S; S.clear();
        rep(i, 1, n) {
            S.insert(dsu.find(i));
        }
        int ans = kuai(2, S.size());
        cout << ans << endl;
    }
    return 0;
}

详细

Test #1:

score: 100
Accepted
time: 12ms
memory: 40432kb

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: 71ms
memory: 40620kb

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: 84ms
memory: 40456kb

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'