QOJ.ac
QOJ
ID | Problem | Submitter | Result | Time | Memory | Language | File size | Submit time | Judge time |
---|---|---|---|---|---|---|---|---|---|
#360959 | #6299. Binary String | mazihang2022 | TL | 1568ms | 12052kb | C++14 | 3.2kb | 2024-03-22 16:31:04 | 2024-03-22 16:31:04 |
Judging History
answer
#include<bits/stdc++.h>
#define ll long long
#define fir first
#define sec second
#define pii pair<int,int>
#define isz(v) (int)(v.size())
using namespace std;
const int maxn=1000005;
const int inf=0x3f3f3f3f;
namespace Solve {
int n;
int a[maxn];
int t[maxn];
int c[maxn];
int res[maxn];
int fail[maxn];
void clear() {
fill(c+1,c+n+1,0);
fill(res+1,res+n+1,0);
fill(fail+1,fail+n+1,0);
}
void deal(int p) {
int cnt=0;
for(int i=p+1;i<=n;i++) {
t[++cnt]=a[i];
}
for(int i=1;i<=p;i++) {
t[++cnt]=a[i];
}
for(int i=1;i<=n;i++) {
a[i]=t[i];
}
}
void main(int tid) {
string s;
cin>>s;
n=isz(s);
for(int i=1;i<=n;i++) {
a[i]=s[i-1]-'0';
}
int cc=accumulate(a+1,a+n+1,0);
if(!cc||cc==n) {
cout<<"1\n";
return ;
}
if(cc>=n-cc) {
for(int i=1;i<=n;i++) {
a[i]^=1;
}
reverse(a+1,a+n+1);
}
int sum=0,mi=inf,pos=0;
for(int i=n;i>=1;i--) {
sum+=!a[i]?1:-1;
if(sum<mi) {
mi=sum;
pos=i;
}
}
if(pos) {
deal(pos-1);
}
// for(int i=1;i<=n;i++) {
// cerr<<a[i]<<" ";
// }
// cerr<<"\n";
sum=0,pos=0;
for(int i=n;i>=1;i--) {
sum+=!a[i]?1:-1;
if(!sum) {
pos=i;
}
}
if(pos) {
deal(pos-1);
}
// for(int i=1;i<=n;i++) {
// cerr<<a[i]<<" ";
// }
// cerr<<"\n";
int cnt=0,p=0;
++cnt;
while(a[c[cnt]+1]) {
c[cnt]++;
}
for(int i=1;i<=n;i++) {
if(!a[i]) {
if(p) {
++cnt;
for(int j=p+1;j<=i;j++) {
c[cnt]+=a[j];
}
}
p=i;
}
}
int e=0;
while(!c[e+1]) {
e++;
}
// for(int i=1;i<=cnt;i++) {
// cerr<<c[i]<<" ";
// }
// cerr<<"\n";
int ans=0;
while(*max_element(c+1,c+cnt+1)>1) {
for(int i=1;i<=cnt;i++) {
if(c[i]) {
int j=i;
while(j<=cnt&&c[j]) {
j++;
}
j--;
c[j]--;
c[i-1]++;
i=j;
}
}
// cerr<<"c: ";
// for(int i=1;i<=cnt;i++) {
// cerr<<c[i]<<" ";
// }
// cerr<<"\n";
ans++;
}
for(int i=cnt-ans+1+e;i<=cnt;i++) {
c[i]++;
}
int cur=0;
for(int i=1;i<=cnt;i++) {
while(c[i]--) {
res[++cur]=1;
}
res[++cur]=0;
}
for(int i=1;i<=ans;i++) {
for(int i=1;i<=n;i++) {
res[i]=a[i];
}
for(int i=1;i<=n;i++) {
if(!a[i]&&a[i%n+1]) {
swap(res[i],res[i%n+1]);
}
}
for(int i=1;i<=n;i++) {
a[i]=res[i];
}
}
// cerr<<ans<<"\n";
// for(int i=1;i<=n;i++) {
// cerr<<res[i]<<" ";
// }
// cerr<<"\n";
int j=0;
for(int i=2;i<=n;i++) {
while(j&&res[i]!=res[j+1]) {
j=fail[j];
}
if(res[i]==res[j+1]) {
j++;
}
fail[i]=j;
}
if(n%(n-fail[n])==0) {
ans+=n-fail[n];
} else {
ans+=n;
}
cout<<ans<<"\n";
}
void init() {
}
}
signed main() {
#ifndef ONLINE_JUDGE
freopen("data.in","r",stdin);
freopen("data.out","w",stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
int T=1;
cin>>T;
Solve::init();
for(int t=1;t<=T;t++) {
Solve::main(t);
Solve::clear();
}
#ifndef ONLINE_JUDGE
cerr<<"Time: "<<(1.0*clock()/CLOCKS_PER_SEC)*1000<<"ms\n";
#endif
}
Details
Tip: Click on the bar to expand more detailed information
Test #1:
score: 100
Accepted
time: 0ms
memory: 11772kb
input:
3 1 001001 0001111
output:
1 3 9
result:
ok 3 number(s): "1 3 9"
Test #2:
score: 0
Accepted
time: 173ms
memory: 12052kb
input:
262144 000000000000000000 100000000000000000 010000000000000000 110000000000000000 001000000000000000 101000000000000000 011000000000000000 111000000000000000 000100000000000000 100100000000000000 010100000000000000 110100000000000000 001100000000000000 101100000000000000 011100000000000000 11110000...
output:
1 18 18 19 18 18 19 20 18 18 18 20 19 19 20 21 18 18 18 19 18 18 20 21 19 19 19 21 20 20 21 22 18 18 18 19 18 18 19 21 18 18 18 21 20 20 21 22 19 19 19 19 19 19 21 22 20 20 20 22 21 21 22 23 18 18 18 19 18 18 19 20 18 18 18 20 19 19 21 22 18 18 18 19 18 18 21 22 20 20 20 22 21 21 22 23 19 19 19 19 1...
result:
ok 262144 numbers
Test #3:
score: 0
Accepted
time: 368ms
memory: 11852kb
input:
524288 0000000000000000000 1000000000000000000 0100000000000000000 1100000000000000000 0010000000000000000 1010000000000000000 0110000000000000000 1110000000000000000 0001000000000000000 1001000000000000000 0101000000000000000 1101000000000000000 0011000000000000000 1011000000000000000 0111000000000...
output:
1 19 19 20 19 19 20 21 19 19 19 21 20 20 21 22 19 19 19 20 19 19 21 22 20 20 20 22 21 21 22 23 19 19 19 20 19 19 20 22 19 19 19 22 21 21 22 23 20 20 20 20 20 20 22 23 21 21 21 23 22 22 23 24 19 19 19 20 19 19 20 21 19 19 19 21 20 20 22 23 19 19 19 20 19 19 22 23 21 21 21 23 22 22 23 24 20 20 20 20 2...
result:
ok 524288 numbers
Test #4:
score: 0
Accepted
time: 520ms
memory: 9840kb
input:
952358 0011101111 101010101101 101111111010100 0101011000110001100 0101111101110 010 100100000111011 011010110110011 1010111 1 1111101010 11111011001111110 0101101101011 001 1100111100 100011 10 10 0001 011100 1100010 111111101010010 01001111110011011 01100 1010 10101111 01000111100011111110 10101 0...
output:
11 12 18 20 14 3 21 16 7 1 10 18 13 3 11 4 2 2 4 4 8 18 19 6 2 8 24 5 1 1 5 25 1 14 1 15 20 3 7 24 12 10 20 21 23 1 22 18 22 5 1 6 18 12 1 4 5 12 13 12 21 1 5 12 21 8 1 8 18 4 1 12 13 6 3 3 16 6 8 1 1 17 1 1 1 6 6 4 4 10 7 5 4 5 24 6 11 4 8 15 3 9 9 19 5 16 11 5 6 9 17 1 25 14 6 1 4 20 1 4 20 14 14 ...
result:
ok 952358 numbers
Test #5:
score: 0
Accepted
time: 631ms
memory: 9756kb
input:
645561 001000111110000 01001111000 01011010 110000110111111111 0110100010000100 0 010011 010011111 00000111100001101110101100001 10111111000 100 1101100000001010110110101 1001111101 000100 101 1110101100011111101001111 000111100111100 1111001101011000000 100101001001001010111011011111 10111001100111...
output:
19 14 4 21 18 1 4 11 37 13 3 34 11 6 3 29 21 27 38 24 13 22 26 39 26 31 10 22 1 17 34 40 18 9 29 31 11 3 28 15 20 27 29 16 2 23 18 31 5 14 33 18 1 1 18 7 36 17 34 1 18 6 16 20 19 3 18 36 21 23 21 4 30 12 4 35 16 18 35 2 25 20 31 17 26 24 3 24 6 26 25 17 13 7 24 27 25 18 22 10 20 4 6 23 17 30 16 22 3...
result:
ok 645561 numbers
Test #6:
score: 0
Accepted
time: 717ms
memory: 9820kb
input:
488486 01101101 011000000100011010101011010 0100101110001011 00111110011110011010001101010000 11010010000010011111011010000010001 01001111001000010110 10110010011010100101010101111 10100000000001 1000010010 0 1111 10001010011011001111100101010 01010111100001011111011110101110101 11100 10101010001101...
output:
8 36 4 17 43 24 33 16 10 1 1 39 38 6 40 30 51 17 41 1 1 12 34 49 44 38 18 47 39 14 35 32 14 36 31 37 23 42 3 10 18 15 21 14 33 11 17 5 18 45 39 31 38 52 27 22 38 15 16 26 30 3 2 3 29 1 41 40 14 17 24 50 21 34 11 31 9 31 18 32 21 43 1 42 39 10 36 27 27 29 15 13 1 24 46 22 21 13 29 13 14 45 47 45 43 1...
result:
ok 488486 numbers
Test #7:
score: 0
Accepted
time: 792ms
memory: 9700kb
input:
392510 01 00110011011000101011100 0100001010100011111011100011101011111100001110 1011001 00100110000011010 1101110 000100011000001111111100101011110111010111110 0111110000001010111110100011 0100111110000000111101110011011100100 100110000111101101101011011110001101111 111 0000001101011 11101100 10000...
output:
2 26 62 8 19 7 59 34 54 44 1 17 9 43 37 5 1 17 10 30 52 32 11 36 16 37 45 31 12 44 31 45 43 16 11 10 51 41 48 31 22 1 13 1 33 27 25 35 2 5 15 27 6 49 33 3 33 38 52 60 48 28 35 31 25 5 1 44 67 31 36 6 24 31 1 35 56 44 38 36 15 14 49 61 57 61 44 22 38 27 11 51 53 13 30 34 4 56 51 18 2 29 42 51 2 15 9 ...
result:
ok 392510 numbers
Test #8:
score: 0
Accepted
time: 1083ms
memory: 9976kb
input:
197451 00010111010000100100110001010100100100101001111001000101101001010111100010110101001000001 0000011 11010001011010010010001000011111001110110100111110000010101100110000001100111 0110101110000001001010100 10100010 0110100111 010101000100011001110000000110000000011101010011101 0000110110101011001...
output:
98 8 112 30 8 12 63 96 73 123 10 106 5 106 28 24 101 44 85 109 69 29 104 76 106 111 126 8 106 89 44 36 9 56 9 111 28 37 94 6 102 2 116 19 5 50 32 17 97 114 127 12 26 9 90 133 109 9 66 27 95 1 59 59 93 40 139 84 51 33 101 127 27 1 86 12 95 41 90 134 87 24 109 57 11 85 60 50 4 52 133 66 58 15 41 45 11...
result:
ok 197451 numbers
Test #9:
score: 0
Accepted
time: 1568ms
memory: 10044kb
input:
99606 110011011001101010010101101110011100110101 111110001011000010010110011001110111010101100110100001111 1111111111110101101011000101101101101110011110100001100010 00110110000101111000010011100010011110101000111110010011111110011011100001001111101001010000101010000100101111001001110010100001000100...
output:
45 66 67 227 261 108 39 44 204 26 72 249 44 130 44 80 39 180 23 148 157 66 201 157 150 151 184 137 252 102 139 36 51 216 9 17 141 216 253 241 92 220 52 139 125 75 98 162 202 2 50 117 170 46 154 95 132 202 23 154 222 210 17 91 39 163 145 184 98 225 35 12 163 197 247 78 28 85 207 177 145 65 1 101 231 ...
result:
ok 99606 numbers
Test #10:
score: -100
Time Limit Exceeded
input:
39961 0010111101010101011101101111110000010000000011100101001100100001101101110110110111000100111010001110101000001011011011101110000111001011001000101000000110100111100110011010011 0011110111000100101111001001010100001011111111011001000110011001100000110110001101001110011100001010100100001010110100...
output:
218 247 101 564 482 45 274 1 342 161 263 364 76 233 581 28 229 134 514 690 722 234 109 555 553 696 481 383 88 78 510 226 603 498 175 10 307 542 333 731 447 608 153 304 193 427 372 242 383 640 664 93 126 434 176 69 361 547 418 518 372 63 439 359 15 249 394 311 194 341 423 202 90 594 595 206 141 154 3...