QOJ.ac
QOJ
ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
---|---|---|---|---|---|---|---|---|---|
#787022 | #4068. Distinctive Character | StayAlone | AC ✓ | 74ms | 16900kb | C++14 | 2.2kb | 2024-11-27 08:46:59 | 2024-11-27 08:46:59 |
Judging History
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