QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#787022#4068. Distinctive CharacterStayAloneAC ✓74ms16900kbC++142.2kb2024-11-27 08:46:592024-11-27 08:46:59

Judging History

This is the latest submission verdict.

  • [2024-11-27 08:46:59]
  • Judged
  • Verdict: AC
  • Time: 74ms
  • Memory: 16900kb
  • [2024-11-27 08:46:59]
  • Submitted

answer

#include <bits/stdc++.h>
#define rep1(i, l, r) for (int i = l; i <= int(r); ++i)
#define rep2(i, l, r) for (int i = l; i >= int(r); --i)
#define rer(i, l, r, a) rep1(i, l, r) read(a[i])
#define ptc putchar
#define il inline
#define eb emplace_back
#define ef emplace_front
#define mp make_pair
#define fst first
#define snd second
#define sqr(x) ((x) * (x))
#define ls(x) x << 1
#define rs(x) x << 1 | 1
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
// typedef __int128 bll;
// typedef unsigned __int128 ubll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int MAXN = 2e6 + 10, LOGN = log2(MAXN) + 1, inf = ~0U >> 2, INF = ~0U >> 1;
const int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
namespace stupid_lrc {
	template <typename T> il bool read(T &x) {
		x = 0; bool f = false; char ch;
 		while (!isdigit(ch = getchar())) {
			f ^= !(ch ^ '-');
			if (ch == EOF) return false;
		}
		while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch & 15), ch = getchar();
		if (f) x = ~x + 1; return true;
	}
	il int read() {int x; read(x); return x;}

	template <typename T> il bool read(pair <T, T> &x) {return read(x.fst) && read(x.snd);}

	template <typename T> il void gmin(T &x, T y) {x = x < y ? x : y;}

 	template <typename T> il void gmax(T &x, T y) {x = x > y ? x : y;}

	template <typename T, typename ...L>
	il bool read(T &x, L &...y) {return read(x) && read(y...);}

	template <typename T> il T lowbit(const T &x) {return x & -x;}
}
using namespace stupid_lrc;
int n, k, dis[MAXN], vis[MAXN];

int main() {
	read(n, k); queue <int> q;
	rep1(i, 0, (1 << k) - 1) dis[i] = inf;
	rep1(i, 1, n) {
		int x = 0; char ch;
 		while (!isdigit(ch = getchar()));
		while (isdigit(ch)) x = (x << 1) + (ch & 15), ch = getchar();
		dis[x] = 0; q.emplace(x);
	}
	while (q.size()) {
		int x = q.front(); q.pop();
		if (vis[x]) continue;
		vis[x] = 1;
		rep1(i, 0, k - 1) {
			int v = x ^ (1 << i);
			if (dis[v] > dis[x] + 1) dis[v] = dis[x] + 1, q.emplace(v);
		}
	} int mx = -1, ans = -1;
	rep1(i, 0, (1 << k) - 1) if (dis[i] > mx) mx = dis[ans = i];
	rep2(i, k - 1, 0) printf("%d", ans >> i & 1);
	return 0;
}


详细

Test #1:

score: 100
Accepted
time: 1ms
memory: 5824kb

input:

3 5
01001
11100
10111

output:

00010

result:

ok 

Test #2:

score: 0
Accepted
time: 1ms
memory: 5780kb

input:

1 4
0000

output:

1111

result:

ok 

Test #3:

score: 0
Accepted
time: 1ms
memory: 6132kb

input:

1 1
0

output:

1

result:

ok 

Test #4:

score: 0
Accepted
time: 1ms
memory: 5828kb

input:

1 2
01

output:

10

result:

ok 

Test #5:

score: 0
Accepted
time: 1ms
memory: 6056kb

input:

1 5
00100

output:

11011

result:

ok 

Test #6:

score: 0
Accepted
time: 56ms
memory: 14652kb

input:

1 20
00100000111011111010

output:

11011111000100000101

result:

ok 

Test #7:

score: 0
Accepted
time: 1ms
memory: 5772kb

input:

2 1
1
0

output:

0

result:

ok 

Test #8:

score: 0
Accepted
time: 1ms
memory: 5768kb

input:

2 2
10
01

output:

00

result:

ok 

Test #9:

score: 0
Accepted
time: 1ms
memory: 5828kb

input:

2 5
00010
00100

output:

11001

result:

ok 

Test #10:

score: 0
Accepted
time: 59ms
memory: 15112kb

input:

2 20
11110100100011011100
11110000000000110111

output:

00001011011100001000

result:

ok 

Test #11:

score: 0
Accepted
time: 0ms
memory: 6048kb

input:

100 1
0
1
1
1
0
0
0
1
1
1
0
1
1
1
1
0
1
1
0
0
1
0
0
1
0
1
0
1
1
0
0
1
1
1
0
0
0
1
0
1
1
0
1
1
0
0
0
0
1
1
1
1
1
1
1
1
0
1
1
1
0
0
1
1
0
0
1
0
0
0
0
1
1
1
1
0
0
0
0
0
1
0
0
1
0
0
1
1
1
1
1
0
0
1
1
1
1
0
1
0

output:

0

result:

ok 

Test #12:

score: 0
Accepted
time: 0ms
memory: 5772kb

input:

100 2
01
10
11
01
11
10
10
10
00
01
11
00
00
11
11
00
01
01
01
11
10
11
10
11
01
11
01
00
11
10
01
00
01
11
10
11
11
11
01
00
11
00
10
11
10
10
11
00
11
00
11
11
10
00
11
10
00
01
11
01
10
10
11
11
10
00
01
11
01
11
10
10
11
10
00
10
11
00
01
10
11
00
10
00
11
01
01
11
11
01
10
11
00
10
10
00
10
01
...

output:

00

result:

ok 

Test #13:

score: 0
Accepted
time: 0ms
memory: 5772kb

input:

100 5
10010
00111
11100
01100
11010
01110
11111
11101
11000
01110
00011
00001
11110
10011
10001
11011
00010
11000
10000
01101
10101
00010
11100
11000
01000
01000
00110
10011
10100
01100
10011
01000
01110
00110
00011
10111
10001
10110
11000
00101
11010
01100
11011
11011
11010
10111
01010
10010
00111
...

output:

01111

result:

ok 

Test #14:

score: 0
Accepted
time: 50ms
memory: 16028kb

input:

100 20
00110011101000101001
11111100011011011101
00101010010111100001
01010010011000010110
11000010001101110111
00010001010000101101
10110010110010111101
11101111110011100101
11111010001001111111
10011011000111001101
11011000110101101000
01110010110011100111
01111001010000101110
11100010010110111111...

output:

10001001001001010000

result:

ok 

Test #15:

score: 0
Accepted
time: 1ms
memory: 6052kb

input:

1000 1
0
1
1
0
1
0
0
0
1
0
0
1
0
1
1
1
1
1
1
0
0
0
1
0
1
1
1
0
0
1
0
0
1
1
0
1
0
0
0
0
1
0
1
1
0
0
0
1
0
0
0
1
1
1
0
1
1
1
0
1
0
1
1
0
0
0
1
0
1
1
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
1
0
1
1
1
0
0
0
0
0
1
0
1
1
0
1
1
1
0
1
1
0
1
1
1
0
0
1
1
0
1
0
0
1
1
0
1
0
0
0
0
1
0
1
1
0
0
1
1
1
0
1
0
0
0
1
0
0
1
0...

output:

0

result:

ok 

Test #16:

score: 0
Accepted
time: 1ms
memory: 5836kb

input:

1000 2
10
01
00
11
10
01
10
11
00
10
10
10
01
01
11
11
00
11
00
01
00
10
11
01
00
01
00
11
00
00
01
11
00
00
11
10
10
11
00
00
11
00
00
11
01
00
00
01
10
11
10
11
11
10
00
10
10
11
01
01
01
11
11
10
01
01
11
11
11
11
11
11
00
11
01
11
01
10
11
11
00
11
00
01
10
00
00
10
01
00
11
10
11
11
00
00
11
10...

output:

00

result:

ok 

Test #17:

score: 0
Accepted
time: 1ms
memory: 5832kb

input:

1000 5
01101
00000
00110
01001
10100
01001
01110
00011
00111
01000
10000
01110
01100
00101
01101
00100
00001
01011
10000
01110
10111
10001
00001
11101
00011
11110
00100
11110
00010
11111
00101
00100
01001
11110
11000
01100
01110
11101
00111
00000
10100
11011
00001
00101
11010
00010
11010
00101
11101...

output:

00000

result:

ok 

Test #18:

score: 0
Accepted
time: 57ms
memory: 16004kb

input:

1000 20
10010101010110101110
00001110001111100101
01100101111110000001
11011001011100011110
10010011111001010000
00010100100000100011
00100101000000101101
10110001001110011101
10010111111011011000
11011000010011011011
00100111100010101111
11010111110111111101
01000110010110110101
0010001110010001001...

output:

00000000000001100000

result:

ok 

Test #19:

score: 0
Accepted
time: 2ms
memory: 5912kb

input:

100000 1
1
1
1
1
0
0
0
0
0
0
0
0
1
0
1
0
0
1
1
1
0
1
1
0
1
1
1
0
1
0
1
1
1
1
1
0
0
0
1
1
0
1
0
0
0
1
1
1
0
1
1
0
1
0
0
1
0
0
1
0
0
1
0
0
1
1
1
0
0
0
1
0
1
1
0
1
1
0
1
0
1
0
1
0
0
1
1
1
1
0
1
1
0
0
1
1
1
1
1
0
0
1
0
0
1
1
0
0
0
0
1
1
1
1
1
0
0
0
1
1
1
1
1
1
0
0
1
0
1
0
1
0
0
1
0
0
1
1
1
1
1
1
0
0
1
1...

output:

0

result:

ok 

Test #20:

score: 0
Accepted
time: 0ms
memory: 5844kb

input:

100000 2
00
00
01
01
10
00
01
10
00
00
00
00
10
11
00
10
01
10
10
11
00
10
10
00
10
01
10
01
00
11
01
10
01
11
10
11
00
01
11
11
01
10
00
01
00
11
00
10
01
01
00
11
01
01
11
10
11
01
01
00
11
11
01
10
01
00
01
10
01
10
10
10
11
11
10
00
00
01
01
00
01
01
01
11
01
10
11
01
10
00
10
01
00
01
11
00
00
...

output:

00

result:

ok 

Test #21:

score: 0
Accepted
time: 0ms
memory: 5848kb

input:

100000 5
10110
10000
00110
10111
11011
00101
11100
10111
11001
10101
00011
11001
00101
00010
10011
00110
00111
00010
10111
10000
11000
10000
00010
01111
11101
10010
11101
11010
10010
10111
10001
10010
10111
10101
11111
11110
00010
10010
10000
11101
11101
10110
10111
11110
10010
01000
01000
10111
001...

output:

00000

result:

ok 

Test #22:

score: 0
Accepted
time: 74ms
memory: 16700kb

input:

100000 20
00010100001101110001
00011111101100000111
11111101101111100110
00110100100100001010
01101010010100000001
00011100000101001101
01110010100110000001
11110011101010011100
11011100010011110011
01101010011110111101
10011111101011010111
00100000010001101100
10111010101001011001
10011000101000100...

output:

00000000000000000100

result:

ok 

Test #23:

score: 0
Accepted
time: 71ms
memory: 16692kb

input:

99973 20
11000111000011101101
00101101011110011100
11001101000001011110
10001110100000001011
11010111110010111010
10000011000101000010
01001010001111101100
00111101100111101100
10111111101111111101
10000111000011100101
01110100000110010111
10111000010011000010
00001001110010110110
111011010010111011...

output:

01110011111000010011

result:

ok 

Test #24:

score: 0
Accepted
time: 58ms
memory: 16900kb

input:

9988 20
11000111000011101101
00101101011110011100
11001101000001011110
10001110100000001011
11010111110010111010
10000011000101000010
01001010001111101100
00111101100111101100
10111111101111111101
10000111000011100101
01110100000110010111
10111000010011000010
00001001110010110110
1110110100101110111...

output:

01110011111000010011

result:

ok 

Test #25:

score: 0
Accepted
time: 61ms
memory: 15912kb

input:

981 20
11000111000011101101
00101101011110011100
11001101000001011110
10001110100000001011
11010111110010111010
10000011000101000010
01001010001111101100
00111101100111101100
10111111101111111101
10000111000011100101
01110100000110010111
10111000010011000010
00001001110010110110
11101101001011101111...

output:

01110011111000010011

result:

ok 

Test #26:

score: 0
Accepted
time: 53ms
memory: 15872kb

input:

467 20
11000111000011101101
00101101011110011100
11001101000001011110
10001110100000001011
11010111110010111010
10000011000101000010
01001010001111101100
00111101100111101100
10111111101111111101
10000111000011100101
01110100000110010111
10111000010011000010
00001001110010110110
11101101001011101111...

output:

01110011111000010011

result:

ok 

Test #27:

score: 0
Accepted
time: 58ms
memory: 16136kb

input:

172 20
11000111000011101101
00101101011110011100
11001101000001011110
10001110100000001011
11010111110010111010
10000011000101000010
01001010001111101100
00111101100111101100
10111111101111111101
10000111000011100101
01110100000110010111
10111000010011000010
00001001110010110110
11101101001011101111...

output:

01110011111000010011

result:

ok 

Test #28:

score: 0
Accepted
time: 64ms
memory: 14712kb

input:

100000 20
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111110
00011111010010111...

output:

11100000101101000001

result:

ok