QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#679796#7900. Gifts from KnowledgeSmHaInTWA 29ms3852kbC++233.6kb2024-10-26 18:36:452024-10-26 18:36:48

Judging History

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

  • [2024-10-26 18:36:48]
  • 评测
  • 测评结果:WA
  • 用时:29ms
  • 内存:3852kb
  • [2024-10-26 18:36:45]
  • 提交

answer

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<string.h>
#include <string>
#include<math.h>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<map>
#include<queue>
#include<stack>
#include<functional>
#include<deque>
using namespace std;

#define MAXN 201000
#define ll long long
#define lll unsigned long long
#define PA pair<ll,ll>
#define Q1 priority_queue<PA,vector<PA>,greater<PA>>
#define Q2 priority_queue<PA>
#define INF (ll)0x3f3f3f3f*(ll)1000000
#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);

const ll mod = 1e9+7;
ll qmi(ll a, ll b)
{
	ll base = a;
	ll re = 1;
	while (b)
	{
		if (b & 1)re = (re * base) % mod;
		b >>= 1;
		base = (base * base) % mod;
	}
	return re;
}


void solve() {
	int n, m; cin >> n >> m;
	vector<int>cnt(m + 1, 0);
	vector<int>cntt(m + 1, 0);
	vector<string>arr(n + 1);
	for (int i = 1; i <= n; i++) {
		string s; cin >> s;
		s = " " + s;
		arr[i] = s;
	}

	vector<vector<int>>place(m + 1);

	vector<int>connect(n + 1);
	for (int i = 1; i <= n; i++) {
		connect[i] = i;
	}


	function<int(int)>Find = [&](int x) {
		if (connect[x] == x)return x;
		else return connect[x] = Find(connect[x]);
	};
	function<void(int, int)>Unite = [&](int x, int y) {
		int fx = Find(x), fy = Find(y);

		if (fy == fx)return;
		
		connect[fx] = fy;
	};
 
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			if (arr[i][j] == '1') {
				cnt[j]++;
				cntt[j]++;
				cnt[m - j + 1]++;

				if (!place[j].empty()) Unite(i, place[j].front());
				if (!place[m - j + 1].empty()) Unite(i, place[m - j + 1].front());
					
				place[j].push_back(i);
				place[m - j + 1].push_back(i);
;
			}
		}
	}

	/*
	for (int i = 1; i <= m; i++) {
		if (cnt[i] > 2) {
			cout << 0 << endl;
			return;
		}
	}
	*/
	//vector<vector<int>>cnttt(n + 1, vector<int>(m + 1, 0));
	//vector<vector<int>>team(n + 1);

	set<int>a;
	for (int i = 1; i <= n; i++) {
		a.insert(Find(i));
		//team[Find(i)].push_back(i);
	}

	/*
	for (int i = 1; i <= n; i++) {
		if (team[i].empty())continue;

		
		for (auto x : team[i]) {

			bool c = false;

			for (int j = 1; j <= m; j++) {
				if (arr[x][j] == '1') {
					if (cnttt[i][j] + 1 >= 2) {
						c = true;
						break;

					}
				}
			}

			if (c) {
				for (int j = 1; j <= m; j++) {
					if (arr[x][j] == '1') {
						cnttt[i][m - j + 1]++;
						if (cnttt[i][m - j + 1] >= 2) {
							cout << 0 << endl;
							return;
						}
					}
				}
			}
			else {
				for (int j = 1; j <= m; j++) {
					if (arr[x][j] == '1') {
						cnttt[i][j]++;
						if (cnttt[i][j] >= 2) {
							cout << 0 << endl;
							return;
						}
					}
				}
			}
		}
	}*/

	vector<int>cc(m + 1, 0);
	for (int i = 1; i <= n; i++) {
		bool c = false;
		for (int j = 1; j <= m; j++) {
			if(arr[i][j]=='1') {
				if (cc[j] + 1 >= 2) {
					c = true;
					break;
				}
			}
		}
		if (c) {
			for (int j = 1; j <= m; j++) {
				if(arr[i][j]=='1') {
					cc[m - j + 1]++;
					if (cc[m - j + 1] >= 2) {
						cout << 0 << endl;
						return;
					}
				}
			}
		}
		else {
			for (int j = 1; j <= m; j++) {
				if(arr[i][j]=='1') {
					cc[j]++;
					if (cc[j] >= 2) {
						cout << 0 << endl;
						return;
					}
				}
			}
		}
	}
	
	ll t = 0;
	for (int i = 1; i <= n; i++) {
		if (connect[i] == i)t++;
	}

	ll ans = 1;
	ans = qmi(2, t);
	cout << ans << endl;
}
int main() {
	IOS;
	int t = 1; cin >> t;
	while (t--) {
		solve();
	}
}

詳細信息

Test #1:

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

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: 20ms
memory: 3564kb

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: 29ms
memory: 3852kb

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: 19ms
memory: 3636kb

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 102nd numbers differ - expected: '64', found: '0'