solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2000005;
int n, m;
int in[MAX_N];
int inv[MAX_N];
int out[MAX_N], temp[MAX_N];
int pos2bckt[MAX_N];
int bckt[MAX_N], relabel[MAX_N];
int bpos[MAX_N];
void build() {
for (int i = 0; i < n; i++) out[i] = i;
sort(out, out + n, [](int a, int bckt) { return in[a] < in[bckt]; });
for (int i = 0, c = 0; i < n; i++) {
bckt[i] = c;
if (i + 1 == n || in[out[i]] != in[out[i + 1]]) c++;
}
for (int h = 1; h < n; h <<= 1) {
for (int i = 0; i < n; i++) pos2bckt[out[i]] = bckt[i];
for (int i = n - 1; i >= 0; i--) bpos[bckt[i]] = i;
for (int i = 0; i < n; i++)
if (out[i] >= n - h) temp[bpos[bckt[i]]++] = out[i];
for (int i = 0; i < n; i++)
if (out[i] >= h) temp[bpos[pos2bckt[out[i] - h]]++] = out[i] - h;
for (int i = 0, c = 0; i < n; i++) {
relabel[i] = c;
if (i + 1 == n) break;
if (bckt[i] != bckt[i + 1])
c++;
else if (temp[i + 1] >= n - h || temp[i] >= n - h)
c++;
else if (pos2bckt[temp[i + 1] + h] != pos2bckt[temp[i] + h])
c++;
}
memcpy(out, temp, sizeof(temp[0]) * n);
memcpy(bckt, relabel, sizeof(relabel[0]) * n);
}
}
char str[MAX_N];
int cnt[MAX_N], mmn[MAX_N], rmmn[MAX_N];
int main() {
scanf("%s", str);
while (str[n]) n++;
for (int i = 0; i < n; i++) in[i] = str[i] == ')';
for (int i = 0; i < n; i++) in[i + n] = in[i];
int step = 0, mn = 0;
for (int i = 0; i < n; i++) {
if (in[i] == 1)
step--;
else
step++;
cnt[i + 1] = step;
if (mn > step) mn = step;
mmn[i + 1] = mn;
}
int p = step;
for (int i = n - 1; i >= 0; i--) {
if (in[i] == 1)
step++;
else
step--;
if (p > step) p = step;
rmmn[i] = p;
}
n *= 2;
build();
n /= 2;
int c[2] = {
0,
};
for (int i = 0; i < n; i++) c[in[i]]++;
if (c[0] >= c[1]) {
for (int i = 0; i < 2 * n; i++) {
if (out[i] < n && rmmn[out[i]] - cnt[out[i]] >= 0 &&
cnt[n] - cnt[out[i]] + mmn[out[i]] >= 0) {
for (int j = 0; j < n; j++) str[j] = in[out[i] + j] == 0 ? '(' : ')';
for (int j = n, k = 0; k < c[0] - c[1]; j++, k++) str[j] = ')';
break;
}
}
} else {
for (int i = 0; i < 2 * n; i++) {
if (out[i] < n && rmmn[out[i]] - cnt[out[i]] >= c[0] - c[1] &&
cnt[n] - cnt[out[i]] + mmn[out[i]] >= c[0] - c[1]) {
for (int j = 0; j < c[1] - c[0]; j++) str[j] = '(';
for (int j = c[1] - c[0], k = 0; k < n; j++, k++)
str[j] = in[out[i] + k] == 0 ? '(' : ')';
break;
}
}
}
puts(str);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[1000100];
int a[2000100], add[8000100], min_[8000100], ans[2000100];
int rk[2000100], rkk[2000100], cnt[2000100], tp[2000100], tpp[2000100];
void pushdown(int rt) {
add[rt << 1] += add[rt];
min_[rt << 1] += add[rt];
add[rt << 1 | 1] += add[rt];
min_[rt << 1 | 1] += add[rt];
add[rt] = 0;
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return min_[rt];
int m = l + r >> 1, ans = 998244353;
pushdown(rt);
if (m >= L) ans = min(ans, query(L, R, l, m, rt << 1));
if (m < R) ans = min(ans, query(L, R, m + 1, r, rt << 1 | 1));
return ans;
}
void pushup(int rt) { min_[rt] = min(min_[rt << 1], min_[rt << 1 | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
min_[rt] = a[l];
return;
}
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
void update(int L, int R, int c, int l, int r, int rt) {
if (L <= l && r <= R) {
min_[rt] += c;
add[rt] += c;
return;
}
pushdown(rt);
int m = l + r >> 1;
if (m >= L) update(L, R, c, l, m, rt << 1);
if (m < R) update(L, R, c, m + 1, r, rt << 1 | 1);
pushup(rt);
}
int main() {
scanf("%s", s);
int n = strlen(s);
int i, t, sum = 0, cntl = 0, cntr = 0;
for (i = 0; i < n; i++) {
if (s[i] == '(')
t = 1, cntl++;
else
t = -1, cntr++;
sum += t;
a[n + i] = sum;
}
build(1, n << 1, 1);
int del, temp;
if (cntl < cntr)
del = cntr - cntl;
else
del = 0;
for (i = 0; i < n; i++) {
if (query(n - i, (n << 1) - i - 1, 1, n << 1, 1) + del < 0)
ans[(n - i) % n] = 0;
else
ans[(n - i) % n] = 1;
if (s[n - i - 1] == '(')
temp = 1;
else
temp = -1;
if (i + 1 != n) update(n - i - 1, (n << 1) - i - 2, temp, 1, n << 1, 1);
}
for (i = 0; i < n; i++) {
cnt[s[i] - 39]++;
}
for (i = 1; i <= 2; i++) {
cnt[i] += cnt[i - 1];
}
for (i = n - 1; i >= 0; i--) {
tpp[--cnt[s[i] - 39]] = i;
}
rk[tpp[0]] = 1;
for (i = 1; i < n; i++) {
if (s[tpp[i]] == s[tpp[i - 1]])
rk[tpp[i]] = rk[tpp[i - 1]];
else
rk[tpp[i]] = rk[tpp[i - 1]] + 1;
}
int j;
for (i = 1; i < n; i <<= 1) {
if (rk[tpp[n - 1]] == n) break;
for (j = 0; j < n; j++) {
tp[j] = (tpp[j] + n - i) % n;
}
memset(cnt, 0, sizeof(cnt));
for (j = 0; j < n; j++) {
cnt[rk[j]]++;
}
for (j = 1; j <= n; j++) {
cnt[j] += cnt[j - 1];
}
for (j = n - 1; j >= 0; j--) {
tpp[--cnt[rk[tp[j]]]] = tp[j];
}
rkk[tpp[0]] = 1;
for (j = 1; j < n; j++) {
if (rk[tpp[j]] == rk[tpp[j - 1]] &&
rk[(tpp[j] + i) % n] == rk[(tpp[j - 1] + i) % n])
rkk[tpp[j]] = rkk[tpp[j - 1]];
else
rkk[tpp[j]] = rkk[tpp[j - 1]] + 1;
}
memcpy(rk, rkk, sizeof(rk));
}
int fin;
for (i = 0; i < n; i++) {
if (ans[tpp[i]]) {
fin = tpp[i];
break;
}
}
if (cntl < cntr) {
while (cntl < cntr) putchar('('), cntl++;
for (i = 0; i < n; i++) putchar(s[(i + fin) % n]);
} else {
for (i = 0; i < n; i++) putchar(s[(i + fin) % n]);
while (cntr < cntl) putchar(')'), cntr++;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
static constexpr size_t maxlen = 1000000;
int main() {
static char text[maxlen];
size_t len = fread(text, 1, maxlen, stdin);
while (len && text[len - 1] < ' ') --len;
static unsigned deque[maxlen];
size_t begin = 0, end = 0;
int balance = 0;
for (size_t i = 0; i < len; ++i) {
if (text[i] == '(')
++balance, deque[end++] = i;
else
--balance, end && --end;
}
size_t start = -1;
for (size_t i = 0, j = 1; i < len; ++i) {
while (begin < end && deque[begin % len] < i) ++begin;
for (; j <= i; ++j) {
if (text[j - 1] == '(')
deque[end++ % len] = j - 1 + len;
else if (begin < end)
--end;
}
if (end - begin > max(balance, 0)) continue;
if (start == -1) {
start = i;
continue;
}
size_t k = 0;
while (k < len && text[(i + k) % len] == text[(start + k) % len]) ++k;
if (k == len)
break;
else if (text[(i + k) % len] > text[(start + k) % len])
i += k;
else
start = max(start + k, i), swap(start, i);
}
while (balance < 0) putchar('('), ++balance;
fwrite(text + start, 1, len - start, stdout);
fwrite(text, 1, start, stdout);
while (balance > 0) putchar(')'), --balance;
putchar('\n');
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2111111;
char buf[maxn];
int sum[maxn];
bool ok[maxn];
int order[maxn];
template <typename T>
void debug(T a[], int n) {
for (int i = 1; i <= n; ++i) {
cout << setw(3) << a[i];
}
puts("");
}
void fix(int& i, int n) {
while (!ok[i] && i <= n) {
++i;
}
}
int run(char s[], int m) {
int n = m >> 1;
int i = 1, j = 2, k = 0;
fix(i, n);
j = i + 1;
fix(j, n);
while (j <= n && i <= n) {
for (k = 0; k < n; ++k) {
if (s[i + k] ^ s[j + k]) {
break;
}
}
if (s[i + k] > s[j + k]) {
i += k + 1;
fix(i, n);
} else {
j += k + 1;
fix(j, n);
}
if (j == i) {
++j;
fix(j, n);
}
}
return std::min(i, j);
}
int main() {
for (int i = 1; i < 100; ++i) {
order[i] = i;
}
scanf("%s", buf + 1);
int n = std::strlen(buf + 1);
int A, B;
A = B = 0;
for (int i = 1; i <= n; ++i) {
buf[i + n] = buf[i];
if (buf[i] == '(') {
++A;
} else {
++B;
}
}
int m = n << 1;
for (int i = 1; i <= m; ++i) {
if (buf[i] == '(') {
sum[i] = 1;
} else {
sum[i] = -1;
}
sum[i] += sum[i - 1];
}
static int q[maxn];
int front, rear;
front = rear = 0;
static int min[maxn];
int add = 0;
if (A < B) {
add = B - A;
}
for (int i = 1; i <= m; ++i) {
if (front < rear && q[front] + n <= i) {
++front;
}
while (front < rear && sum[q[rear - 1]] >= sum[i]) {
--rear;
}
q[rear++] = i;
min[i] = sum[q[front]];
}
for (int i = 1; i <= n; ++i) {
if (add + min[i + n - 1] >= sum[i - 1]) {
ok[i] = true;
}
}
int index = run(buf, m);
auto print = [](char ch, int n) {
while (n--) {
putchar(ch);
}
};
if (A < B) {
print('(', B - A);
}
for (int i = index; i < index + n; ++i) {
putchar(buf[i]);
}
if (B < A) {
print(')', A - B);
}
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const long long bas = 131, mod = 2147483647;
long long pw[N], hsh[2 * N], num[2 * N], fsum[2 * N], que[2 * N];
long long dif, len, c1, c2, f, b, h;
char rd[N];
int main() {
scanf("%s", rd), len = strlen(rd);
for (int i = 0; i < len; i++)
num[i + 1] = num[i + 1 + len] = ((rd[i] == '(') ? 1 : 2),
(rd[i] == '(') ? c1++ : c2++;
pw[0] = 1, f = 1, dif = abs(c1 - c2);
for (int i = 1; i <= len; i++) pw[i] = pw[i - 1] * bas % mod;
for (int i = 1; i <= 2 * len; i++) {
fsum[i] = fsum[i - 1] + ((num[i] == 1) ? 1 : -1);
hsh[i] = (hsh[i - 1] * bas + num[i]) % mod;
}
for (int i = 1; i < len; i++) {
while (f <= b && fsum[i] <= fsum[que[b]]) b--;
que[++b] = i;
}
for (int i = len; i <= 2 * len; i++) {
while (f <= b && fsum[i] <= fsum[que[b]]) b--;
que[++b] = i;
int l = f, r = b, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (que[mid] + len < i + 1)
l = mid + 1;
else
r = mid - 1, ans = mid;
}
bool i1 = fsum[i - len] - fsum[que[ans]] > dif;
bool i2 = fsum[que[ans]] - fsum[i - len] < 0;
if ((c1 <= c2 && i1) || (c1 >= c2 && i2)) continue;
l = 1, r = len, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
long long hsh1 =
((hsh[i - len + mid] - hsh[i - len] * pw[mid] % mod) % mod + mod) %
mod;
long long hsh2 =
((hsh[h - 1 + mid] - hsh[h - 1] * pw[mid] % mod) % mod + mod) % mod;
if (hsh1 != hsh2)
r = mid - 1;
else
l = mid + 1, ans = mid;
}
if (num[i - len + ans + 1] < num[h + ans] || !h) h = i - len + 1;
}
if (c1 < c2)
for (int j = 1; j <= dif; j++) printf("(");
for (int j = 1; j <= len; j++)
(num[j + h - 1] == 1) ? printf("(") : printf(")");
if (c1 > c2)
for (int j = 1; j <= dif; j++) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 1000007;
const int MAX2 = 2000;
const int BASE = 1000000000;
char s[MAX];
int v[MAX];
set<pair<int, int> > S;
int cur = 0;
int p[MAX], cnt[MAX], c[MAX];
int pn[MAX], cn[MAX];
int main() {
scanf("%s", s);
int n = strlen(s);
int val = 0;
for (int i = (0); i < (n); ++i) {
if (s[i] == '(') {
++val;
} else {
--val;
}
v[i] = val;
S.insert(make_pair(val, i));
}
vector<int> ids;
int M = -INF;
for (int it = (0); it < (n); ++it) {
int V = min(S.begin()->first + cur, 0);
if (V > M) {
ids.clear();
}
if (V >= M) {
M = V;
ids.push_back((n - it) % n);
}
int id = n - it - 1;
S.erase(make_pair(v[id], id));
if (s[id] == '(') {
++cur;
v[id] = 1 - cur;
S.insert(make_pair(v[id], id));
} else {
--cur;
v[id] = -1 - cur;
S.insert(make_pair(v[id], id));
}
}
memset(cnt, 0, sizeof(cnt));
for (int i = (0); i < (n); ++i) ++cnt[s[i] - '('];
cnt[1] += cnt[0];
for (int i = (0); i < (n); ++i) p[--cnt[s[i] - '(']] = i;
c[p[0]] = 0;
int classes = 1;
for (int i = 1; i < n; ++i) {
if (s[p[i]] != s[p[i - 1]]) ++classes;
c[p[i]] = classes - 1;
}
for (int h = 0; (1 << h) < n; ++h) {
for (int i = (0); i < (n); ++i) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += n;
}
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; ++i) ++cnt[c[pn[i]]];
for (int i = 1; i < classes; ++i) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; --i) p[--cnt[c[pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (int i = 1; i < n; ++i) {
int mid1 = (p[i] + (1 << h)) % n, mid2 = (p[i - 1] + (1 << h)) % n;
if (c[p[i]] != c[p[i - 1]] || c[mid1] != c[mid2]) ++classes;
cn[p[i]] = classes - 1;
}
memcpy(c, cn, n * sizeof(int));
}
int cl = INF;
int id;
for (int i = (0); i < (ids.size()); ++i) {
if (cn[ids[i]] < cl) {
cl = cn[ids[i]];
id = ids[i];
}
}
string R = "";
for (int i = (0); i < (abs(M)); ++i) {
R += '(';
}
for (int i = (id); i < (n); ++i) {
R += s[i];
}
for (int i = (0); i < (id); ++i) {
R += s[i];
}
val = 0;
for (int i = (0); i < (R.size()); ++i) {
if (R[i] == '(')
++val;
else
--val;
}
for (int i = (0); i < (val); ++i) {
R += ')';
}
printf("%s", R.c_str());
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, T, x, mmh, la, pos;
char a[2000003], c[2000003];
int s[2000003], SS = 0, A, len;
int v[2000003], sa[2000003], q[2000003], ran[2000003], st[2000003], y[2000003],
P[2000003];
bool bo[2000003];
int read_p, read_ca;
inline int read() {
read_p = 0;
read_ca = getchar();
while (read_ca < '0' || read_ca > '9') read_ca = getchar();
while (read_ca >= '0' && read_ca <= '9')
read_p = read_p * 10 + read_ca - 48, read_ca = getchar();
return read_p;
}
inline void gr(int x) {
ran[sa[1]] = 1;
for (register int i = 2; i <= n; i++)
ran[sa[i]] = ran[sa[i - 1]] + (s[sa[i]] != s[sa[i - 1]] ||
s[P[sa[i] + x]] != s[P[sa[i - 1] + x]]);
for (int i = 1; i <= n; i++) s[i] = ran[i];
m = max(ran[sa[n]], m);
}
inline void gv() {
for (int i = 0; i <= m; i++) v[i] = 0;
for (int i = 1; i <= n; i++) v[s[i]]++;
for (int i = 1; i <= m; i++) v[i] += v[i - 1];
}
inline void gsa() {
m = 2;
gv();
for (int i = n; i >= 1; i--) sa[v[s[i]]--] = i;
gr(0);
for (int i = 1; i < n; i <<= 1) {
gv();
for (int j = 1; j <= n; j++) y[j] = (sa[j] + n - i - 1) % n + 1;
for (register int j = n; j >= 1; j--) q[v[s[y[j]]]--] = y[j], SS++;
for (int j = 1; j <= n; j++) sa[j] = q[j];
gr(i);
if (ran[sa[n]] == n) return;
}
}
inline int min(int a, int b) { return a < b ? a : b; }
int main() {
int i;
scanf("%s", a + 1);
n = strlen(a + 1);
for (i = 1; i <= n; i++)
a[i] = a[i] == ')', s[i + n] = a[i + n] = s[i] = a[i], P[i] = P[i + n] = i;
gsa();
v[0] = 0;
for (i = 1; i <= n * 2; i++) sa[i], v[i] = v[i - 1] + (a[i] ? -1 : 1);
int l = 0, r = -1;
for (i = 1; i <= n * 2; i++) {
while (l <= r && st[l] < i - n + 1) l++;
while (l <= r && v[i] <= v[st[r]]) r--;
st[++r] = i;
if (i >= n) q[i - n] = v[st[l]];
}
mmh = min(v[n], 0);
for (i = 1; i <= n * 2; i++)
if (sa[i] <= n) {
pos = sa[i] - 1;
if (q[pos] >= v[pos] + mmh) break;
}
pos++;
for (i = pos; i <= n; i++) c[i - pos + 1] = a[i];
for (i = 1; i < pos; i++) c[n - pos + i + 1] = a[i];
for (pos = 0, i = 1; i <= n; i++) pos += a[i] ? -1 : 1;
if (pos < 0)
for (i = 0; i < -pos; i++) putchar('(');
for (i = 1; i <= n; i++) putchar(c[i] ? ')' : '(');
if (pos > 0)
for (i = 0; i < pos; i++) putchar(')');
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, s[2000100];
bool vis[2000100];
char t[2000100];
int sa[2000100], rnk[2000100], tmp[2000100], cnt[2000100];
void build(char *s) {
int n = strlen(s) + 1, m = 256;
int *x = rnk, *y = tmp, *z;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i] = s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[y[i]]]] = y[i];
z = x, x = y, y = z;
x[sa[0]] = 0, p = 1;
for (int i = 1; i < n; i++)
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + j] == y[sa[i - 1] + j])
? p - 1
: p++;
}
for (int i = 0; i < n; i++) rnk[sa[i]] = i;
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
int mn = 0;
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1];
if (t[i] == '(')
s[i]++;
else
s[i]--;
mn = min(mn, s[i]);
}
for (int i = 1; i <= n; i++) t[n + i] = t[i], s[i + n] = s[i] + s[n];
int dn = 0;
if (s[n] < 0) dn = -s[n];
build(t + 1);
multiset<int> S;
for (int i = n + 1; i <= 2 * n; i++) S.insert(s[i]);
int k, p = 1e9;
for (int i = n; i >= 0; i--) {
int t = *S.begin();
S.erase(S.find(s[i + n]));
if (t - s[i] + dn >= 0) {
if (rnk[i] < p) p = rnk[i], k = i + 1;
}
S.insert(s[i]);
}
int sum = s[n];
if (sum < 0)
for (int i = sum; i < 0; i++) putchar('(');
for (int i = 0; i < n; i++) putchar(t[k + i]);
if (sum > 0)
for (int i = 0; i < sum; i++) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
int d[1 << 22], e[1 << 22];
char s[2000100];
int h, m[2000100], p[2000100], a[2000100], b[2 * 2000100];
void sfa() {
int i, j, n;
for (n = 0; s[n]; m[n] = n, a[n] = s[n], n++)
;
for (h = 0, j = 0; j < n; h = h * 2 + !h) {
for (i = 0; i < n + 256; b[i] = 0, i++)
;
for (i = 0; i < n; ++b[a[i]], i++)
;
for (i = 0; i < n + 256; b[i + 1] += b[i], i++)
;
for (i = n; i--;)
if (m[i] >= h) p[--b[a[m[i] - h]]] = m[i] - h;
for (i = n - h; i < n; p[--b[a[i]]] = i, i++)
;
for (i = 0; i < n; m[i] = p[i], b[i] = a[i], b[n + i] = 0, i++)
;
for (j = 1, i = 0; i < n; a[m[i]] = j,
j += b[m[i]] < b[m[i + 1]] || b[m[i] + h] < b[m[i + 1] + h], i++)
;
}
}
int getm(int i, int j) {
int k = 0, l = 0;
for (i += h, j += h; i <= j; i = (i + 1) / 2, j = (j - 1) / 2) {
if (i & 1) a[k++] = i;
if (~j & 1) b[l++] = j;
}
for (; l > 0; l--, a[k++] = b[l])
;
for (l = 2 * 2000100, j = 0, i = 0; i < k; i++) {
l = min(l, j + d[a[i]]);
j += e[a[i]];
}
return l;
}
int main() {
int n, i, j, k, b;
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; s[i + n] = s[i], i++)
;
sfa();
b = 0;
for (i = 0; i < n; i++)
if (s[i] == '(')
b++;
else
b--;
for (h = 1; h < 2 * n; h *= 2)
;
for (i = 0; i < 2 * h; d[i] = 2 * 2000100, i++)
;
for (i = 0; i < 2 * n; i++)
if (s[i] == '(') {
d[h + i] = 1;
e[h + i] = 1;
} else {
d[h + i] = -1;
e[h + i] = -1;
}
for (i = h - 1; i > 0; i--) {
d[i] = min(d[2 * i], e[2 * i] + d[2 * i + 1]);
e[i] = e[2 * i] + e[2 * i + 1];
}
for (i = 0; i < 2 * n; i++) {
j = m[i];
if (j < n) {
k = getm(j, j + n - 1);
if (b < 0) k -= b;
if (k >= 0) break;
}
}
if (b < 0)
for (i = 0; i < -b; printf("("), i++)
;
for (i = 0; i < n; printf("%c", s[i + j]), i++)
;
if (b > 0)
for (i = 0; i < b; printf(")"), i++)
;
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
string st;
long bal[1 << 20];
long minsuf[1 << 20], minpref[1 << 20];
long val1, val2;
long n;
long s[1 << 20];
long p[1 << 20], pn[1 << 20], cnt[1 << 20], c[1 << 20], cn[1 << 20];
long classes, mid1, mid2;
long ans, k;
long open, clos;
long blen, bc, tlen, nopen;
int main() {
ios_base::sync_with_stdio(0);
cin >> st;
n = st.size();
for (int i = 0; i < n; i++)
if (st[i] == '(')
s[i] = 0;
else
s[i] = 1;
for (int i = 0; i < n; i++) ++cnt[s[i]];
for (int i = 1; i < 100; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i < n; i++) {
p[--cnt[s[i]]] = i;
}
c[p[0]] = 0;
classes = 1;
for (int i = 1; i < n; i++) {
if (s[p[i]] != s[p[i - 1]]) ++classes;
c[p[i]] = classes - 1;
}
for (int h = 0; (1 << h) < n; ++h) {
for (int i = 0; i < n; i++) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += n;
}
for (int i = 0; i <= classes; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[c[pn[i]]]++;
for (int i = 1; i < classes; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; --i) p[--cnt[c[pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (int i = 1; i < n; i++) {
mid1 = p[i] + (1 << h);
mid2 = p[i - 1] + (1 << h);
mid1 %= n;
mid2 %= n;
if (c[p[i]] != c[p[i - 1]] || c[mid1] != c[mid2]) ++classes;
cn[p[i]] = classes - 1;
}
for (int i = 0; i <= n; i++) c[i] = cn[i];
}
for (int i = 0; i < st.size(); i++) {
if (st[i] == '(')
bal[i + 1] = bal[i] + 1;
else
bal[i + 1] = bal[i] - 1;
minpref[i + 1] = min(minpref[i], bal[i + 1]);
if (st[i] == '(')
++open;
else
++clos;
}
minsuf[st.size()] = bal[st.size()];
for (int i = st.size() - 1; i + 1; --i) {
minsuf[i] = min(minsuf[i + 1], bal[i]);
}
blen = 1e9;
bc = 0;
for (int i = 0; i < st.size(); i++) {
val1 = minsuf[i + 1] - bal[i];
val2 = minpref[i] + (bal[st.size()] - bal[i]);
val1 = min(val1, val2);
if (val1 >= 0) {
tlen = st.size() + (open - clos);
if (tlen < blen || (tlen == blen && c[i] < c[bc])) {
blen = tlen;
bc = i;
}
} else {
nopen = open - val1;
tlen = st.size() + (nopen - clos);
if (tlen < blen || (tlen == blen && c[i] < c[bc])) {
blen = tlen;
bc = i;
}
}
}
string ts = "";
for (int i = bc; i < st.size(); i++) ts += st[i];
for (int i = 0; i < bc; i++) ts += st[i];
long mb = 0;
long qb = 0;
for (int i = 0; i < ts.size(); i++) {
if (ts[i] == '(')
qb++;
else
qb--;
if (qb < mb) mb = qb;
}
reverse(ts.begin(), ts.end());
if (mb < 0) {
mb *= -1;
for (int i = 0; i < mb; i++) ts += '(';
}
reverse(ts.begin(), ts.end());
qb = 0;
for (int i = 0; i < ts.size(); i++) {
if (ts[i] == '(')
++qb;
else
--qb;
}
for (int i = 0; i < qb; i++) ts += ')';
cout << ts << endl;
cin.get();
cin.get();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000000 + 10;
char s[N];
int n, pre[N];
const int INF = 1e9 + 7;
int mx[N << 2], mn[N << 2];
vector<int> vec;
void build(int l, int r, int rt) {
if (l == r) {
mn[rt] = mx[rt] = pre[l];
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
mn[rt] = min(mn[rt << 1], mn[rt << 1 | 1]);
}
int querymin(int l, int r, int rt, int L, int R) {
if (L <= l && r <= R) return mn[rt];
int mid = (l + r) >> 1, ans = N;
if (L <= mid) ans = min(ans, querymin(l, mid, rt << 1, L, R));
if (R > mid) ans = min(ans, querymin(mid + 1, r, rt << 1 | 1, L, R));
return ans;
}
int querymax(int l, int r, int rt, int L, int R) {
if (L <= l && r <= R) return mx[rt];
int mid = (l + r) >> 1, ans = -N;
if (L <= mid) ans = max(ans, querymax(l, mid, rt << 1, L, R));
if (R > mid) ans = max(ans, querymax(mid + 1, r, rt << 1 | 1, L, R));
return ans;
}
char str[N];
int height[N], rk[N], sa[N], cc[N], t1[N], t2[N];
bool cmp(int *y, int a, int b, int k) {
int a1 = y[a], a2 = a + k >= n ? -1 : y[a + k];
int b1 = y[b], b2 = b + k >= n ? -1 : y[b + k];
return a1 == b1 && a2 == b2;
}
void buildSA(int m) {
int *x = t1, *y = t2;
for (int i = 0; i < m; i++) cc[i] = 0;
for (int i = 0; i < n; i++) cc[x[i] = str[i]]++;
for (int i = 1; i < m; i++) cc[i] += cc[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cc[x[i]]] = i;
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (int i = n - k; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (int i = 0; i < m; i++) cc[i] = 0;
for (int i = 0; i < n; i++) cc[x[y[i]]]++;
for (int i = 1; i < m; i++) cc[i] += cc[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cc[x[y[i]]]] = y[i];
swap(x, y);
m = 1, x[sa[0]] = 0;
for (int i = 1; i < n; i++) {
x[sa[i]] = cmp(y, sa[i - 1], sa[i], k) ? m - 1 : m++;
}
if (m >= n) break;
}
}
void buildH() {
for (int i = 0; i < n; i++) rk[sa[i]] = i;
int k = 0;
height[0] = 0;
for (int i = 0; i < n; i++) {
if (!rk[i]) continue;
if (k) k--;
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) k++;
height[rk[i]] = k;
}
}
void init() {
for (int i = 1; i <= n * 2; i++) str[i - 1] = s[i];
n = n * 2;
buildSA(1000);
buildH();
n = n / 2;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) s[i + n] = s[i];
for (int i = 1; i <= 2 * n; i++) pre[i] = pre[i - 1] + (s[i] == '(' ? 1 : -1);
build(1, 2 * n, 1);
init();
int need = pre[n];
pair<int, int> bst = make_pair(INF, 0);
for (int i = 1; i <= n; i++) {
int cnt = 0, cntLef = 0;
int m2 = querymin(1, n << 1, 1, i, i + n - 1);
if (need <= 0) {
cnt = -need +
max(max(-(m2 - pre[i - 1] - need), pre[i + n - 1] - m2), 0) * 2;
cntLef =
-need + max(max(-(m2 - pre[i - 1] - need), pre[i + n - 1] - m2), 0);
} else {
cnt = +need +
max(max(-(m2 - pre[i - 1]), pre[i + n - 1] - m2 - need), 0) * 2;
cntLef = max(max(-(m2 - pre[i - 1]), pre[i + n - 1] - m2 - need), 0);
}
if (make_pair(cnt, cntLef) < bst) {
bst = make_pair(cnt, cntLef);
vec.clear();
}
if (make_pair(cnt, cntLef) == bst) {
vec.push_back(i);
}
}
int mn = N;
int st = 0;
for (auto x : vec)
if (rk[x - 1] < mn) {
mn = rk[x - 1];
st = x;
}
for (int i = 1; i <= bst.second; i++) printf("(");
for (int i = st; i < st + n; i++) printf("%c", s[i]);
for (int i = 1; i <= bst.first - bst.second; i++) printf(")");
printf("\n");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
struct SegmTree {
vector<int> t;
int sz;
SegmTree(const vector<int>& a) {
sz = 1;
while (sz < (int)a.size()) sz *= 2;
t.assign(sz * 2, INF);
for (int v = sz; v < sz + (int)a.size(); ++v) {
t[v] = a[v - sz];
}
for (int v = sz - 1; v > 0; --v) {
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
}
int get_min(int l, int r) {
int res = INF;
l += sz;
r += sz;
while (l <= r) {
res = min(res, t[l]);
res = min(res, t[r]);
l = (l + 1) / 2;
r = (r - 1) / 2;
}
return res;
}
};
const double EPS = 1e-9;
const int PP = 7;
const int MAXN = 1 << 21;
const int MOD[2] = {(int)1e9 + 7, (int)1e9 + 17};
void add(int& x, int y, int mod) { ((x += y) >= mod) && (x -= mod); }
int mul(int& x, int y, int mod) { return x * 1ll * y % mod; }
struct Hash {
static const int SZ = 2;
int v[SZ];
Hash(int x = 0) {
for (int i = 0; i < (int)SZ; ++i) v[i] = x;
}
void operator+=(const Hash& h) {
for (int i = 0; i < (int)SZ; ++i) {
add(v[i], h.v[i], MOD[i]);
}
}
void operator-=(const Hash& h) {
for (int i = 0; i < (int)SZ; ++i) {
add(v[i], -h.v[i] + MOD[i], MOD[i]);
}
}
void operator*=(const Hash& h) {
for (int i = 0; i < (int)SZ; ++i) {
v[i] = mul(v[i], h.v[i], MOD[i]);
}
}
void operator*=(const int& h) {
for (int i = 0; i < (int)SZ; ++i) {
v[i] = mul(v[i], h, MOD[i]);
}
}
void print() const { fprintf(stderr, "%d %d\n", v[0], v[1]); }
};
Hash operator*(const Hash& h1, const Hash& h2) {
Hash h = h1;
h *= h2;
return h;
}
Hash operator*(const Hash& h1, const int& h2) {
Hash h = h1;
h *= h2;
return h;
}
Hash operator+(const Hash& h1, const Hash& h2) {
Hash h = h1;
h += h2;
return h;
}
Hash operator-(const Hash& h1, const Hash& h2) {
Hash h = h1;
h -= h2;
return h;
}
bool operator==(const Hash& h1, const Hash& h2) {
return h1.v[0] == h2.v[0] && h1.v[1] == h2.v[1];
}
bool operator!=(const Hash& h1, const Hash& h2) {
return !(h1.v[0] == h2.v[0] && h1.v[1] == h2.v[1]);
}
bool operator<(const Hash& h1, const Hash& h2) {
return h1.v[0] < h2.v[0] || (h1.v[0] == h2.v[0] && h1.v[1] < h2.v[1]);
}
Hash P[MAXN];
struct Solver {
vector<Hash> pref;
vector<Hash> P;
string s;
Solver(const string& s) : s(s) {
P.resize(MAXN);
P[0] = Hash(1);
for (int i = 1; i < MAXN; ++i) {
P[i] = PP * P[i - 1];
}
pref.assign(((int)(s).size()) + 1, 0);
for (int i = 0; i < (int)((int)(s).size()); ++i) {
int c = (s[i] == ')') + 1;
Hash cur = P[i] * c;
pref[i + 1] = pref[i] + cur;
}
}
Hash hash(int l, int r) {
Hash res = pref[r + 1] - pref[l];
res *= P[MAXN - r - 1];
return res;
}
};
int nn;
Solver text_hashes("dfdgggd");
string text;
bool weird_cmp(int l, int r) {
int maxlen = nn - max(l, r);
int left = 0;
int right = maxlen + 1;
while (right - left > 1) {
int mid = (right + left) / 2;
if (text_hashes.hash(l, mid + l - 1) == text_hashes.hash(r, mid + r - 1))
left = mid;
else
right = mid;
}
return text[l + left] < text[r + left];
}
void solve(string s) {
int n = (int)s.size();
nn = 2 * n;
text = s + s + char(0) + char(0) + char(0);
vector<int> pref(2 * n + 1, 0);
for (int i = 1; i <= 2 * n; i++)
pref[i] = pref[i - 1] + (text[i - 1] == '(' ? 1 : -1);
SegmTree Min(pref);
vector<int> minbal(n);
for (int i = 0; i < n; i++) {
int l = i + 1;
int r = i + n;
int cnt = Min.get_min(l, r) - pref[i];
if (cnt > 0) cnt = 0;
minbal[i] = cnt;
}
vector<int> cands;
int allbest = *max_element(minbal.begin(), minbal.end());
assert(allbest <= 0);
for (int i = 0; i < n; i++)
if (minbal[i] == allbest) cands.push_back(i);
text_hashes = Solver(text);
int pos = *min_element(cands.begin(), cands.end(), weird_cmp);
string ans = string(-allbest, '(');
ans += text.substr(pos, n);
int cntbal = 0;
for (int i = 0; i < (int)ans.size(); i++) {
if (ans[i] == '(')
cntbal++;
else if (ans[i] == ')')
cntbal--;
else
assert(0);
assert(cntbal >= 0);
}
ans += string(cntbal, ')');
cout << ans << endl;
}
int main() {
string s;
while (cin >> s) solve(s);
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T Abs(const T& x) {
return x < 0 ? -x : x;
}
template <class T>
inline T Sqr(const T& x) {
return x * x;
}
namespace NSuffixArray {
void ZipValues(vector<int>& input) {
vector<pair<int, int> > tmp;
for (size_t i = 0; i < input.size(); ++i) {
tmp.push_back(make_pair(input[i], i));
}
sort(tmp.begin(), tmp.end());
int classes = 0;
for (size_t i = 0; i < tmp.size(); ++i) {
if (i == 0 || tmp[i].first != tmp[i - 1].first) {
++classes;
}
input[tmp[i].second] = classes - 1;
}
}
void CalcAndAggCnt(const vector<int>& cl, vector<int>& cnt) {
cnt.assign(cl.size(), 0);
for (size_t i = 0; i < cl.size(); ++i) {
++cnt[cl[i]];
}
for (size_t i = 0; i < cnt.size(); ++i) {
cnt[i] += i > 0 ? cnt[i - 1] : 0;
}
}
inline int SoftMod(int a, int n) {
return a < 0 ? n + a : (a >= n ? a - n : a);
}
vector<int> SortedShifts(vector<int> input) {
ZipValues(input);
int n = input.size(), classes = 0;
vector<int> sa(n, 0), nsa(n, 0), cnt(n, 0);
vector<int> cl = input, oldcl(n, 0);
CalcAndAggCnt(cl, cnt);
for (int i = 0; i < n; ++i) {
sa[--cnt[cl[i]]] = i;
}
for (int h = 1; h < n; h <<= 1) {
CalcAndAggCnt(cl, cnt);
for (int i = 0; i < n; ++i) {
nsa[i] = SoftMod(sa[i] - h, n);
}
for (int i = n - 1; i >= 0; --i) {
sa[--cnt[cl[nsa[i]]]] = nsa[i];
}
classes = 0;
oldcl.swap(cl);
for (int i = 0; i < n; ++i) {
if (classes == 0 || oldcl[sa[i]] > oldcl[sa[i - 1]] ||
oldcl[SoftMod(sa[i] + h, n)] > oldcl[SoftMod(sa[i - 1] + h, n)]) {
++classes;
}
cl[sa[i]] = classes - 1;
}
}
return sa;
}
vector<int> SortedShifts(const string& input) {
vector<int> arrayInput(input.begin(), input.end());
return SortedShifts(arrayInput);
}
vector<int> SortedArray(vector<int> array) {
int mn = array[0];
for (size_t i = 1; i < array.size(); ++i) {
if (array[i] < mn) {
mn = array[i];
}
}
--mn;
array.push_back(mn);
auto sorted = SortedShifts(array);
for (size_t i = 0; i < sorted.size(); ++i) {
if (array[sorted[i]] == mn) {
sorted.erase(sorted.begin() + i);
break;
}
}
return sorted;
}
vector<int> SortedArray(const string& s) {
vector<int> arrayInput(s.begin(), s.end());
return SortedArray(arrayInput);
}
} // namespace NSuffixArray
struct TParInfo {
int AddLeft;
int AddRight;
int SortedPos;
int Shift;
};
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
vector<int> sortedShifts = NSuffixArray::SortedShifts(s);
vector<int> shiftPos(s.length());
for (size_t i = 0; i < sortedShifts.size(); ++i) {
shiftPos[sortedShifts[i]] = i;
}
vector<int> balance(s.length() + 1, 0);
for (size_t i = 1; i <= s.length(); ++i) {
balance[i] += balance[i - 1] + (s[i - 1] == '(' ? +1 : -1);
}
vector<int> leftMin(s.length() + 1, 0);
vector<int> rightMin(s.length() + 1, 0);
for (size_t i = 1; i <= s.length(); ++i) {
leftMin[i] = min(balance[i], leftMin[i - 1]);
}
rightMin[s.length()] = balance[s.length()];
for (int i = static_cast<int>(s.length()) - 1; i >= 0; --i) {
rightMin[i] = min(balance[i], rightMin[i + 1]);
}
TParInfo bestInfo;
bestInfo.AddLeft = s.length() * 4;
bestInfo.AddRight = s.length() * 4;
vector<TParInfo> parInfo(s.length());
for (size_t i = 0; i < s.length(); ++i) {
TParInfo& info = parInfo[i];
info.AddLeft = info.AddRight = 0;
info.SortedPos = shiftPos[i];
info.Shift = i;
int rMin = rightMin[i] - balance[i];
int lMin = leftMin[i] + (balance[s.length()] - balance[i]);
int totalMin = min(lMin, rMin);
if (totalMin < 0) {
info.AddLeft = -totalMin;
}
if (info.AddLeft + balance[s.length()] > 0) {
info.AddRight = info.AddLeft + balance[s.length()];
}
if (info.AddLeft + info.AddRight < bestInfo.AddLeft + bestInfo.AddRight) {
bestInfo = info;
}
}
for (size_t i = 0; i < s.length(); ++i) {
TParInfo& info = parInfo[i];
if (bestInfo.AddLeft + bestInfo.AddRight == info.AddLeft + info.AddRight) {
if (bestInfo.SortedPos > info.SortedPos) {
bestInfo = info;
}
}
}
for (int i = 0; i < bestInfo.AddLeft; ++i) {
cout << '(';
}
rotate(s.begin(), s.begin() + bestInfo.Shift, s.end());
cout << s;
for (int i = 0; i < bestInfo.AddRight; ++i) {
cout << ')';
}
cout << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int sz = 1 << 15;
char inbuf[sz], outbuf[sz];
char *pinbuf = inbuf + sz;
char *poutbuf = outbuf;
inline char _getchar() {
if (pinbuf == inbuf + sz) fread(inbuf, 1, sz, stdin), pinbuf = inbuf;
return *(pinbuf++);
}
inline void _putchar(char x) {
if (poutbuf == outbuf + sz) fwrite(outbuf, 1, sz, stdout), poutbuf = outbuf;
*(poutbuf++) = x;
}
inline void flush() {
if (poutbuf != outbuf)
fwrite(outbuf, 1, poutbuf - outbuf, stdout), poutbuf = outbuf;
}
} // namespace IO
inline int read() {
int x = 0, p = 1;
char c = IO::_getchar();
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = IO::_getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = IO::_getchar();
return x * p;
}
const int Maxn = 1e6 + 5;
char c[Maxn];
int n;
struct br {
int v, m;
br() { v = m = 0; }
br(int _v, int _m) { v = _v, m = _m; }
br(char __) {
int _x = (__ == '(') ? 1 : -1;
v = _x, m = min(0, _x);
}
br operator+(br x) { return br(v + x.v, min(m, v + x.m)); }
};
const long long mod1 = 998244353;
const long long mod2 = 1e9 + 9;
int H1[Maxn][22], H2[Maxn][22];
br pre[Maxn], suf[Maxn];
long long pw1[25], pw2[25];
bool cmp(int x, int y) {
int lim = 1;
while ((1 << lim) <= n) lim++;
for (int i = lim - 1; i >= 0; i--) {
if (H1[x][i] == H1[y][i] && H2[x][i] == H2[y][i]) {
x += 1 << i;
y += 1 << i;
if (x > n) x -= n;
if (y > n) y -= n;
}
}
return c[x] < c[y];
}
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (int i = 1; i <= n; i++) H1[i][0] = H2[i][0] = c[i];
pw1[0] = 3948243;
for (int i = 1; i < 25; i++) pw1[i] = pw1[i - 1] * pw1[i - 1] % mod1;
pw2[0] = 3948243;
for (int i = 1; i < 25; i++) pw2[i] = pw2[i - 1] * pw2[i - 1] % mod2;
for (int i = 1, j = 2; j <= n; i++, j <<= 1) {
for (int k = 1; k <= n; k++) {
int nk = k + (j >> 1);
if (nk > n) nk -= n;
H1[k][i] = (1ll * H1[k][i - 1] * pw1[i - 1] + H1[nk][i - 1]) % mod1;
H2[k][i] = (1ll * H2[k][i - 1] * pw2[i - 1] + H2[nk][i - 1]) % mod2;
}
}
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + br(c[i]);
}
for (int i = n; i >= 1; i--) {
suf[i] = br(c[i]) + suf[i + 1];
}
int tot = min(pre[n].v, 0);
int ans = -1;
for (int i = 1; i <= n; i++) {
br tmp = suf[i] + pre[i - 1];
if (tmp.m == tot) {
if (ans == -1)
ans = i;
else {
if (cmp(i, ans)) ans = i;
}
}
}
tot = pre[n].v;
string res;
for (int i = ans; i <= n; i++) res += c[i];
for (int i = 1; i < ans; i++) res += c[i];
if (tot > 0) {
for (int i = 0; i < tot; i++) res += ')';
} else {
string tmp;
for (int i = 0; i < (-tot); i++) tmp += '(';
res = tmp + res;
}
printf("%s\n", res.c_str());
return ~~(0 ^ 0 ^ 0);
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:666777216")
using namespace std;
const int N = 1000007;
char st[N];
int n, sum[N], openCnt[N];
struct segTree {
int T[4 * N];
void build(int v, int tl, int tr, int *sum) {
if (tl == tr) {
T[v] = sum[tl];
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm, sum);
build(2 * v + 1, tm + 1, tr, sum);
T[v] = min(T[2 * v], T[2 * v + 1]);
}
void update(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
T[v] = val;
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm)
update(2 * v, tl, tm, pos, val);
else
update(2 * v + 1, tm + 1, tr, pos, val);
T[v] = min(T[2 * v], T[2 * v + 1]);
}
int get(int v, int tl, int tr, int l, int r) {
if (r < l) return N;
if (tl == l && tr == r) return T[v];
int tm = (tl + tr) / 2;
if (r <= tm) return get(2 * v, tl, tm, l, r);
if (l > tm) return get(2 * v + 1, tm + 1, tr, l, r);
return min(get(2 * v, tl, tm, l, tm),
get(2 * v + 1, tm + 1, tr, tm + 1, r));
}
} tree;
inline int get(int l, int r, int *sum) {
if (l > r) return 0;
if (l == 0) return sum[r];
return sum[r] - sum[l - 1];
}
int open[N], close[N];
inline int code(char c) { return c == '(' ? 0 : 1; }
struct SA {
int pos[N], tpos[N], cnt[N], rev[N];
int C[21][N];
void build() {
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < (n); ++i) ++cnt[code(st[i])];
for (int i = 0; i < (n); ++i) {
if (i) cnt[i] += cnt[i - 1];
}
for (int i = n - 1; i >= 0; --i) {
pos[i] = --cnt[code(st[i])];
}
for (int i = 0; i < (n); ++i) {
C[0][i] = code(st[i]);
}
for (int h = 1, lev = 0; h < n; h <<= 1, ++lev) {
for (int i = 0; i < (n); ++i) {
tpos[i] = pos[(i + h) % n];
}
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < (n); ++i) ++cnt[C[lev][i]];
for (int i = 0; i < (n); ++i) {
if (i) cnt[i] += cnt[i - 1];
}
for (int i = 0; i < (n); ++i) {
rev[tpos[i]] = i;
}
for (int i = n - 1; i >= 0; --i) {
int ind = rev[i];
pos[ind] = --cnt[C[lev][ind]];
}
for (int i = 0; i < (n); ++i) {
rev[pos[i]] = i;
}
C[lev + 1][rev[0]] = 0;
for (int i = 1, cur = 0; i < n; ++i) {
if (C[lev][rev[i - 1]] != C[lev][rev[i]] ||
C[lev][(rev[i - 1] + h) % n] != C[lev][(rev[i] + h) % n])
++cur;
C[lev + 1][rev[i]] = cur;
}
}
}
} sa;
bool checkOpen(int i, int j) {
if (i < j) return get(i, j, openCnt) == j - i + 1;
return get(i, n - 1, openCnt) + get(0, j, openCnt) ==
n - 1 - i + 1 + j - 0 + 1;
}
int cmp(int i, int j, int len) {
for (int h = 19; h >= 0; --h) {
if ((1 << h) > len) continue;
if (sa.C[h][i] < sa.C[h][j]) return -1;
if (sa.C[h][i] > sa.C[h][j]) return 1;
i = (i + (1 << h)) % n;
j = (j + (1 << h)) % n;
}
return 0;
}
bool compare(int i, int j) {
int op1 = open[i] - min(open[i], open[j]);
int op2 = open[j] - min(open[i], open[j]);
int cl1 = close[i];
int cl2 = close[j];
if (op1 != 0) {
if (!checkOpen(j, (j + op1) % n)) return true;
j = (j + op1) % n;
}
if (op2 != 0) {
if (!checkOpen(i, (i + op2) % n)) return false;
i = (i + op2) % n;
}
int res = cmp(i, j, n - max(op1, op2));
if (res == -1) return true;
if (res == 1) return false;
return cl1 <= cl2;
}
void solve() {
scanf("%s", st);
n = strlen(st);
for (int i = 0; i < (n); ++i) {
int psum = (i ? sum[i - 1] : 0);
if (st[i] == '(')
sum[i] = psum + 1;
else
sum[i] = psum - 1;
int popen = (i ? openCnt[i - 1] : 0);
if (st[i] == '(')
openCnt[i] = popen + 1;
else
openCnt[i] = popen;
}
tree.build(1, 0, n - 1, sum);
int totalBal = sum[n - 1];
for (int i = 0; i < (n); ++i) {
int min1 = tree.get(1, 0, n - 1, i, n - 1) - get(0, i - 1, sum);
int min2 = tree.get(1, 0, n - 1, 0, i - 1) + get(i, n - 1, sum);
int mini = min(min1, min2);
if (mini >= 0) {
close[i] = totalBal;
} else {
open[i] = -mini;
if (totalBal + open[i] < 0)
open[i] += -(totalBal + open[i]);
else
close[i] = totalBal + open[i];
}
}
int minAdd = N + N;
for (int i = 0; i < (n); ++i) {
minAdd = min(minAdd, open[i] + close[i]);
}
sa.build();
int best = -1;
for (int i = 0; i < (n); ++i) {
if (open[i] + close[i] != minAdd) continue;
if (best == -1 || compare(i, best)) {
best = i;
}
}
for (int i = 0; i < (open[best]); ++i) putchar('(');
for (int i = best; i < n; ++i) {
putchar(st[i]);
}
for (int i = 0; i < best; ++i) {
putchar(st[i]);
}
for (int i = 0; i < (close[best]); ++i) putchar(')');
}
int rd() { return (((long long)rand() << 16) ^ rand()) % 1000000000; }
void testGen() {
FILE *f = fopen("input.txt", "w");
fclose(f);
}
int main() {
cerr << fixed;
cerr.precision(5);
solve();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int N = s.length();
int d = 0;
for (int i = 0; i < N; i++) {
if (s[i] == '(')
d++;
else
d--;
}
set<pair<int, int> > S1;
vector<int> Sv(N);
int sA = 0;
for (int i = 0; i < N; i++) {
if (s[i] == '(')
sA++;
else
sA--;
Sv[i] = sA;
S1.insert(make_pair(sA, i));
}
vector<int> Ppos(1, 0);
int ans = max(((d < 0) ? -(d) : d), -S1.begin()->first);
sA = 0;
if (d >= 0) ans = d + max(0, -S1.begin()->first);
for (int i = 0; i < N - 1; i++) {
S1.erase(make_pair(Sv[i], i));
sA = min(sA, Sv[i]);
int c;
if (d >= 0)
c = d + max(0, max(-S1.begin()->first + Sv[i], -sA - Sv[N - 1] + Sv[i]));
else
c = max(0, max(-S1.begin()->first + Sv[i], -sA - Sv[N - 1] + Sv[i]));
if (ans > c) {
ans = c;
Ppos.clear();
}
if (ans == c) Ppos.push_back(i + 1);
}
N *= 2;
vector<vector<int> > V1(256);
V1[0].push_back(N);
for (int i = 0; i < N; i++) V1[s[i % (N / 2)]].push_back(i);
int K = 5;
while (1 << (K - 1) < N) K++;
vector<int> isB(N + 1 + (1 << (K - 1)), 0);
vector<int> SA(N + 1, N);
vector<int> Bs(N + 2, N + 1);
Bs[0] = 0;
int Btot = -1, q = 0;
for (int j = 0; j < 256; j++) {
if (!V1[j].empty()) Bs[++Btot] = q;
for (unsigned int i = 0; i < V1[j].size(); i++) {
SA[q] = V1[j][i];
isB[V1[j][i]] = Btot;
q++;
}
}
vector<pair<int, int> > tmp(N + 1);
vector<int> Bs1(N + 1, 0);
vector<int> nxtB(N + 1, 0), pos(N + 1, 0);
for (int i = 1; i < K; i++) {
int q = 1 << (i - 1);
for (int j = 0; j <= Btot; j++) Bs1[j] = 0;
for (int j = 0; j <= N; j++) nxtB[j] = isB[SA[j] + q];
for (int j = 0; j <= Btot; j++)
if (Bs[j + 1] - Bs[j] > 1)
for (int k = Bs[j]; k < Bs[j + 1]; k++) Bs1[nxtB[k]]++;
int s = 0;
for (int j = 0; j <= Btot; j++) {
int s2 = Bs1[j] + s;
Bs1[j] = s;
s = s2;
}
for (int j = 0; j <= Btot; j++)
if (Bs[j + 1] - Bs[j] > 1)
for (int k = Bs[j]; k < Bs[j + 1]; k++) pos[k] = Bs1[nxtB[k]]++;
for (int j = 0; j <= Btot; j++)
if (Bs[j + 1] - Bs[j] > 1)
for (int k = Bs[j]; k < Bs[j + 1]; k++) {
tmp[pos[k]].first = SA[k];
tmp[pos[k]].second = j;
}
for (int j = 0; j < s; j++) pos[j] = Bs[tmp[j].second]++;
for (int j = 0; j < s; j++) SA[pos[j]] = tmp[j].first;
for (int j = 0; j <= N; j++) nxtB[j] = isB[SA[j] + q];
Btot = 0;
Bs[0] = 0;
for (int j = 1; j <= N; j++) {
if (isB[SA[j]] != isB[SA[j - 1]] || nxtB[j] != nxtB[j - 1])
pos[j] = ++Btot;
else
pos[j] = pos[j - 1];
}
int p = 0;
for (int j = 1; j <= N; j++) {
if (p + 1 == pos[j]) Bs[++p] = j;
isB[SA[j]] = p;
}
}
vector<int> invP(N + 1);
for (int i = 0; i <= N; i++) invP[SA[i]] = i;
int optR = Ppos[0], optP = invP[Ppos[0]];
for (unsigned int i = 0; i < Ppos.size(); i++)
if (optP > invP[Ppos[i]]) {
optR = Ppos[i];
optP = invP[Ppos[i]];
}
string s2;
for (int i = 0; i < -d; i++) s2 += "(";
for (int i = optR; i < N / 2; i++) s2 += s[i];
for (int i = 0; i < optR; i++) s2 += s[i];
for (int i = 0; i < d; i++) s2 += ")";
cout << s2 << "\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
const int M = 5e6 + 3;
const int oo = 1e9;
const int OS = 317;
const int MOD = 1e9 + 7;
char s[N];
int n, stp[M], p1[N], p2[N], s1[N], s2[N], ho[N], hz[N], h[N];
vector<int> st;
int get(int i, int ln) {
int op, zp, zs, os, il, ir, ans, l1, l, r, ym;
op = p2[i];
zp = i - p1[i] - op;
zs = s2[i + 1];
os = n - i - s1[i + 1] - zs;
il = zs;
ir = op;
if (os > zp)
ir += os - zp;
else
il += zp - os;
l1 = min(il, ln);
ym = 2 * n;
ans = (stp[ym] * 1LL * ho[l1]) % MOD;
if (ln - l1 > 0) {
l = i + 1;
r = l + min(n - i, ln - l1) - 1;
ans = (ans + (((h[r] - h[l - 1]) % MOD + MOD) % MOD) * 1LL *
stp[ym + l1 - (l - 1)] % MOD) %
MOD;
l1 += r - l + 1;
if (ln - l1 > 0) {
r = min(i, ln - l1);
ans = (ans + h[r] * 1LL * stp[ym + l1] % MOD) % MOD;
l1 += r;
if (ln - l1 > 0) {
r = ln - l1;
ans = (ans + hz[r] * 1LL * stp[ym + l1] % MOD) % MOD;
}
}
}
return ans;
}
int get_ch(int i, int ln) {
int op, zp, zs, os, il, ir;
op = p2[i];
zp = i - p1[i] - op;
zs = s2[i + 1];
os = n - i - s1[i + 1] - zs;
il = zs;
ir = op;
if (os > zp)
ir += os - zp;
else
il += zp - os;
if (ln <= il) return '(';
ln -= il;
if (ln <= n - i) return s[i + ln];
ln -= n - i;
if (ln <= i)
return s[ln];
else
return ')';
}
int ans;
bool cmp(int i, int j) {
int l, r, x;
l = 1, r = ans;
while (l <= r) {
x = (l + r) >> 1;
if (get(i, x) == get(j, x))
l = x + 1;
else
r = x - 1;
}
if (r + 1 > ans) return true;
return get_ch(i, r + 1) <= get_ch(j, r + 1);
}
void make(char *s) {
int i, n;
srand(time(NULL));
n = 100;
for (i = 0; i <= n; ++i)
if (rand() % 2 == 0)
s[i] = '(';
else
s[i] = ')';
s[n + 1] = 0;
}
char ss[1000][1000];
bool cmp1(int i, int j) {
int li, lj, u, l;
li = strlen(ss[i]);
lj = strlen(ss[j]);
l = min(li, lj);
if (li < lj)
return true;
else if (li > lj)
return false;
for (u = 0; u < l; ++u)
if (ss[i][u] < ss[j][u])
return true;
else if (ss[i][u] > ss[j][u])
return false;
if (li == u)
return true;
else
return false;
}
char bd[2 * N], na[2 * N];
void solve(char *s) {
int i, j, n, op, zp, zs, os, il, ir, m, mn;
n = strlen(s + 1);
for (i = 0; i < n; ++i) {
op = p2[i];
zp = i - p1[i] - op;
zs = s2[i + 1];
os = n - i - s1[i + 1] - zs;
il = zs;
ir = op;
if (os > zp)
ir += os - zp;
else
il += zp - os;
m = 0;
for (j = 0; j < il; ++j) ss[i][m++] = '(';
for (j = i + 1; j <= n; ++j) ss[i][m++] = s[j];
for (j = 1; j <= i; ++j) ss[i][m++] = s[j];
for (j = 0; j < ir; ++j) ss[i][m++] = ')';
ss[i][m] = 0;
}
mn = 0;
for (i = 0; i < n; ++i)
if (cmp1(i, mn)) mn = i;
m = strlen(ss[mn]);
for (i = 0; i < m; ++i) bd[i] = ss[mn][i];
bd[m] = 0;
}
char san[N];
int main() {
int i, j, op, zp, zs, os, len, mn;
while (1) {
gets(s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; ++i)
if (s[i] == '(')
p1[i] = p1[i - 1], p2[i] = p2[i - 1] + 1;
else if (p2[i - 1])
p1[i] = p1[i - 1] + 2, p2[i] = p2[i - 1] - 1;
else
p1[i] = p1[i - 1], p2[i] = p2[i - 1];
for (i = n; i; --i)
if (s[i] == ')')
s1[i] = s1[i + 1], s2[i] = s2[i + 1] + 1;
else if (s2[i + 1])
s1[i] = s1[i + 1] + 2, s2[i] = s2[i + 1] - 1;
else
s1[i] = s1[i + 1], s2[i] = s2[i + 1];
ans = oo;
for (i = 0; i < n; ++i) {
op = p2[i];
zp = i - p1[i] - op;
zs = s2[i + 1];
os = n - i - s1[i + 1] - zs;
len = n + zs + op + max(os, zp) - min(os, zp);
if (ans > len) st.clear();
if (ans >= len) ans = len, st.push_back(i);
}
stp[0] = 1;
for (i = 1; i < M; ++i) stp[i] = (stp[i - 1] * 1LL * OS) % MOD;
ho[0] = hz[0] = 0;
for (i = 1; i < N; ++i)
ho[i] = (ho[i - 1] + '(' * 1LL * stp[i - 1] % MOD) % MOD;
for (i = 1; i < N; ++i)
hz[i] = (hz[i - 1] + ')' * 1LL * stp[i - 1] % MOD) % MOD;
h[0] = 0;
for (i = 1; i <= n; ++i)
h[i] = (h[i - 1] + s[i] * 1LL * stp[i - 1] % MOD) % MOD;
mn = st[0];
for (i = 1; i < (int)st.size(); ++i) {
if (cmp(st[i], mn)) mn = st[i];
}
i = mn;
int il, ir;
op = p2[i];
zp = i - p1[i] - op;
zs = s2[i + 1];
os = n - i - s1[i + 1] - zs;
il = zs;
ir = op;
if (os > zp)
ir += os - zp;
else
il += zp - os;
int m = 0;
for (j = 0; j < il; ++j) na[m++] = '(';
for (j = i + 1; j <= n; ++j) na[m++] = s[j];
for (j = 1; j <= i; ++j) na[m++] = s[j];
for (j = 0; j < ir; ++j) na[m++] = ')';
na[m++] = 0;
printf("%s\n", na);
return 0;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2111111;
char buf[maxn];
int sum[maxn];
bool ok[maxn];
int order[maxn];
template <typename T>
void debug(T a[], int n) {
for (int i = 1; i <= n; ++i) {
cout << setw(3) << a[i];
}
puts("");
}
void fix(int& i, int n) {
while (!ok[i] && i <= n) {
++i;
}
}
int run(char s[], int m) {
int n = m >> 1;
int i = 1, j = 2, k = 0;
fix(i, n);
j = i + 1;
fix(j, n);
while (j <= n) {
for (k = 0; k < n; ++k) {
if (s[i + k] ^ s[j + k]) {
break;
}
}
if (s[i + k] > s[j + k]) {
i += k + 1;
fix(i, n);
} else {
j += k + 1;
fix(j, n);
}
if (j == i) {
++j;
fix(j, n);
}
}
return std::min(i, j);
}
int main() {
for (int i = 1; i < 100; ++i) {
order[i] = i;
}
scanf("%s", buf + 1);
int n = std::strlen(buf + 1);
int A, B;
A = B = 0;
for (int i = 1; i <= n; ++i) {
buf[i + n] = buf[i];
if (buf[i] == '(') {
++A;
} else {
++B;
}
}
int m = n << 1;
for (int i = 1; i <= m; ++i) {
if (buf[i] == '(') {
sum[i] = 1;
} else {
sum[i] = -1;
}
sum[i] += sum[i - 1];
}
static int q[maxn];
int front, rear;
front = rear = 0;
static int min[maxn];
int add = 0;
if (A < B) {
add = B - A;
}
for (int i = 1; i <= m; ++i) {
if (front < rear && q[front] + n <= i) {
++front;
}
while (front < rear && sum[q[rear - 1]] >= sum[i]) {
--rear;
}
q[rear++] = i;
min[i] = sum[q[front]];
}
for (int i = 1; i <= n; ++i) {
if (add + min[i + n - 1] >= sum[i - 1]) {
ok[i] = true;
}
}
int index = run(buf, m);
auto print = [](char ch, int n) {
while (n--) {
putchar(ch);
}
};
if (A < B) {
print('(', B - A);
}
for (int i = index; i < index + n; ++i) {
putchar(buf[i]);
}
if (B < A) {
print(')', A - B);
}
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char p[2010000], Ans[2010000 * 2];
int n, D[1010000], D2[1010000], C[2010000], ord[2010000], ord2[2010000],
SA[2010000], MM, P[1010000], Pcnt;
int X[2010000], Y[2010000];
void Suffix_Array(int m) {
int i, L = 2, M, cnt, cc, t;
for (i = 1; i <= m; i++) {
X[i] = p[i - 1], Y[i] = p[i];
}
while (1) {
M = max(m, 256);
for (i = 1; i <= m; i++) C[Y[i]]++;
for (i = 1; i <= M; i++) C[i] += C[i - 1];
for (i = 1; i <= m; i++) ord[C[Y[i]]--] = i;
for (i = 0; i <= M; i++) C[i] = 0;
for (i = 1; i <= m; i++) C[X[i]]++;
for (i = 1; i <= M; i++) C[i] += C[i - 1];
for (i = m; i >= 1; i--) ord2[C[X[ord[i]]]--] = ord[i];
for (i = 0; i <= M; i++) C[i] = 0;
cnt = 0;
for (i = 1; i <= m; i++) {
if (i == 1 || X[ord2[i]] != X[ord2[i - 1]] ||
Y[ord2[i]] != Y[ord2[i - 1]])
cnt++;
SA[ord2[i]] = cnt;
}
t = cnt + 1, cc = 0;
for (i = 0; i < Pcnt; i++) {
if (t > SA[P[i] + 1])
t = SA[P[i] + 1], cc = 1;
else if (t == SA[P[i] + 1])
cc++;
}
if (cc == 1) break;
if (L >= m) break;
for (i = 1; i <= m; i++) {
X[i] = SA[i];
if (i + L > m)
Y[i] = 0;
else
Y[i] = SA[i + L];
}
L *= 2;
}
}
int main() {
int i, t = 0, SS = 0, MM2, pv, cc = 0;
gets(p);
for (i = 0; p[i]; i++)
;
n = i;
for (i = n - 1; i >= 0; i--) {
if (p[i] == '(')
t++, SS++;
else
t--, SS--;
if (t > 0) t = 0;
D[i] = t;
}
t = 0;
for (i = 0; i < n; i++) {
D2[i] = min(D[i], SS - t + MM);
if (p[i] == '(')
t++;
else
t--;
if (MM > t) MM = t;
}
for (i = 0; i < n; i++) p[i + n] = p[i];
MM = -99999999;
for (i = 0; i < n; i++) {
if (MM < D2[i]) MM = D2[i];
}
for (i = 0; i < n; i++) {
if (MM == D2[i]) P[Pcnt++] = i;
}
Suffix_Array(2 * n);
MM2 = 99999999;
for (i = 0; i < n; i++) {
if (MM == D2[i] && MM2 > SA[i + 1]) {
MM2 = SA[i + 1];
pv = i;
}
}
for (i = 0; i < -MM; i++) Ans[cc++] = '(';
for (i = pv; i < n; i++) Ans[cc++] = p[i];
for (i = 0; i < pv; i++) Ans[cc++] = p[i];
for (i = 0; i < t; i++) Ans[cc++] = ')';
puts(Ans);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000006;
struct SuffixArray {
const int L;
string s;
vector<int> SA;
inline bool leq(int a1, int a2, int b1, int b2) {
return (a1 < b1 || a1 == b1 && a2 <= b2);
}
inline bool leq(int a1, int a2, int a3, int b1, int b2, int b3) {
return (a1 < b1 || a1 == b1 && leq(a2, a3, b2, b3));
}
void radixPass(int* a, int* b, int* r, int n, int K) {
int* c = new int[K + 1];
for (int i = 0; i < K + 1; ++i) c[i] = 0;
for (int i = 0; i < n; ++i) c[r[a[i]]]++;
for (int i = 0, sum = 0; i <= K; i++) {
int t = c[i];
c[i] = sum;
sum += t;
}
for (int i = 0; i < n; ++i) b[c[r[a[i]]]++] = a[i];
delete[] c;
}
SuffixArray(const string& s) : L(s.length()), s(s) {
SA.resize(L);
if (L == 1)
SA[0] = 0;
else {
int *sa = new int[L], *v = new int[L + 3];
int K = 255;
for (int i = 0; i < L; ++i) v[i] = int(s[i]);
v[L] = v[L + 1] = v[L + 2] = 0;
constructSA(v, sa, L, K);
for (int i = 0; i < L; ++i) SA[i] = sa[i];
delete[] v;
delete[] sa;
}
}
void constructSA(int* s, int* SA, int n, int K) {
int n0 = (n + 2) / 3, n1 = (n + 1) / 3, n2 = n / 3, n02 = n0 + n2;
int* s12 = new int[n02 + 3];
s12[n02] = s12[n02 + 1] = s12[n02 + 2] = 0;
int* SA12 = new int[n02 + 3];
SA12[n02] = SA12[n02 + 1] = SA12[n02 + 2] = 0;
int* s0 = new int[n0];
int* SA0 = new int[n0];
for (int i = 0, j = 0; i < n + (n0 - n1); i++)
if (i % 3 != 0) s12[j++] = i;
radixPass(s12, SA12, s + 2, n02, K);
radixPass(SA12, s12, s + 1, n02, K);
radixPass(s12, SA12, s, n02, K);
int name = 0, c0 = -1, c1 = -1, c2 = -1;
for (int i = 0; i < n02; ++i) {
if (s[SA12[i]] != c0 || s[SA12[i] + 1] != c1 || s[SA12[i] + 2] != c2) {
name++;
c0 = s[SA12[i]];
c1 = s[SA12[i] + 1];
c2 = s[SA12[i] + 2];
}
if (SA12[i] % 3 == 1)
s12[SA12[i] / 3] = name;
else
s12[SA12[i] / 3 + n0] = name;
}
if (name < n02) {
constructSA(s12, SA12, n02, name);
for (int i = 0; i < n02; ++i) s12[SA12[i]] = i + 1;
} else
for (int i = 0; i < n02; ++i) SA12[s12[i] - 1] = i;
for (int i = 0, j = 0; i < n02; i++)
if (SA12[i] < n0) s0[j++] = 3 * SA12[i];
radixPass(s0, SA0, s, n0, K);
for (int p = 0, t = n0 - n1, k = 0; k < n; k++) {
int i = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
int j = SA0[p];
if (SA12[t] < n0 ? leq(s[i], s12[SA12[t] + n0], s[j], s12[j / 3])
: leq(s[i], s[i + 1], s12[SA12[t] - n0 + 1], s[j],
s[j + 1], s12[j / 3 + n0])) {
SA[k] = i;
t++;
if (t == n02)
for (k++; p < n0; p++, k++) SA[k] = SA0[p];
} else {
SA[k] = j;
p++;
if (p == n0)
for (k++; t < n02; t++, k++)
SA[k] = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
}
}
delete[] s12;
delete[] SA12;
delete[] SA0;
delete[] s0;
}
vector<int> getSuffixArray() { return SA; }
};
int contagem[MAXN];
int L[MAXN], R[MAXN];
int main() {
ios_base::sync_with_stdio(false);
string s;
while (cin >> s) {
string t = s + s;
SuffixArray sa(t);
vector<int> v = sa.getSuffixArray();
int cnt = 0;
int mini = 0;
for (int i = 0; i < (int)s.size(); ++i) {
contagem[i] = cnt;
if (s[i] == '(')
cnt++;
else
cnt--;
mini = min(mini, cnt);
}
contagem[(int)s.size()] = cnt;
L[0] = contagem[0];
for (int i = 1; i < (int)s.size() + 1; ++i)
L[i] = min(contagem[i], L[i - 1]);
R[(int)s.size()] = contagem[(int)s.size()];
for (int i = (int)s.size() - 1; i >= 0; i--)
R[i] = min(contagem[i], R[i + 1]);
string resp = "";
if (cnt > 0) {
int k = -1;
for (int i = 0; i < (int)v.size(); ++i) {
if (v[i] >= (int)s.size()) continue;
if (L[v[i]] + cnt < contagem[v[i]]) continue;
if (R[v[i]] < contagem[v[i]]) continue;
k = v[i];
break;
}
for (int i = 0; i < (int)s.size(); ++i) {
resp += s[(k + i) % (int)s.size()];
}
while (cnt > 0) {
resp += ")";
cnt--;
}
} else {
int k = -1;
for (int i = 0; i < (int)v.size(); ++i) {
if (v[i] >= (int)s.size()) continue;
if (L[v[i]] < contagem[v[i]]) continue;
if (R[v[i]] - cnt < contagem[v[i]]) continue;
k = v[i];
break;
}
while (cnt < 0) {
resp += "(";
cnt++;
}
for (int i = 0; i < (int)s.size(); ++i) {
resp += s[(k + i) % (int)s.size()];
}
}
cout << resp << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 1000;
int t1, t2;
int lr[MAXN];
int ll[MAXN];
int rl[MAXN];
int rr[MAXN];
bool check(int i) {
if (i == 0) {
return rr[i] == t1 && rl[i] == t2;
}
int tl, tr;
tr = rr[i];
tl = ll[i - 1];
int tmin = min(rl[i], lr[i - 1]);
tl += rl[i] - tmin;
tr += lr[i - 1] - tmin;
if (tr == t1 && tl == t2) return true;
return false;
}
struct SA {
int rank[MAXN], height[MAXN];
int len;
inline int ge(char a) {
if (a == '(')
return 1;
else if (a == ')')
return 2;
else
return 0;
}
int sa[MAXN];
int wa[MAXN], wb[MAXN], wv[MAXN], ws[MAXN];
int cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void da(char *r, int *sa, int n, int m) {
int i, j, p, *x = wa, *y = wb, *t;
for (i = 0; i < m; i++) ws[i] = 0;
for (i = 0; i < n; i++) ws[x[i] = ge(r[i])]++;
for (i = 1; i < m; i++) ws[i] += ws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--ws[x[i]]] = i;
for (j = 1, p = 1; p < n; j *= 2, m = p) {
for (p = 0, i = n - j; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) wv[i] = x[y[i]];
for (i = 0; i < m; i++) ws[i] = 0;
for (i = 0; i < n; i++) ws[wv[i]]++;
for (i = 1; i < m; i++) ws[i] += ws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--ws[wv[i]]] = y[i];
for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
return;
}
int solve(char *s) {
len = strlen(s);
s[len] = 0;
da(s, sa, len + 1, 3);
for (int i = 0; i < len + 1; ++i) {
if (sa[i] < len / 2 && check(sa[i])) {
return sa[i];
}
}
return -1;
}
} tq;
char s[MAXN];
int main() {
while (scanf("%s", s) != EOF) {
memset(lr, 0, sizeof lr);
memset(ll, 0, sizeof ll);
memset(rr, 0, sizeof rr);
memset(rl, 0, sizeof rl);
int len = strlen(s);
t1 = 0, t2 = 0;
for (int i = 0; i < len; ++i) {
s[i + len] = s[i];
if (s[i] == '(') {
++t1;
} else {
++t2;
}
}
int tn = min(t1, t2);
t1 -= tn, t2 -= tn;
swap(t1, t2);
s[len * 2] = '\0';
int tl = 0, tr = 0;
for (int i = 0; i < len; ++i) {
if (s[i] == '(') {
++tl;
} else {
if (tl == 0)
++tr;
else
--tl;
}
lr[i] = tr;
ll[i] = tl;
}
tl = tr = 0;
for (int i = len - 1; i >= 0; --i) {
if (s[i] == ')') {
++tr;
} else {
if (tr == 0)
++tl;
else
--tr;
}
rr[i] = tr;
rl[i] = tl;
}
for (int i = 0; i < t1; ++i) putchar('(');
int tmp = tq.solve(s);
for (int i = 0; i < len; ++i) {
putchar(s[i + tmp]);
}
for (int i = 0; i < t2; ++i) putchar(')');
puts("");
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 2000005;
const int lmax = 21;
int n, i, N, val, add, A, B, mlc, sol;
int can[nmax], sum[nmax];
int sa[lmax][nmax], ord[nmax];
char s[nmax];
deque<int> q;
struct piece {
int x, y, i;
bool operator<(const piece &a) const {
if (x == a.x) return y < a.y;
return x < a.x;
}
};
piece L[nmax];
void find_candidates() {
for (i = 1; i < N; i++) {
while (!q.empty() && sum[i] < sum[q.back()]) q.pop_back();
q.push_back(i);
if (q.front() == i - n) q.pop_front();
if (i > n) {
if (s[i - n] == '(')
add--;
else
add++;
}
if (i >= n && sum[q.front()] + add + mlc >= 0) can[i - n + 1] = 1;
}
}
void suffix_arrays() {
for (i = 1; i <= N; i++) sa[0][i] = s[i] - '(';
int step, cnt;
for (step = 1, cnt = 1; (1 << step) <= N; step++, cnt *= 2) {
for (i = 1; i <= N; i++) {
L[i].x = sa[step - 1][i];
if (i + cnt <= N)
L[i].y = sa[step - 1][i + cnt];
else
L[i].y = -1;
L[i].i = i;
}
sort(L + 1, L + N + 1);
for (i = 1; i <= N; i++) {
if (i > 1 && L[i].x == L[i - 1].x && L[i].y == L[i - 1].y)
sa[step][L[i].i] = sa[step][L[i - 1].i];
else
sa[step][L[i].i] = i;
}
}
for (i = 1; i <= N; i++) ord[sa[step - 1][i]] = i;
}
int main() {
cin.sync_with_stdio(false);
cin >> s + 1;
n = strlen(s + 1);
for (i = 1; i <= n; i++) s[i + n] = s[i];
N = 2 * n;
for (i = 1; i <= N; i++) {
if (s[i] == '(')
val = 1;
else
val = -1;
sum[i] = sum[i - 1] + val;
}
for (i = 1; i <= n; i++) {
if (s[i] == '(')
A++;
else
B++;
}
if (B > A) mlc = B - A;
find_candidates();
suffix_arrays();
for (i = 1; i <= N; i++)
if (can[ord[i]]) {
sol = ord[i];
break;
}
s[n + 1] = '\0';
if (A >= B) {
cout << s + sol;
s[sol] = '\0';
cout << s + 1;
for (i = 1; i <= A - B; i++) cout << ')';
} else {
for (i = 1; i <= B - A; i++) cout << '(';
cout << s + sol;
s[sol] = '\0';
cout << s + 1;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> r[1000002];
char c[1000002];
int a[1000002], ls[1000002], lx[1000002], b[1000002], g[1000002], l, p, k, kk,
s;
int main() {
scanf("%s", c);
l = strlen(c);
k = 0;
for (int i = (0); i <= (l - 1); i++)
if (c[i] == '(') a[i] = kk + 1, b[p++] = i, k = 1;
if (k) kk++, k = 0;
for (int i = (0); i <= (l - 1); i++)
if (c[i] == ')') a[i] = kk + 1, b[p++] = i, k = 1;
if (k) kk++, k = 0;
for (int j = (0); j <= (20); j++) {
k = 1 << j;
if (k >= l) break;
for (int i = (1); i <= (kk); i++) r[i].clear();
s = 0;
for (int i = (0); i <= (l - 1); i++)
p = (b[i] - k + l) % l, r[a[p]].push_back(p);
p = 0;
for (int i = (1); i <= (kk); i++) {
int sz = r[i].size() - 1;
g[r[i][0]] = ++s;
b[p++] = r[i][0];
for (int ii = (1); ii <= (sz); ii++) {
int w = r[i][ii];
b[p++] = w;
if (a[(w + k) % l] != a[(r[i][ii - 1] + k) % l])
g[w] = ++s;
else
g[w] = s;
}
}
for (int i = (0); i <= (l - 1); i++) a[i] = g[i];
kk = s;
}
a[0] = 0;
for (int i = (1); i <= (l); i++)
if (c[i - 1] == '(')
a[i] = 1;
else
a[i] = -1;
for (int i = (2); i <= (l); i++) a[i] += a[i - 1];
ls[0] = l;
lx[l + 1] = l;
if (a[l] > 0)
p = 0;
else
p = a[l];
for (int i = (1); i <= (l); i++)
if (ls[i - 1] < a[i])
ls[i] = ls[i - 1];
else
ls[i] = a[i];
for (int i = (l); i >= (1); i--)
if (lx[i + 1] < a[i])
lx[i] = lx[i + 1];
else
lx[i] = a[i];
for (int i = (0); i <= (l - 1); i++) {
int ii = b[i] + 1;
if (lx[ii] - a[ii - 1] >= p && ls[ii - 1] + a[l] - a[ii - 1] >= p) {
if (a[l] < 0)
for (int j = (1); j <= (-a[l]); j++) printf("(");
for (int j = (ii - 1); j <= (l - 1); j++) printf("%c", c[j]);
for (int j = (0); j <= (ii - 2); j++) printf("%c", c[j]);
if (a[l] > 0)
for (int j = (1); j <= (a[l]); j++) printf(")");
return 0;
}
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.push_back(move(x));
return v;
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
int N;
string s;
struct entry {
int nr[2], p;
} L[2 * 1000013];
int P[2][4 * 1000013], stp;
int order[1000013];
int prefix[1000013];
int total;
int st[2097152];
char ANS[2 * 1000013];
void update(int i, int x, int lo = 0, int hi = -1, int node = 0) {
if (hi == -1) hi = N;
if (i < lo || i > hi) return;
if (lo == hi) {
st[node] += x;
return;
}
int mid = (lo + hi) / 2;
update(i, x, lo, mid, 2 * node + 1);
update(i, x, mid + 1, hi, 2 * node + 2);
st[node] = min(st[2 * node + 1], st[2 * node + 2]);
}
int query(int s, int e, int lo = 0, int hi = -1, int node = 0) {
if (hi == -1) hi = N;
if (e < lo || s > hi) return (1 << 30);
if (s <= lo && hi <= e) return st[node];
int mid = (lo + hi) / 2;
return min(query(s, e, lo, mid, 2 * node + 1),
query(s, e, mid + 1, hi, 2 * node + 2));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> s;
N = s.size();
for (int i = 0; i < N; i++) {
prefix[i + 1] = prefix[i] + (s[i] == '(' ? 1 : -1);
update(i + 1, prefix[i + 1]);
}
total = prefix[N];
for (int i = 0; i < 2 * N; i++) {
P[0][i] = (s[i % N] == ')') + 1;
}
for (stp = 1; (1 << (stp - 1)) < 2 * N; stp++) {
int cnt = 1 << (stp - 1);
int t = stp % 2;
for (int i = 0; i < 2 * N; i++) {
L[i].nr[0] = P[!t][i];
L[i].nr[1] = P[!t][i + cnt];
L[i].p = i;
}
sort(L, L + 2 * N, [](entry a, entry b) {
return a.nr[0] == b.nr[0] ? a.nr[1] < b.nr[1] : a.nr[0] < b.nr[0];
});
int cur = 1;
for (int i = 0; i < 2 * N; i++) {
if (i == 0 ||
(L[i].nr[0] == L[i - 1].nr[0] && L[i].nr[1] == L[i - 1].nr[1])) {
P[t][L[i].p] = cur;
} else {
P[t][L[i].p] = ++cur;
}
}
}
for (int i = 0; i < N; i++) {
order[i] = i;
}
stp = (stp - 1) % 2;
sort(order, order + N, [](int a, int b) { return P[stp][a] < P[stp][b]; });
int a;
for (int i = 0; i < N; i++) {
int idx = order[i];
int amt = query(idx + 1, N) - prefix[idx];
amt = min(amt, query(1, idx) + total - prefix[idx]);
int bound = min(total, 0);
if (amt >= bound) {
a = idx;
break;
}
}
int idx = 0;
if (total < 0) {
for (int i = 0; i < -total; i++) {
ANS[idx++] = '(';
}
}
for (int i = a; i < a + N; i++) {
ANS[idx++] = s[i % N];
}
if (total > 0) {
for (int i = 0; i < total; i++) {
ANS[idx++] = ')';
}
}
for (int i = 0; i < idx; i++) {
cout << ANS[i];
}
cout << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int sp[2000514 * 7], spt;
int ta[2000514], tb[2000514], tc[2000514];
int box[2000514];
void radix(int *key, int *a, int *b, int n, int m) {
for (int i = 0; i <= m; i++) box[i] = 0;
for (int i = 0; i < n; i++) box[key[a[i]]]++;
for (int i = 1; i <= m; i++) box[i] += box[i - 1];
for (int i = n - 1; i >= 0; i--) b[--box[key[a[i]]]] = a[i];
}
bool equ(int *s, int a, int b) {
return s[a] == s[b] && s[a + 1] == s[b + 1] && s[a + 2] == s[b + 2];
}
bool cmp(int *s, int *sa12, int a, int b) {
if (s[a + 0] != s[b + 0]) return s[a + 0] < s[b + 0];
if (b % 3 == 1) return sa12[a + 1] < sa12[b + 1];
if (s[a + 1] != s[b + 1]) return s[a + 1] < s[b + 1];
return sa12[a + 2] < sa12[b + 2];
}
void make_sa(int *sa, int *s, int l, int m) {
for (int i = 0; i < 3; i++) {
s[l + i] = 0;
}
int nl = 0, hl = (l + 1) / 3;
for (int i = 0; i < l; i++)
if (i % 3) ta[nl++] = i;
radix(s + 2, ta, tb, nl, m);
radix(s + 1, tb, ta, nl, m);
radix(s + 0, ta, sa, nl, m);
int *nsa = sp + spt;
spt += nl + 3;
int *ns = sp + spt;
spt += nl + 3;
int j = 1;
ns[((sa[0]) / 3 + ((sa[0]) % 3 == 1 ? 0 : hl))] = 0;
for (int i = 1; i < nl; i++) {
ns[((sa[i]) / 3 + ((sa[i]) % 3 == 1 ? 0 : hl))] =
equ(s, sa[i - 1], sa[i]) ? j - 1 : j++;
}
if (j < nl)
make_sa(nsa, ns, nl, j);
else
for (int i = 0; i < nl; i++) nsa[ns[i]] = i;
int nr = 0;
for (int i = 0; i < nl; i++) {
if (nsa[i] < hl) tb[nr++] = nsa[i] * 3;
}
if (l % 3 == 1) tb[nr++] = l - 1;
radix(s, tb, ta, nr, m);
for (int i = 0; i < nl; i++) {
tc[tb[i] = ((nsa[i]) < hl ? (nsa[i]) * 3 + 1 : ((nsa[i]) - hl) * 3 + 2)] =
i;
}
int p = 0, q = 0, r = 0;
for (; p < nr && q < nl;) {
sa[r++] = cmp(s, tc, ta[p], tb[q]) ? ta[p++] : tb[q++];
}
for (; p < nr;) sa[r++] = ta[p++];
for (; q < nl;) sa[r++] = tb[q++];
spt -= (nl + 3) * 2;
}
char s[2000514];
int sum[2000514];
int qk[2000514];
int qx[2000514];
int qs, qe;
int mx[2000514];
int sa[2000514];
int ns[2000514];
void sol() {
int l = 1;
for (; s[l]; l++)
;
l--;
for (int i = 1; i <= l; i++) s[i + l] = s[i];
s[l + l + 1] = 0;
int nl = l * 2;
for (int i = 1; i <= nl; i++) ns[i] = (s[i] == '(' ? 1 : 2);
ns[nl + 1] = 0;
for (int i = 1; i <= nl; i++) sum[i] = sum[i - 1] + (s[i] == '(' ? 1 : -1);
int d = sum[l];
qs = qe = 0;
for (int i = 1; i <= nl; i++) {
if (qe - qs && qx[qs] <= i - l) qs++;
for (; qe - qs && qk[qe - 1] >= sum[i]; qe--)
;
qk[qe] = sum[i];
qx[qe] = i;
qe++;
mx[i] = qk[qs];
}
make_sa(sa, ns + 1, nl + 1, 128);
int ans = -1;
for (int i = 0; i < nl + 1; i++) {
int w = sa[i] + 1;
if (w > l) continue;
int tmn = mx[w + l - 1];
if (d < 0) {
if (tmn - sum[w - 1] >= d) {
ans = w;
break;
}
} else {
if (tmn - sum[w - 1] >= 0) {
ans = w;
break;
}
}
}
for (; d < 0; d++) putchar('(');
s[ans + l] = 0;
printf("%s", s + ans);
for (; d > 0; d--) putchar(')');
puts("");
}
int main() {
while (scanf("%s", s + 1) != EOF) sol();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long shift = 21, mask = (1LL << shift) - 1;
int n, i, j, k, m, a[1000100], b[1000100], all[1000100], l[2000100], cnt, cur,
last, now, best = -1000000000;
unsigned long long f[2000100], id, lastId;
char s[2000100];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; i++) {
a[i] = a[i - 1] + (s[i] == '(' ? 1 : -1);
b[i] = min(b[i - 1], a[i]);
s[i + n] = s[i];
}
for (i = 1; i <= 2 * n; i++) l[i - 1] = 1 + int(s[i] == ')');
for (i = n; i > 0; i--) {
now = min(0, min(b[i] + last, cur));
if (now > best) {
best = now;
m = 0;
}
if (now == best) all[m++] = i;
if (s[i] == ')') {
last--;
cur = min(cur - 1, -1);
} else {
last++;
cur++;
}
}
for (k = 0; k < shift; k++) {
for (i = 0; i < 2 * n; i++) {
long long x = l[i];
long long y = ((i + (1 << k)) >= 2 * n) ? 0 : l[i + (1 << k)];
if (x >= (1LL << shift) || y >= (1LL << shift)) puts("!");
f[i] = (((x << shift) + y) << shift) + i;
}
sort(f, f + 2 * n);
for (lastId = -1, i = 0; i < 2 * n; i++) {
id = (f[i] >> shift);
if (id != lastId) {
lastId = id;
j = i + 1;
}
l[f[i] & mask] = j;
}
}
for (i = 0; i < -best; i++) {
putchar('(');
cnt++;
}
for (i = k = 0; i < m; i++)
if (l[all[k]] > l[all[i]]) k = i;
for (i = 0; i < n; i++) {
char ch = s[all[k] + i + 1];
cnt += (ch == '(' ? 1 : -1);
putchar(ch);
}
for (; cnt > 0; cnt--) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,inline,unroll-loops,fast-math")
using namespace std;
char a[4000020];
int f[4000020], g[4000020], h[4000020];
deque<int> q;
void InitSA(char *s, int n, int m) {
static int l[4000020], r[4000020], c[4000020];
int i, p, k;
int *x, *y;
x = l;
y = r;
for (i = 0; i < n; i++) {
x[i] = s[i + 1];
c[x[i]]++;
}
for (i = 1; i <= m; i++) c[i] += c[i - 1];
for (i = n - 1; i > -1; i--) f[--c[x[i]]] = i;
for (k = 1; k < n; k <<= 1) {
for (i = n - k, p = 0; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (f[i] >= k) y[p++] = f[i] - k;
for (i = 0; i <= m; i++) c[i] = 0;
for (i = 0; i < n; i++) c[x[i]]++;
for (i = 1; i <= m; i++) c[i] += c[i - 1];
for (i = n - 1; i > -1; i--) f[--c[x[y[i]]]] = y[i];
swap(x, y);
for (i = 1, x[f[0]] = m = 0; i < n; i++)
x[f[i]] =
y[f[i]] == y[f[i - 1]] && y[f[i] + k] == y[f[i - 1] + k] ? m : ++m;
if (m >= n) break;
}
return;
}
int main(void) {
int n;
int i;
scanf("%s", a + 1);
n = strlen(a + 1);
for (i = 1; i <= n; i++) a[i + n] = a[i];
InitSA(a, n * 2, ')');
for (i = 1; i <= n * 2; i++) {
g[i] = g[i - 1] + (a[i] == '(' ? 1 : -1);
for (; !q.empty() && i - q.front() > n; q.pop_front())
;
for (; !q.empty() && g[q.back()] > g[i]; q.pop_back())
;
q.push_back(i);
if (i >= n) h[i - n + 1] = g[q.front()];
}
if (g[n] < 0)
for (i = 0; i < -g[n]; i++) printf("(");
for (i = 0; i < n * 2; i++)
if (f[i] < n && h[f[i] + 1] - g[f[i]] >= min(g[n], 0)) break;
a[f[i] + 1 + n] = 0;
printf("%s", a + f[i] + 1);
if (g[n] > 0)
for (i = 0; i < g[n]; i++) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[2000100];
int Lb[2000100 << 2], Rb[2000100 << 2];
void build(int x, int L, int R) {
if (L == R) {
if (s[L] == '(')
Rb[x] = 1;
else
Lb[x] = 1;
return;
}
int mid = L + R >> 1;
build((x << 1), L, mid);
build((x << 1 | 1), mid + 1, R);
if (Rb[(x << 1)] > Lb[(x << 1 | 1)]) {
Lb[x] = Lb[(x << 1)];
Rb[x] = Rb[(x << 1 | 1)] + Rb[(x << 1)] - Lb[(x << 1 | 1)];
} else {
Lb[x] = Lb[(x << 1)] + Lb[(x << 1 | 1)] - Rb[(x << 1)];
Rb[x] = Rb[(x << 1 | 1)];
}
}
int lb, rb;
int qury(int x, int L, int R, int l, int r) {
if (l <= L && R <= r) {
lb = lb + max(0, Lb[x] - rb);
rb = Rb[x] + max(0, rb - Lb[x]);
return lb;
}
int mid = L + R >> 1, res;
if (l <= mid) res = qury((x << 1), L, mid, l, r);
if (r > mid) res = qury((x << 1 | 1), mid + 1, R, l, r);
return res;
}
int _wa[2000100], _wb[2000100], _wv[2000100], _ws[2000100];
int _cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void Get_Sa(int *r, int *sa, int n, int m) {
int i, j, p, *x = _wa, *y = _wb, *t;
for (i = 0; i < m; i++) _ws[i] = 0;
for (i = 0; i < n; i++) _ws[x[i] = r[i]]++;
for (i = 1; i < m; i++) _ws[i] += _ws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--_ws[x[i]]] = i;
for (j = 1, p = 1; p < n; j <<= 1, m = p) {
for (p = 0, i = n - j; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) _wv[i] = x[y[i]];
for (i = 0; i < m; i++) _ws[i] = 0;
for (i = 0; i < n; i++) _ws[_wv[i]]++;
for (i = 1; i < m; i++) _ws[i] += _ws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--_ws[_wv[i]]] = y[i];
for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
x[sa[i]] = _cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
int rnk[2000100], ht[2000100];
void Get_H(int *r, int *sa, int n) {
int i, j, k = 0;
for (i = 0; i <= n; i++) rnk[sa[i]] = i;
for (i = 0; i < n; ht[rnk[i++]] = k)
for (k ? k-- : 0, j = sa[rnk[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
int sa[2000100], pr[2000100];
struct Node {
int l, m, id;
} ax[2000100];
int cmp(const Node &a, const Node &b) {
if (a.l < b.l)
return 1;
else if (a.l == b.l) {
if (a.m < b.m)
return 1;
else
return 0;
} else
return 0;
}
int main() {
scanf("%s", s);
int zer = 0, one = 0, len = strlen(s), _len = len;
int sum1 = 0, sum2 = 0;
for (int i = 0; i < _len; i++)
if (s[i] == '(')
sum1++;
else
sum2++;
for (int i = 0; i < _len - 1; i++) s[len++] = s[i];
s[len] = 0;
for (int i = 0; i < len; i++) {
if (s[i] == '(')
pr[i] = 1;
else
pr[i] = 2;
}
pr[len] = 0;
Get_Sa(pr, sa, len + 1, 3);
Get_H(pr, sa, len);
build(1, 0, len - 1);
for (int i = 0; i < _len; i++) {
lb = rb = 0;
ax[i].l = qury(1, 0, len - 1, i, i + _len - 1);
ax[i].m = rnk[i];
ax[i].id = i;
}
sort(ax, ax + _len, cmp);
int bj = ax[0].id;
string ans = "";
for (int i = 0; i < ax[0].l; i++) ans += '(';
for (int i = bj; i < _len; i++) ans += s[i];
for (int i = 0; i < bj; i++) ans += s[i];
int lef = sum1 + ax[0].l - sum2;
for (int i = 0; i < lef; i++) ans += ')';
cout << ans << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5 * 1000 * 1000 + 13;
string s;
int a[N];
int n;
int pos[N], c[N];
int cnt[N], tmp[N];
int curLcp[N];
inline void calcSufMasAndLCP() {
s.push_back(0);
n++;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < int(n); ++i) cnt[(int)s[i]]++;
for (int i = 1; i <= N - 1; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) pos[--cnt[(int)s[i]]] = i;
int comp = 1;
c[pos[0]] = comp - 1;
for (int i = 1; i <= n - 1; i++) {
if (s[pos[i]] != s[pos[i - 1]]) comp++;
c[pos[i]] = comp - 1;
}
for (int h = 0; (1 << h) < n && comp < n; h++) {
for (int i = 0; i < int(n); ++i) pos[i] = (pos[i] - (1 << h) + n) % n;
memset(cnt, 0, sizeof(int) * comp);
for (int i = 0; i < int(n); ++i) cnt[c[i]]++;
for (int i = 1; i <= comp - 1; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) tmp[--cnt[c[pos[i]]]] = pos[i];
memcpy(pos, tmp, sizeof(int) * n);
comp = 1;
tmp[pos[0]] = comp - 1;
for (int i = 1; i <= n - 1; i++) {
if (c[pos[i]] != c[pos[i - 1]] ||
c[(pos[i] + (1 << h)) % n] != c[(pos[i - 1] + (1 << h)) % n])
comp++;
tmp[pos[i]] = comp - 1;
}
memcpy(c, tmp, sizeof(int) * n);
}
for (int i = 0; i < int(n - 1); ++i) a[i] = pos[i + 1];
int last = 0;
for (int i = 0; i < int(n); ++i) {
int a = i;
if (c[a] == n - 1) {
last = 0;
continue;
}
int b = pos[c[a] + 1];
int val = max(0, last - 1);
while (a + val < n && b + val < n && s[a + val] == s[b + val]) val++;
if (c[a] > 0) curLcp[c[a] - 1] = val;
last = val;
}
n--;
}
string str;
char buf[N];
multiset<int> ss;
bool read() {
if (scanf("%s", buf) <= 0) return false;
str = buf;
n = int(str.size());
return true;
}
int ppos[N];
void solve() {
int nn = n;
s = str + str;
n *= 2;
calcSufMasAndLCP();
n = nn;
for (int i = 0; i < int(n * 2); ++i) {
ppos[a[i]] = i;
}
int bal = 0;
int c = 0;
int mn = 0;
for (int i = 0; i < int(n); ++i) {
bal += str[i] == '(' ? 1 : -1;
mn = min(mn, bal);
ss.insert(bal);
}
int sum = bal;
int bestop = -mn;
int pos = 0;
for (int i = 0; i < int(n - 1); ++i) {
int bal = str[i] == '(' ? 1 : -1;
ss.erase(ss.find(bal - c));
c -= bal;
ss.insert(sum - c);
int mn = min(0, *ss.begin() + c);
if (-mn < bestop) {
bestop = -mn;
pos = i + 1;
}
if (-mn == bestop && ppos[i + 1] < ppos[pos]) pos = i + 1;
}
string s = str + str;
string r = s.substr(pos, n);
r = string(bestop, '(') + r;
sum += bestop;
r = r + string(sum, ')');
printf("%s", r.c_str());
}
int main() {
while (read()) solve();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 1000;
int Wa[maxn], Wb[maxn], Wv[maxn], Ws[maxn], sa[maxn];
int Rank[maxn];
int height[maxn];
set<int> S;
map<int, int> M;
vector<int> V;
int a[maxn];
int cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void get_sa(int *r, int *sa, int n, int m) {
int i, j, p, *x = Wa, *y = Wb, *t;
for (i = 0; i < m; i++) Ws[i] = 0;
for (i = 0; i < n; i++) Ws[x[i] = r[i]]++;
for (i = 1; i < m; i++) Ws[i] += Ws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--Ws[x[i]]] = i;
for (p = 1, j = 1; p < n; j *= 2, m = p) {
for (p = 0, i = n - j; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) Wv[i] = x[y[i]];
for (i = 0; i < m; i++) Ws[i] = 0;
for (i = 0; i < n; i++) Ws[Wv[i]]++;
for (i = 1; i < m; i++) Ws[i] += Ws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--Ws[Wv[i]]] = y[i];
for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
void get_height(int *r, int *sa, int n) {
int i, j, k = 0;
for (i = 1; i <= n; i++) Rank[sa[i]] = i;
for (i = 0; i < n; height[Rank[i++]] = k)
for (k ? k-- : 0, j = sa[Rank[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
void Hinsert(int x) {
if (M[x] == 0) S.insert(x);
M[x]++;
}
void Herase(int x) {
if (M[x] == 1) S.erase(x);
M[x]--;
}
char str[maxn];
int tr, tl;
int main() {
cin >> str;
int n = strlen(str), nl = 0, nr = 0;
for (int i = 0; i < n; i++) {
if (str[i] == '(')
nl++, str[i] = 1;
else
nr++, str[i] = 2;
}
if (nl < nr) {
tl = 0;
for (int i = n - 1; i >= 0; i--) {
if (str[i] == 1) tl++;
a[i] = 2 * tl - (n - i);
Hinsert(-a[i]);
}
tl = 0;
for (int i = n - 1; i >= 0; i--) {
if (-(*S.begin()) <= -(n - i - 1) + 2 * tl) V.push_back(i);
Herase(-a[i]);
if (str[i] == 1) tl++;
Hinsert(-(2 * nl - n - (n - i) + 2 * tl));
}
int N = 2 * n - 1;
for (int i = 0; i < n; i++) a[i] = str[i];
for (int i = n; i < N; i++) a[i] = str[i - n];
get_sa(a, sa, N + 1, 4);
for (int i = 1; i <= N; i++) Rank[sa[i]] = i;
int maxr = N + 100, Kr = 0;
for (auto i : V) {
if (i + 1 >= N) break;
if (Rank[i + 1] < maxr) {
maxr = Rank[i + 1];
Kr = i + 1;
}
}
a[N] = a[N - n];
for (int i = 0; i < nr - nl; i++) printf("(");
for (int i = Kr; i < Kr + n; i++) printf("%c", a[i] == 2 ? ')' : '(');
} else {
tr = 0;
for (int i = 0; i < n; i++) {
if (str[i] == 2) tr++;
a[i] = 2 * tr - i - 1;
Hinsert(-a[i]);
}
tr = 0;
for (int i = 0; i < n; i++) {
if (-(*S.begin()) <= -i + 2 * tr) V.push_back(i);
Herase(-a[i]);
if (str[i] == 2) tr++;
Hinsert(-(2 * nr - n - i - 1 + 2 * tr));
}
int N = 2 * n - 1;
for (int i = 0; i < n; i++) a[i] = str[i];
for (int i = n; i < N; i++) a[i] = str[i - n];
get_sa(a, sa, N + 1, 4);
for (int i = 1; i <= N; i++) Rank[sa[i]] = i;
int maxr = N + 100, Kr = 0;
for (auto i : V) {
if (Rank[i] < maxr) {
maxr = Rank[i];
Kr = i;
}
}
for (int i = Kr; i < Kr + n; i++) printf("%c", a[i] == 2 ? ')' : '(');
for (int i = 0; i < nl - nr; i++) printf(")");
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int last, cnt;
int sa[2000100], rnk[2000100];
pair<int, int> tr[4200000];
char s[2000100], st[2000100];
int n;
struct SAM {
int l[2000100 * 2], ch[2000100 * 2][2], fa[2000100 * 2], cnt, last, len,
lp[2000100 * 2];
int son[2000100 * 2], son1[2000100 * 2], lnk[2000100 * 5], nxt[2000100 * 5],
tcnt, b[28], t[2000100 * 2], ec, d;
bool mark[2000100 * 2];
char s[2000100];
void addedge1(int x, int y) {
nxt[++ec] = son1[x];
lnk[son1[x] = ec] = y;
}
void add(int c) {
int np = ++cnt, p = last;
last = np;
l[np] = ++len;
mark[np] = true;
lp[np] = 0;
for (; p && !ch[p][c]; p = fa[p]) ch[p][c] = np;
if (!p)
fa[np] = 1;
else {
int q = ch[p][c];
if (l[p] + 1 == l[q])
fa[np] = q;
else {
int nq = ++cnt;
lp[nq] = lp[q] + l[q] - 1 - l[p];
l[nq] = l[p] + 1;
mark[nq] = false;
memcpy(ch[nq], ch[q], sizeof ch[q]);
fa[nq] = fa[q];
fa[q] = fa[np] = nq;
for (; ch[p][c] == q; p = fa[p]) ch[p][c] = nq;
}
}
}
void dfs(int u, int *sa) {
for (int p = u; p;)
if (son[p]) {
int v = lnk[son[p]];
son[p] = nxt[son[p]];
if (mark[v]) sa[tcnt++] = len - l[v];
p = v;
} else
p = fa[p];
}
void addedge(int x, int y) {
nxt[++ec] = son[x];
lnk[son[x] = ec] = y;
}
void build_tree() {
memset(b, 0, sizeof b);
for (int i = 2; i <= cnt; ++i) ++b[s[lp[i] + l[i] - l[fa[i]] - 1] - 'a'];
for (int i = 1; i < 28; ++i) b[i] += b[i - 1];
for (int i = 2; i <= cnt; ++i)
t[b[s[lp[i] + l[i] - l[fa[i]] - 1] - 'a']--] = i;
for (int i = cnt - 1; i; --i) addedge(fa[t[i]], t[i]);
}
void construct_sa(char *ss, int n) {
tcnt = 0;
for (int i = 0; i < n; ++i) s[n - i - 1] = ss[i];
construct(n);
build_tree();
dfs(1, sa);
for (int i = 0; i < n; i++) rnk[sa[i]] = i;
}
void construct(int n) {
len = 0;
last = cnt = 1;
for (int i = 0; i < n; ++i) add(s[i] - 'a');
}
} sam;
void build_sa() { sam.construct_sa(st, n); }
pair<int, int> upd(pair<int, int> b, pair<int, int> c) {
return make_pair(c.first + max(0, b.first - c.second),
b.second + max(0, c.second - b.first));
}
void build_tree(int l, int r, int k) {
if (l == r) {
if (s[l] == '(')
tr[k] = make_pair(1, 0);
else
tr[k] = make_pair(0, 1);
return;
}
int mid = (l + r) >> 1;
build_tree(l, mid, k << 1);
build_tree(mid + 1, r, k << 1 | 1);
tr[k] = upd(tr[k << 1], tr[k << 1 | 1]);
}
pair<int, int> ret;
void qry(int L, int R, int l, int r, int k) {
if (L <= l && r <= R) {
ret = upd(ret, tr[k]);
return;
}
int mid = (l + r) >> 1;
if (L <= mid) qry(L, R, l, mid, k << 1);
if (mid < R) qry(L, R, mid + 1, r, k << 1 | 1);
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) s[i + n] = s[i];
n *= 2;
for (int i = 0; i < n; i++)
if (s[i] == '(')
st[i] = 'a';
else
st[i] = 'b';
build_sa();
build_tree(0, n - 1, 1);
pair<int, int> ans = make_pair(0, 0);
int pos = -1;
for (int i = 0; i < n / 2; i++) {
ret = make_pair(0, 0);
qry(i, i + n / 2 - 1, 0, n - 1, 1);
if (ret.first && ret.second) continue;
if (pos == -1 || rnk[i] < rnk[pos]) pos = i;
ans = ret;
}
for (int i = 0; i < ans.second; i++) putchar('(');
for (int i = pos; i < pos + n / 2; i++) putchar(s[i]);
for (int i = 0; i < ans.first; i++) putchar(')');
putchar('\n');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 6;
char s[N];
int p1[N];
int p2[N];
int s1[N];
int s2[N];
long long X1 = 277, X2 = 2887;
long long M1 = 1444444447, M2 = 1777777777;
long long x1[N], x2[N];
struct hasher {
vector<long long> h1, h2;
hasher() {}
string s;
hasher(char *str) {
s = str;
int n = s.length();
h1.assign(n + 1, 0);
for (int i = n - 1; i >= 0; --i) {
h1[i] = (h1[i + 1] * X1 + s[i]) % M1;
}
}
long long get(int l, int r) {
return ((h1[l] - h1[r + 1] * x1[r - l + 1] % M1 + M1) % M1);
}
};
int cmp(hasher &s1, int i1, int j1, hasher &s2, int i2, int j2) {
int l = 0, r = min(j1 - i1 + 1, j2 - i2 + 1) + 1;
while (l < r) {
int m = (l + r) >> 1;
if (s1.get(i1, i1 + m - 1) == s2.get(i2, i2 + m - 1))
l = m + 1;
else
r = m;
}
--l;
if (i1 + l > j1 && i2 + l > j2) return 0;
if (i1 + l > j1) return -1;
if (i2 + l > j2) return 1;
return s1.s[i1 + l] < s2.s[i2 + l] ? -1 : 1;
}
hasher h, ho, hz;
int n;
void calc(int i, int &il, int &ir) {
int op = p2[i];
int zp = i - p1[i] - op;
int zs = s2[i + 1];
int os = n - i - s1[i + 1] - zs;
il = zs;
ir = op;
if (os > zp)
ir += os - zp;
else
il += zp - os;
}
bool cmp(int i, int j, int len, int k) {
int il, ir, jl, jr;
calc(i, il, ir);
calc(j, jl, jr);
int im = len - il - ir;
int jm = len - jl - jr;
if (k < il) {
if (k < jl) {
return cmp(i, j, len, min(il, jl));
} else if (k < jl + jm) {
int d = min(il - k, jl + jm - k);
int dif = cmp(ho, 0, d - 1, h, j + (k - jl), j + (k - jl) + d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
} else {
return true;
}
} else if (k < il + im) {
if (k < jl) {
int d = min(jl - k, il + im - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, ho, 0, d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
} else if (k < jl + jm) {
int d = min(il + im - k, jl + jm - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, h, j + (k - jl),
j + (k - jl) + d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
} else {
int d = min(il + im - k, len - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, hz, 0, d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
}
} else if (k < len) {
if (k < jl) {
return false;
} else if (k < jl + jm) {
int d = min(len - k, jl + jm - k);
int dif = cmp(hz, 0, d - 1, h, j + (k - jl), j + (k - jl) + d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
} else {
return cmp(i, j, len, len);
}
} else
return false;
}
char e[N];
string ans;
string func(string &s) {
string res;
int m = 0;
for (int i = 0; i < s.length(); ++i)
if (s[i] == '(') {
++m;
} else {
if (!m)
res += "(";
else
--m;
}
res += s;
while (m--) res += ")";
return res;
}
int main() {
for (int i = x1[0] = 1; i < N; ++i) x1[i] = x1[i - 1] * X1 % M1;
gets(s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) s[i + n] = s[i];
for (int i = n; i; --i) {
if (s[i] == '(') {
if (s2[i + 1]) {
s1[i] = s1[i + 1] + 2;
s2[i] = s2[i + 1] - 1;
} else {
s1[i] = s1[i + 1];
s2[i] = s2[i + 1];
}
} else {
s1[i] = s1[i + 1];
s2[i] = s2[i + 1] + 1;
}
}
for (int i = 1; i <= n; ++i) {
if (s[i] == ')') {
if (p2[i - 1]) {
p1[i] = p1[i - 1] + 2;
p2[i] = p2[i - 1] - 1;
} else {
p1[i] = p1[i - 1];
p2[i] = p2[i - 1];
}
} else {
p1[i] = p1[i - 1];
p2[i] = p2[i - 1] + 1;
}
}
int x = n * 10;
vector<int> pos;
for (int i = 0; i < n; ++i) {
int op = p2[i];
int zp = i - p1[i] - op;
int zs = s2[i + 1];
int os = n - i - s1[i + 1] - zs;
int len = zs + op + max(os, zp) - min(os, zp) + n;
if (x > len) {
pos.clear();
x = len;
}
if (x == len) {
pos.push_back(i);
}
int sl, sr;
calc(i, sl, sr);
}
h = hasher(s + 1);
for (int i = 0; i < n * 2; ++i) e[i] = '(';
ho = hasher(e);
for (int i = 0; i < n * 2; ++i) e[i] = ')';
hz = hasher(e);
int res = pos[0];
for (int k = 1; k < pos.size(); ++k)
if (cmp(pos[k], res, x, 0)) res = pos[k];
int sl, sr;
calc(res, sl, sr);
for (int i = 0; i < sl; ++i) printf("(");
for (int i = 0; i < x - sl - sr; ++i) printf("%c", s[res + i + 1]);
for (int i = 0; i < sr; ++i) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool b[2000005];
char c[2000005];
int h[2000005], q[2000005];
int i, j, k, n, H, T, t;
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (i = 1; i <= n; i++) t += (c[i] == '(') ? 1 : -1;
for (i = n + 1; i <= n * 2; i++) c[i] = c[i - n];
if (t < 0)
for (i = 1; i <= -t; i++) putchar('(');
for (i = 1; i <= 2 * n; i++) h[i] = h[i - 1] + ((c[i] == '(') ? 1 : -1);
H = 1;
T = 0;
for (i = 1; i <= n; i++) {
for (; T && h[i] < h[q[T]]; T--)
;
q[++T] = i;
}
for (i = 1; i <= n; i++) {
if (h[q[H]] - h[i - 1] < min(t, 0)) b[i] = 1;
for (; T >= H && h[n + i] < h[q[T]]; T--)
;
q[++T] = n + i;
if (q[H] == i) H++;
}
for (i = 1, j = 2;;) {
for (; b[i]; i++)
;
for (; b[j]; j++)
;
if (i == j)
for (j++; b[j]; j++)
;
if (i > n || j > n) break;
for (k = 0; k < n && c[i + k] == c[j + k]; k++)
;
if (c[i + k] < c[j + k])
j = j + k + 1;
else
i = i + k + 1;
}
if (j < i) i = j;
for (j = i; j < n + i; j++) putchar(c[j]);
if (t > 0)
for (i = 1; i <= t; i++) putchar(')');
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T1, typename T2>
inline void remin(T1& a, T2 b) {
a = min(a, (T1)b);
}
const int maxN = 1 << 21;
namespace SuffixArray {
int temp[maxN], inds[maxN], C[maxN], T[maxN * 4], *R, *P;
bool cmp(int i, int j) {
while (P[i] == P[j]) i++, j++;
return P[i] < P[j];
}
void brut(int n, int* T, int* res) {
iota(res, res + n, 0);
P = T;
sort(res, res + n, cmp);
}
int cntSort(int n, int* T, int k) {
int m = 0;
if (k == 0) {
for (int i = 0; i < n; i += 3) temp[m++] = i;
for (int i = 1; i < n; i += 3) temp[m++] = i;
} else
for (int i = 2; i < n; i += 3) temp[m++] = i;
for (int j = (2 - k); j > (-1); j--) {
for (int i = (0); i < (m); i++) {
int ind = temp[i];
int v = j & k ? R[ind + 1] : T[ind + j];
C[v]++;
}
for (int i = 1; C[i - 1] != m; i++) C[i] += C[i - 1];
for (int i = (m - 1); i > (-1); i--) {
int ind = temp[i];
int v = j & k ? R[ind + 1] : T[ind + j];
inds[--C[v]] = ind;
}
fill(C, C + n + 1, 0);
if (j != 0) copy(inds, inds + m, temp);
}
return m;
}
inline bool differ(int* T, int i, int j) {
return T[i + 2] ^ T[j + 2] | T[i + 1] ^ T[j + 1] | T[i] ^ T[j];
}
inline int newInd(int i, int p) { return i / 3 + i % 3 * p; }
void calcRanks(int* sa, int n, int d = 0) {
for (int i = (0); i < (n); i++) R[sa[i]] = i + d;
}
bool cmpMerge(int i, int j) {
for (; true; i++, j++) {
if (P[i] != P[j]) return P[i] < P[j];
if (i % 3 != 2 and j % 3 != 2) return R[i] < R[j];
}
}
void ks(int n, int* T, int* res) {
if (n < 6) {
brut(n, T, res);
return;
}
int m = cntSort(n, T, 0), p = (n + 2) / 3 + 1, ctr = 2;
int *A = T + n + 2, *S = res + n / 3;
A[p - 1] = 1, A[m + 1] = A[m + 2] = 0;
for (int i = (0); i < (m); i++) {
if (i != 0 and differ(T, inds[i - 1], inds[i])) ctr++;
A[newInd(inds[i], p)] = ctr;
}
ks(m + 1, A, S - 1);
for (int i = (0); i < (m); i++)
S[i] = S[i] < p ? S[i] * 3 : (S[i] - p) * 3 + 1;
calcRanks(S, m, 1);
R[n] = 0;
int k = cntSort(n, T, 1);
P = T;
merge(S, S + m, inds, inds + k, res, cmpMerge);
}
void run(char* Tin, int n, int* sa, int* lcp, int* ranks) {
R = ranks;
for (int i = (0); i < (n); i++) T[i] = (int)Tin[i] + 1;
T[n] = T[n + 1] = 0;
n < 256 ? brut(n, T, sa) : ks(n, T, sa);
calcRanks(sa, n);
for (int i = 0, q = 0; i < n; i++) {
if (R[i] == n - 1) continue;
int j = sa[R[i] + 1];
while (T[i + q] == T[j + q]) q++;
lcp[R[i]] = q;
if (q != 0) q--;
}
}
} // namespace SuffixArray
char T[maxN], S[maxN];
int sum[maxN], pref[maxN], suf[maxN];
int sa[maxN], R[maxN], lcp[maxN];
void solve() {
scanf("%s", T + 1);
int n = strlen(T + 1);
for (int i = (1); i < (n + 1); i++)
sum[i] = sum[i - 1] + (T[i] == '(' ? 1 : -1);
pref[0] = suf[n + 1] = maxN;
for (int i = (1); i < (n + 1); i++) pref[i] = min(pref[i - 1], sum[i]);
for (int i = (n); i > (-1); i--) suf[i] = min(suf[i + 1], sum[i]);
copy(T + 1, T + n + 1, S);
copy(S, S + n, S + n);
SuffixArray::run(S, n * 2, sa, lcp, R);
pref[0] = 0;
int opt = maxN * 3, ind = 0;
for (int i = (1); i < (n + 1); i++) {
int mn = min(suf[i] - sum[i - 1], (sum[n] - sum[i - 1]) + pref[i - 1]);
int prop = sum[n];
if (mn < 0) prop -= mn * 2;
if (opt > prop or (opt == prop and R[i - 1] < R[ind - 1]))
opt = prop, ind = i;
}
int mn =
min(suf[ind] - sum[ind - 1], (sum[n] - sum[ind - 1]) + pref[ind - 1]);
for (int _ = (0); _ < (-mn); _++) printf("(");
printf("%s", T + ind);
T[ind] = 0;
printf("%s", T + 1);
sum[n] -= min(mn, 0);
for (int _ = (0); _ < (sum[n]); _++) printf(")");
printf("\n");
}
int main() {
int t = 1;
for (int tid = (1); tid < (t + 1); tid++) {
solve();
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
namespace lib {
static const int MAX_K = 2000005;
static const int MAX_N = 2000005;
static int bkt[MAX_K + 1];
static void setBuckets(int* s, int n, int K, bool end) {
for (int i = 0; i <= K; ++i) bkt[i] = 0;
for (int i = 0; i < n; ++i) bkt[s[i]]++;
int sum = 0;
for (int i = 0; i <= K; ++i) {
sum += bkt[i];
bkt[i] = (end ? sum : sum - bkt[i]);
}
}
static void induceSAL(const vector<bool>& t, int* SA, int* s, int n, int K,
bool end) {
setBuckets(s, n, K, end);
int j;
for (int i = 0; i < n; ++i) {
j = SA[i] - 1;
if (j >= 0 && !t[j]) SA[bkt[s[j]]++] = j;
}
}
static void induceSAS(const vector<bool>& t, int* SA, int* s, int n, int K,
bool end) {
setBuckets(s, n, K, end);
int j;
for (int i = n - 1; i >= 0; --i) {
j = SA[i] - 1;
if (j >= 0 && t[j]) SA[--bkt[s[j]]] = j;
}
}
static void SA_IS(int* s, int* SA, int n, int K) {
vector<bool> t(n);
t[n - 1] = 1;
t[n - 2] = 0;
for (int i = n - 3; i >= 0; --i) {
if (s[i] < s[i + 1] || (s[i] == s[i + 1] && t[i + 1] == 1))
t[i] = 1;
else
t[i] = 0;
}
setBuckets(s, n, K, true);
for (int i = 0; i < n; ++i) SA[i] = -1;
for (int i = 1; i < n; ++i)
if ((i > 0 && t[i] && !t[i - 1])) SA[--bkt[s[i]]] = i;
induceSAL(t, SA, s, n, K, false);
induceSAS(t, SA, s, n, K, true);
int n1 = 0;
for (int i = 0; i < n; ++i)
if ((SA[i] > 0 && t[SA[i]] && !t[SA[i] - 1])) SA[n1++] = SA[i];
for (int i = n1; i < n; ++i) SA[i] = -1;
int rank = 0, prev = -1;
for (int i = 0; i < n1; ++i) {
int pos = SA[i];
bool dif = false;
for (int d = 0; d < n; ++d) {
if (prev == -1 || s[pos + d] != s[prev + d] ||
t[pos + d] != t[prev + d]) {
dif = true;
break;
} else if (d > 0 && ((pos + d > 0 && t[pos + d] && !t[pos + d - 1]) ||
(prev + d > 0 && t[prev + d] && !t[prev + d - 1])))
break;
}
if (dif) {
++rank;
prev = pos;
}
pos >>= 1;
SA[n1 + pos] = rank - 1;
}
for (int i = n - 1, j = n - 1; i >= n1; --i)
if (SA[i] >= 0) SA[j--] = SA[i];
int *SA1 = SA, *s1 = SA + n - n1;
if (rank < n1)
SA_IS(s1, SA1, n1, rank - 1);
else
for (int i = 0; i < n1; ++i) SA1[s1[i]] = i;
setBuckets(s, n, K, true);
for (int i = 1, j = 0; i < n; ++i)
if ((i > 0 && t[i] && !t[i - 1])) s1[j++] = i;
for (int i = 0; i < n1; ++i) SA1[i] = s1[SA1[i]];
for (int i = n1; i < n; ++i) SA[i] = -1;
for (int i = n1 - 1, j; i >= 0; --i) {
j = SA[i];
SA[i] = -1;
SA[--bkt[s[j]]] = j;
}
induceSAL(t, SA, s, n, K, false);
induceSAS(t, SA, s, n, K, true);
}
static int tmp[MAX_N];
static void SA_IS(char* s, int* SA, int n) {
for (int i = 0; i < (n); ++i) tmp[i] = s[i];
SA_IS(tmp, SA, n, 260);
}
}; // namespace lib
static const int MAX_N = 2000005;
int sa[MAX_N];
char s[2000005];
int n;
int hei[2000005], nxt[2000005];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < (n); ++i) s[i + n] = s[i];
int n2 = n * 2;
hei[0] = 0;
for (int i = 0; i < (n2); ++i) {
hei[i + 1] = hei[i] + (s[i] == '(' ? 1 : -1);
}
priority_queue<pair<int, int> > pq;
for (int i = 0; i < (n2); ++i) nxt[i] = n2;
int d = hei[n];
int dif;
if (d >= 0)
dif = 0;
else
dif = -d;
for (int i = 0; i < (n2); ++i) {
while (!pq.empty() && pq.top().first > hei[i] + dif) {
nxt[pq.top().second] = i;
pq.pop();
}
pq.push(make_pair(hei[i], i));
}
lib::SA_IS(s, sa, n * 2 + 1);
string res;
int p = -1;
for (int i = 0; i < (n2 + 1); ++i) {
if (sa[i] < n && nxt[sa[i]] >= sa[i] + n) {
p = sa[i];
break;
}
}
if (d < 0)
for (int i = 0; i < (-d); ++i) res += '(';
for (int i = 0; i < (n); ++i) res += s[p + i];
if (d > 0)
for (int i = 0; i < (d); ++i) res += ')';
printf("%s\n", res.c_str());
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool getmin(T *a, const T &b) {
if (b < *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline bool getmax(T *a, const T &b) {
if (b > *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline void read(T *a) {
char c;
while (isspace(c = getchar())) {
}
bool flag = 0;
if (c == '-')
flag = 1, *a = 0;
else
*a = c - 48;
while (isdigit(c = getchar())) *a = *a * 10 + c - 48;
if (flag) *a = -*a;
}
const int mo = 1000000007;
template <class T>
T pow(T a, T b, int c = mo) {
T res = 1;
for (T i = 1; i <= b; i <<= 1, a = 1LL * a * a % c)
if (b & i) res = 1LL * res * a % c;
return res;
}
const int N = 2100000;
unsigned long long h[N];
unsigned long long e[N];
int h2[N], e2[N];
char s[N];
int n;
unsigned long long get(int x, int l) { return h[x + l - 1] - h[x - 1] * e[l]; }
int get2(int x, int l) {
return (h2[x + l - 1] - 1LL * h2[x - 1] * e2[l] % mo + mo) % mo;
}
bool cmp(int x, int y) {
int l = 1, r = n, z = 0;
if (!y) return true;
while (l <= r) {
int mid = (l + r) >> 1;
if (get(x, mid) == get(y, mid) && get2(x, mid) == get2(y, mid))
z = mid, l = mid + 1;
else
r = mid - 1;
}
return s[x + z] < s[y + z];
}
set<pair<int, int> > S;
int a[N];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = (1); i <= (n); ++i) s[n + i] = s[i];
e[0] = 1;
e2[0] = 1;
for (int i = (1); i <= (2 * n); ++i) e[i] = e[i - 1] * 1331;
for (int i = (1); i <= (2 * n); ++i) e2[i] = 1LL * e2[i - 1] * 1331 % mo;
for (int i = (1); i <= (2 * n); ++i) h[i] = h[i - 1] * 1331 + s[i];
for (int i = (1); i <= (2 * n); ++i)
h2[i] = (1LL * h2[i - 1] * 1331 % mo + s[i]) % mo;
int x = 0, y = 0;
for (int i = (1); i <= (n); ++i)
if (s[i] == '(')
a[i] = a[i - 1] + 1, ++x;
else
a[i] = a[i - 1] - 1, ++y;
for (int i = (1); i <= (n); ++i) S.insert(std::make_pair(a[i], i));
int ans = 0;
if (x > y) {
int tmp = 0;
for (int i = (1); i <= (n); ++i) {
if (S.begin()->first - tmp >= 0)
if (cmp(i, ans)) ans = i;
set<pair<int, int> >::iterator it = S.find(std::make_pair(a[i], i));
S.erase(it);
if (s[i] == '(')
++tmp;
else
--tmp;
S.insert(std::make_pair(x - y + tmp, i));
}
for (int i = (ans); i <= (ans + n - 1); ++i) putchar(s[i]);
for (int i = (1); i <= (x - y); ++i) putchar(')');
} else {
int tmp = 0;
for (int i = (1); i <= (n); ++i) {
if (S.begin()->first - tmp >= x - y)
if (cmp(i, ans)) ans = i;
set<pair<int, int> >::iterator it = S.find(std::make_pair(a[i], i));
S.erase(it);
if (s[i] == '(')
++tmp;
else
--tmp;
S.insert(std::make_pair(x - y + tmp, i));
}
for (int i = (1); i <= (y - x); ++i) putchar('(');
for (int i = (ans); i <= (ans + n - 1); ++i) putchar(s[i]);
}
cout << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 100;
int na[N], nb[N], ns[N], nv[N];
int sa[N], he[N], rk[N];
int cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void _sort(int x[N], int y[N], int n, int m) {
for (int i = 0; i < m; i++) ns[i] = 0;
for (int i = 0; i < n; i++) ns[x[y[i]]]++;
for (int i = 1; i < m; i++) ns[i] += ns[i - 1];
for (int i = n - 1; i >= 0; i--) {
sa[--ns[x[y[i]]]] = y[i];
}
}
void da(int *r, int n, int m) {
int *x = na, *y = nb;
for (int i = 0; i < n; i++) x[i] = r[i];
for (int i = 0; i < n; i++) y[i] = i;
for (int i = 0; i < m; i++) ns[i] = 0;
for (int i = 0; i < n; i++) ns[x[i] = r[i]]++;
for (int i = 1; i < m; i++) ns[i] += ns[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--ns[x[i]]] = i;
for (int j = 1, p = 1, i; p < n; j *= 2, m = p) {
for (p = 0, i = n - j; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) nv[i] = x[y[i]];
for (i = 0; i < m; i++) ns[i] = 0;
for (i = 0; i < n; i++) ns[nv[i]]++;
for (i = 1; i < m; i++) ns[i] += ns[i - 1];
for (i = n - 1; i >= 0; i--) sa[--ns[nv[i]]] = y[i];
swap(x, y);
p = 1;
x[sa[0]] = 0;
for (i = 1; i < n; i++) {
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
}
void gethe(int *r, int n) {
for (int i = 1; i <= n; i++) rk[sa[i]] = i;
for (int i = 0, k = 0, j = 0; i < n; he[rk[i++]] = k) {
for (k ? k-- : 0, j = sa[rk[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
}
void debug(int n) {
for (int i = 0; i <= n; i++) printf("%d ", rk[i]);
printf("rk\n");
for (int i = 0; i <= n; i++) printf("%d ", sa[i]);
printf("sa\n");
for (int i = 0; i <= n; i++) printf("%d ", he[i]);
printf("he\n");
}
void solve(int *r, int n) {
r[n] = 0;
da(r, n + 1, 3);
gethe(r, n);
}
int l, r, sta[N];
int aa[N], bb[N];
void ins(int id) {
while (r > l && aa[sta[r - 1]] >= aa[id]) r--;
sta[r++] = id;
}
char ss[N];
int vis[N];
int main() {
while (scanf("%s", ss) != EOF) {
int n = strlen(ss);
int num = 0;
for (int i = 0; i < n; i++) {
if (ss[i] == '(') {
aa[i] = 1;
bb[i] = 1;
num++;
} else {
aa[i] = -1;
bb[i] = 2;
num--;
}
}
for (int i = 0; i < n; i++) {
aa[i + n] = aa[i];
bb[i + n] = bb[i];
}
for (int i = 1; i < 2 * n; i++) {
aa[i] += aa[i - 1];
}
memset(vis, 0, sizeof(vis));
l = r = 0;
for (int i = 0; i < n; i++) {
ins(i);
}
for (int i = 0; i < n; i++) {
if (sta[l] < i) l++;
int x = aa[sta[l]];
if (i) x -= aa[i - 1];
if (num < 0) {
x += -num;
}
if (x >= 0) {
vis[i] = 1;
}
ins(i + n);
}
solve(bb, n * 2);
int id = -1;
for (int i = 0; i < n; i++)
if (vis[i]) {
if (id == -1 || rk[i] < rk[id]) {
id = i;
}
}
if (id == -1) {
printf("x\n");
continue;
}
for (int i = 0; i < -num; i++) {
printf("(");
}
for (int i = 0; i < n; i++) {
printf("%c", ss[id]);
id++;
if (id == n) id = 0;
}
for (int i = 0; i < num; i++) {
printf(")");
}
printf("\n");
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int best_value = 0;
void update_best(int value) {
if (value > best_value) {
best_value = value;
}
}
vector<bool> a(2000000);
vector<int> minleft(1000000);
vector<int> minright(1000000);
vector<int> b(1000000);
vector<int> increasing(1000000);
vector<int> good(1000000);
int main() {
int n = 0, z = 0;
char t;
for (;;) {
if (!(cin >> t)) {
break;
}
if (t == '(') {
z++;
} else {
a[0] = true;
n = 1;
break;
}
}
for (;; ++n) {
if (!(cin >> t)) {
break;
}
if (t == '(') {
a[n] = false;
} else {
a[n] = true;
}
}
for (int i = 0; i < z; ++i) {
a[n] = false;
n++;
}
for (int i = 0; i < n; ++i) {
a[n + i] = a[i];
}
int balance = 0, min = 0;
for (int i = 0; i < n; ++i) {
minleft[i] = min;
b[i] = balance;
if (a[i] == false) {
balance++;
} else {
balance--;
if (min > balance) {
min = balance;
}
}
}
int total = balance;
min = balance;
for (int i = n - 1; i >= 0; --i) {
minright[i] = min;
if (a[i] == false) {
balance--;
if (min > balance) {
min = balance;
}
} else {
balance++;
}
}
balance = total;
int incr = 0;
for (int i = n - 1; i >= 0; --i) {
if (a[i] == false) {
incr++;
} else {
incr = 0;
}
increasing[i] = incr;
}
if (balance <= 0) {
for (int i = 0; i < n; ++i) {
good[i] = 0;
if (minleft[i] == b[i] && minright[i] - balance >= b[i]) {
update_best(increasing[i]);
good[i] = 1;
}
}
} else {
if (minright[0] >= 0) {
update_best(increasing[0]);
good[0] = 1;
}
for (int i = 0; i < n - 1; ++i) {
good[i + 1] = 0;
if (minright[i] == b[i + 1] && b[i + 1] - balance <= minleft[i]) {
update_best(increasing[i + 1]);
good[i + 1] = 1;
}
}
}
int first = -1, second = -1;
for (int i = 0; i < n; ++i) {
if (increasing[i] == best_value && good[i] == 1) {
if (first == -1) {
first = i;
} else if (second == -1) {
second = i;
}
} else {
good[i] = 0;
}
}
if (first == -1) return 1;
if (second != -1) {
int len = best_value;
while (true) {
do {
if (first + len == second || second + len == first) {
break;
}
len++;
} while (a[first + len] == a[second + len]);
if (second + len == first) {
swap(first, second);
} else if (a[first + len] == true) {
swap(first, second);
}
second += len;
len = best_value;
while (second < n && (good[second] == 0 || second == first)) {
second++;
}
if (second >= n) {
break;
}
}
}
int best_position = first;
if (balance <= 0) {
for (int i = 0; i < -balance; ++i) {
cout << "(";
}
}
for (int i = best_position; i < n; ++i) {
cout << (a[i] == false ? "(" : ")");
}
for (int i = 0; i < best_position; ++i) {
cout << (a[i] == false ? "(" : ")");
}
if (balance > 0) {
for (int i = 0; i < balance; ++i) {
cout << ")";
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct H {
long long a, b;
H(long long a = 1, long long b = 1) : a(a), b(b) {}
H operator*(long long x) { return H(a * x, b * x % 1000000007); }
H operator*(H h) { return H(a * h.a, b * h.b % 1000000007); }
H operator+(H h) { return H(a + h.a, (b + h.b) % 1000000007); }
H operator-(H h) { return H(a - h.a, (b - h.b + 1000000007) % 1000000007); }
bool operator==(H h) { return a == h.a && b == h.b; }
};
int n;
string s;
H p[2 * 1000010], h[2 * 1000010];
int pre[1000010], suf[1000010];
int pmn[1000010], smx[1000010];
H get(int a, int len) {
H res = h[a + len - 1];
if (a > 0) res = res - h[a - 1];
return res;
}
bool equal(int a, int b, int len) {
if (a < b) swap(a, b);
H ha = get(a, len);
H hb = get(b, len) * p[a - b];
return ha == hb;
}
bool test(int a, int b) {
int lo = 0, hi = n + 1, mid;
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (equal(a, b, mid))
lo = mid;
else
hi = mid;
}
if (lo == n) return 0;
return s[a + lo] < s[b + lo];
}
int main() {
ios::sync_with_stdio(0);
p[0] = H();
for (int i = 1; i < 2 * 1000010; i++) p[i] = p[i - 1] * 17;
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) pre[i] = suf[i] = s[i] == '(' ? 1 : -1;
for (int i = 1; i < n; i++) pre[i] += pre[i - 1];
for (int i = n - 2; i >= 0; i--) suf[i] += suf[i + 1];
pmn[0] = 1000010;
for (int i = 1; i < n; i++) {
pmn[i] = min(pmn[i - 1], pre[i - 1] + pre[n - 1]);
}
for (int i = n - 1, x = 1000010; i >= 0; i--) {
x = min(x, pre[i]);
pmn[i] = min(pmn[i], x);
}
smx[n] = -1000010;
for (int i = n - 1; i >= 0; i--) {
smx[i] = max(smx[i + 1], suf[i] + suf[0]);
}
for (int i = 1, x = -1000010; i < n; i++) {
x = max(x, suf[i - 1]);
smx[i] = max(smx[i], x);
}
for (int i = 1; i < n; i++) pmn[i] -= pre[i - 1];
for (int i = n - 1; i >= 0; i--) smx[i] -= suf[i];
s = s + s;
for (int i = 0; i < n + n; i++) {
h[i] = p[i] * (s[i] - '(');
if (i > 0) h[i] = h[i] + h[i - 1];
}
int a = -1;
for (int i = 0; i < n; i++) {
if (suf[0] >= 0 && pmn[i] < 0) continue;
if (suf[0] <= 0 && smx[i] > 0) continue;
if (a < 0 || test(i, a)) a = i;
}
for (int i = 0; i < -suf[0]; i++) cout << '(';
for (int i = 0; i < n; i++) cout << s[a + i];
for (int i = 0; i < suf[0]; i++) cout << ')';
cout << '\n';
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ans, mini, N, lg, dp[22][1000009], s[2000009], pos[1000009];
char sir[2000009];
pair<pair<int, int>, int> A[2000009];
deque<int> dq;
int main() {
gets(sir + 1), N = strlen(sir + 1), ans = -1;
for (int i = N + 1; i <= 2 * N; i++) sir[i] = sir[i - N];
for (int i = 1; i <= 2 * N; i++) {
s[i] = s[i - 1];
if (sir[i] == '(')
s[i]++;
else
s[i]--;
if (s[i] < mini && i < N) mini = s[i];
}
for (int i = 1; i <= N; i++)
dp[0][i] = sir[i], A[i] = make_pair(make_pair(0, 0), i);
for (int i = 1; (1 << (i - 1)) <= N; i++) {
int P = (1 << (i - 1));
for (int j = 1; j <= N; j++) {
int k = A[j].second;
A[j].first.first = dp[i - 1][k];
if (k + P <= N)
A[j].first.second = dp[i - 1][k + P];
else
A[j].first.second = dp[i - 1][k + P - N];
}
sort(A + 1, A + N + 1);
for (int j = 1; j <= N; j++)
dp[i][A[j].second] =
dp[i][A[j - 1].second] + (j == 1 || A[j].first != A[j - 1].first);
}
for (int i = 1; i <= N; i++) pos[A[i].second] = i;
int Konst = 0;
if (s[N] < 0) Konst = s[N];
int j = 0;
for (int i = 0; i < N; i++) {
while (j <= i + N) {
while (!dq.empty() && s[dq.back()] >= s[j]) dq.pop_back();
dq.push_back(j);
while (dq.front() <= j - N) dq.pop_front();
j++;
}
if (s[dq.front()] - s[i] >= Konst) {
if (ans == -1)
ans = i + 1;
else {
if (pos[i + 1] < pos[ans]) ans = i + 1;
}
}
}
while (s[N] < 0) printf("("), s[N]++;
for (int i = ans; i <= N + ans - 1; i++) printf("%c", sir[i]);
while (s[N] > 0) printf(")"), s[N]--;
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 4000010;
inline int read() {
int x = 0;
int f = 0, c = getchar();
for (; c > '9' || c < '0'; f = c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 3) + (x << 1) + c - '0';
return f ? -x : x;
}
struct cqz {
int i, x, y;
cqz(int a = 0, int b = 0, int c = 0) {
i = a;
x = b;
y = c;
}
} a[N];
inline bool operator<(const cqz& i, const cqz& j) {
return i.x < j.x || (i.x == j.x && i.y < j.y);
}
inline bool operator!=(const cqz& i, const cqz& j) {
return i.x != j.x || i.y != j.y;
}
char s[N];
int sta[N], top, p[N];
int n, m, rk[N], sm, sl, sr, ans, flag;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
m = n;
register int i, j, k;
for (i = 1; i <= n; i++) s[i + n] = s[i];
for (i = 1; i <= n; i++) rk[i] = s[i];
for (k = 1; k < n; k <<= 1) {
for (i = 1; i <= n; i++) a[i] = cqz(i, rk[i], rk[(i + k - 1) % n + 1]);
sort(a + 1, a + n + 1);
for (i = j = 1; i <= n; i++) rk[a[i].i] = j, j += a[i + 1] != a[i];
if (j > n) break;
}
n = n + n;
for (i = n - 1; i > m; i--)
if (s[i] == '(') {
if (sl)
sm++, sl--;
else
sr++;
} else
sl++;
k = 1e9;
for (i = 1; i <= n; i++)
if (s[i] == '(')
sta[++top] = i;
else {
p[i] = sta[top];
if (top) top--;
}
for (i = m; i; i--) {
if (s[i] == '(') {
if (sl)
sm++, sl--;
else
sr++;
} else
sl++;
if (!sl || !sr) {
flag = sl - sr;
if (rk[i] < k) ans = i, k = rk[i];
}
if (s[i + m - 1] == '(')
sr--;
else {
if (p[i + m - 1] > i)
sm--, sr++;
else
sl--;
}
}
if (flag > 0)
while (flag) putchar('('), flag--;
for (i = 0; i < m; i++) putchar(s[ans + i]);
if (flag < 0)
while (flag++) putchar(')');
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000000 + 5;
int n, gs[maxn], sa[maxn], wb[maxn], wv[maxn], ran[maxn], sum[maxn], pre[maxn],
suf[maxn];
char s[maxn];
inline int check(char a) {
if (a == '(') return 1;
if (a == ')') return -1;
}
inline bool cmp(int *x, int a, int b, int l) {
return x[a] == x[b] && x[a + l] == x[b + l];
}
inline void da(int *sa, int *x, int n, int m) {
int i, j, p, *y = wb;
for (i = 0; i < m; i++) gs[i] = 0;
for (i = 0; i < n; i++) gs[x[i]]++;
for (i = 1; i < m; i++) gs[i] += gs[i - 1];
for (i = n - 1; ~i; i--) sa[--gs[x[i]]] = i;
for (j = 1, p = 1; p < n; j <<= 1, m = p) {
for (i = n - j, p = 0; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) wv[i] = x[y[i]];
for (i = 0; i < m; i++) gs[i] = 0;
for (i = 0; i < n; i++) gs[wv[i]]++;
for (i = 1; i < m; i++) gs[i] += gs[i - 1];
for (i = n - 1; ~i; i--) sa[--gs[wv[i]]] = y[i];
p = 1;
swap(x, y);
x[sa[0]] = 0;
for (i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i], sa[i - 1], j) ? p - 1 : p++;
}
}
signed main(void) {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) ran[i] = (int)s[i];
for (int i = n; i < 2 * n; i++) ran[i] = (int)s[i - n], s[i] = s[i - n];
da(sa, ran, 2 * n + 1, 47);
for (int i = 0; i < n; i++) sum[i] = sum[i - 1] + check(s[i]);
pre[0] = sum[0];
for (int i = 1; i < n; i++) pre[i] = min(pre[i - 1], sum[i]);
suf[n - 1] = sum[n - 1];
for (int i = n - 2; i >= 0; i--) suf[i] = min(suf[i + 1], sum[i]);
for (int i = 1; i <= 2 * n; i++)
if (sa[i] < n) {
int tmp = min(suf[sa[i]] - sum[sa[i] - 1],
sum[n - 1] - sum[sa[i] - 1] + pre[sa[i] - 1]);
if (sum[n - 1] >= 0 && tmp >= 0) {
for (int j = 0; j < n; j++) printf("%c", s[sa[i] + j]);
for (int j = 0; j < sum[n - 1]; j++) printf(")");
puts("");
break;
}
tmp = min(sum[n - 1] - sum[sa[i] - 1] + pre[sa[i] - 1] - sum[n - 1],
suf[sa[i]] - sum[sa[i] - 1] - sum[n - 1]);
if (sum[n - 1] < 0 && tmp >= 0) {
for (int j = 0; j < -sum[n - 1]; j++) printf("(");
for (int j = 0; j < n; j++) printf("%c", s[sa[i] + j]);
puts("");
break;
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000000 + 5;
int wa[N], wb[N], wc[N], wv[N];
bool cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void da(int *r, int *sa, int n, int m) {
int *x = wa, *y = wb;
for (int i = 0; i < m; i++) wc[i] = 0;
for (int i = 0; i < n; i++) wc[x[i] = r[i]]++;
for (int i = 1; i < m; i++) wc[i] += wc[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--wc[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < n; i++) wv[i] = x[y[i]];
for (int i = 0; i < m; i++) wc[i] = 0;
for (int i = 0; i < n; i++) wc[wv[i]]++;
for (int i = 1; i < m; i++) wc[i] += wc[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--wc[wv[i]]] = y[i];
int *t = x;
x = y;
y = t;
p = 1;
x[sa[0]] = 0;
for (int i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
void calheight(int *r, int *sa, int *rk, int *height, int n) {
for (int i = 1; i <= n; i++) rk[sa[i]] = i;
int k = 0;
for (int i = 0; i < n; height[rk[i++]] = k) {
if (k) k--;
for (int j = sa[rk[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
}
int rq[N][22], Log[N];
void build_rmq(int *a, int n) {
for (int i = 0; i < n; i++) rq[i][0] = a[i];
for (int j = 1; j < 21; j++) {
for (int i = 0; i + (1 << j) - 1 < n; i++)
rq[i][j] = min(rq[i][j - 1], rq[i + (1 << j - 1)][j - 1]);
}
int cr = 0;
for (int i = 1; i <= n; i++) {
if ((1 << cr + 1) <= i) cr++;
Log[i] = cr;
}
}
int query_rmq(int l, int r) {
int k = Log[r - l + 1];
return min(rq[l][k], rq[r - (1 << k) + 1][k]);
}
char s[N];
int a[N], sa[N], rk[N], height[N];
int sum[N];
int n;
bool check(int id, int need) {
int pre = 0;
if (id > 0) pre = sum[id - 1];
int mn = query_rmq(id, id + n - 1);
if (need < 0) mn -= need;
return mn >= pre;
}
void solve() {
n = strlen(s);
for (int i = 0; i < n; i++) {
a[i] = s[i] == '(' ? 1 : 2;
}
for (int i = n; i < n << 1; i++) a[i] = a[i - n];
a[n << 1] = 0;
da(a, sa, n << 1 | 1, 3);
calheight(a, sa, rk, height, n << 1);
sum[0] = a[0] == 1 ? 1 : -1;
for (int i = 1; i < (n << 1); i++) sum[i] = sum[i - 1] + (a[i] == 1 ? 1 : -1);
build_rmq(sum, n << 1);
int need = sum[n - 1];
int ans = -1;
for (int i = 0; i < n; i++) {
if (check(i, need)) {
if (ans == -1 || rk[ans] > rk[i]) {
ans = i;
}
}
}
if (need < 0) {
for (int i = 0; i < -need; i++) printf("(");
for (int i = 0; i < n; i++) {
if (a[i + ans] > 1)
printf(")");
else
printf("(");
}
puts("");
} else {
for (int i = 0; i < n; i++) {
if (a[i + ans] > 1)
printf(")");
else
printf("(");
}
for (int i = 0; i < need; i++) printf(")");
puts("");
}
}
int main() {
scanf("%s", s);
solve();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int m;
char s[2000100];
int a[2000100], pre[2000100], suf[2000100];
int sa[2000100], rnk[2000100], lcp[2000100], cnt[2000100];
void build(char *s) {
int n = strlen(s) + 1, m = 256;
int *x = rnk, *y = lcp, *z;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i] = s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[y[i]]]] = y[i];
z = x, x = y, y = z;
x[sa[0]] = 0, p = 1;
for (int i = 1; i < n; i++) {
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + j] == y[sa[i - 1] + j])
? p - 1
: p++;
}
}
}
int main() {
scanf("%s", s + 1);
m = strlen(s + 1);
for (int i = 1; i <= m; i++) a[i] = a[i - 1] + (s[i] == '(' ? 1 : -1);
pre[0] = 2000100;
for (int i = 1; i <= m; i++) pre[i] = min(pre[i - 1], a[i]);
suf[m + 1] = 2000100;
for (int i = m; i >= 0; i--) suf[i] = min(suf[i + 1], a[i]);
for (int i = 1; i <= m; i++) s[m + i] = s[i];
build(s + 1);
for (int i = 0; i <= 2 * m; i++)
if (sa[i] < m) {
int j = sa[i] + 1;
bool ok = 0;
if (a[m] >= 0) {
if (min(suf[j], a[m] + pre[j - 1]) >= a[j - 1]) {
ok = 1;
}
} else {
if (min(-a[m] + suf[j], pre[j - 1]) >= a[j - 1]) {
ok = 1;
}
}
if (ok) {
rotate(s + 1, s + j, s + m + 1);
s[m + 1] = 0;
if (a[m] >= 0) {
printf("%s", s + 1);
while (a[m]--) putchar(')');
} else {
a[m] = -a[m];
while (a[m]--) putchar('(');
printf("%s", s + 1);
}
return 0;
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const long long md = 1e9 + 7;
int need[N], reduce[N];
long long st[N], head[N], tail[N], sdfsdfsd[N];
int n;
string s;
struct candidate {
int start, headLen, tailLen;
candidate() {}
candidate(int start, int headLen, int tailLen)
: start(start), headLen(headLen), tailLen(tailLen) {}
};
long long getSuperHash(int l, int r) {
if (l == 0 && r == n - 1) {
return sdfsdfsd[l];
}
if (l < n && r >= n) {
return (sdfsdfsd[l] + sdfsdfsd[r] * st[n - l]) % md;
}
if (l >= n) {
l -= n;
r -= n;
}
if (r == n - 1) {
return sdfsdfsd[l];
}
r++;
long long res = (sdfsdfsd[l] - sdfsdfsd[r] * st[r - l]) % md;
return (res + md) % md;
}
long long getHash(candidate i, int len) {
if (len <= i.headLen) {
return head[len];
}
long long res = head[i.headLen];
len -= i.headLen;
if (len <= n) {
return (res + getSuperHash(i.start, i.start + len - 1) * st[i.headLen]) %
md;
}
res += getSuperHash(i.start, i.start + n - 1) * st[i.headLen];
res %= md;
len -= n;
return (res + st[n + i.headLen] * tail[len]) % md;
}
char compare(candidate last, candidate cur) {
int l = 0, r = n + cur.headLen + cur.tailLen;
if (getHash(last, r) == getHash(cur, r)) {
return true;
}
while (l + 1 < r) {
int len = (l + r) / 2;
(getHash(last, len) == getHash(cur, len) ? l : r) = len;
}
int p = getHash(last, r) == getHash(cur, r) ? r : l;
if (p < last.headLen) {
return true;
}
p -= last.headLen;
assert(p < n + last.tailLen);
return p < n ? s[last.start + p] == '(' : false;
}
int main() {
st[0] = 1;
for (int i = 1; i < N; i++) {
st[i] = st[i - 1] * 239 % md;
head[i] = (head[i - 1] + st[i]) % md;
tail[i] = (tail[i - 1] + st[i] * 2) % md;
}
getline(cin, s);
n = s.length();
s += s;
need[n - 1] = s[n - 1] == ')';
reduce[n - 1] = s[n - 1] == '(';
sdfsdfsd[n - 1] = s[n - 1] - '(' + 1;
need[n] = s[n] == ')';
reduce[n] = s[n] == '(';
sdfsdfsd[n] = s[n] - '(' + 1;
for (int i = n - 2; i >= 0; i--) {
need[i] = s[i] == ')';
reduce[i] = s[i] == '(';
int take = min(reduce[i], need[i + 1]);
need[i] = need[i] + need[i + 1] - take;
reduce[i] = reduce[i] + reduce[i + 1] - take;
sdfsdfsd[i] = (s[i] - '(' + 1 + sdfsdfsd[i + 1] * st[1]) % md;
}
for (int i = n + 1; i < n * 2; i++) {
need[i] = s[i] == ')';
reduce[i] = s[i] == '(';
int take = min(reduce[i - 1], need[i]);
need[i] = need[i] + need[i - 1] - take;
reduce[i] = reduce[i] + reduce[i - 1] - take;
sdfsdfsd[i] = (sdfsdfsd[i - 1] + st[i - n] * (s[i] - '(' + 1)) % md;
}
int minCost = need[0] + reduce[0];
vector<candidate> c;
c.emplace_back(0, need[0], reduce[0]);
for (int l = 1, r = n; l < n; l++, r++) {
int take = min(reduce[l], need[r]), need, reduce;
need = ::need[l] + ::need[r] - take;
reduce = ::reduce[l] + ::reduce[r] - take;
if (need + reduce > minCost) {
continue;
}
if (need + reduce < minCost) {
c.clear();
}
minCost = need + reduce;
c.emplace_back(l, need, reduce);
}
for (candidate i : c)
if (!compare(c[0], i)) {
c[0] = i;
}
while (c[0].headLen--) {
printf("(");
}
for (int i = 0; i < n; i++) {
printf("%c", s[i + c[0].start]);
}
while (c[0].tailLen--) {
printf(")");
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug;
const int inf = 1e9 + 5;
const long long INF = (long long)inf * inf;
const int nax = 1e6 + 5;
const int D = 5;
const long long MM = 1000 * 1000 * 1000;
const long long m[D] = {MM + 7, MM + 9, MM + 21, MM + 33, 333333361LL};
char sl[nax];
long long preh[nax][D];
int n;
long long potega[nax][D];
long long h(pair<int, int> a, int j) {
long long x = preh[a.second][j];
if (a.first) x -= preh[a.first - 1][j];
if (x < 0) x += m[j];
x = (x * potega[n - a.first][j]) % m[j];
return x;
}
bool rowne(pair<int, int> a, pair<int, int> b) {
for (int j = 0; j <= (D)-1; ++j)
if (h(a, j) != h(b, j)) return false;
return true;
}
int porow(pair<int, int> a, pair<int, int> b) {
assert(a.second - a.first == b.second - b.first);
if (a.first > a.second) return true;
if (rowne(a, b)) return 1;
int low = 0, high = a.second - a.first;
while (low != high) {
int med = (low + high) / 2;
if (rowne(make_pair(a.first, a.first + med),
make_pair(b.first, b.first + med)))
low = med + 1;
else
high = med;
}
if (sl[a.first + low] == '(') return 0;
return 2;
}
int pref[nax];
int LICZ;
const int pot = 1024 * 1024;
int tr[2 * pot];
int mi(int a, int b) {
a += pot;
b += pot;
int ku = min(tr[a], tr[b]);
while (a < b - 1) {
ku = min(ku, tr[a + 1]);
ku = min(ku, tr[b - 1]);
a /= 2;
b /= 2;
}
return ku;
}
bool ok_podzial_szybkie(int i) {
int s1 = pref[i];
int s2 = LICZ - pref[i];
int k = 0;
if (LICZ < 0) k = -LICZ;
if (i + 1 <= n - 1 && k + mi(i + 1, n - 1) - s1 < 0) return false;
if (0 <= i && k + s2 + mi(0, i) < 0) return false;
return true;
}
bool ok_podzial(int i) {
int teraz = 0;
if (LICZ < 0) teraz = -LICZ;
for (int j = i + 1; j <= n - 1; ++j) {
if (sl[j] == '(')
++teraz;
else
--teraz;
if (teraz < 0) return false;
}
for (int j = 0; j <= i; ++j) {
if (sl[j] == '(')
++teraz;
else
--teraz;
if (teraz < 0) return false;
}
return true;
}
int best = -1;
bool jebaj(int i) {
if (best == -1) return true;
int kon = best + 1 + (n - 1 - (i + 1));
int pom = porow(make_pair(best + 1, kon), make_pair(i + 1, n - 1));
if (pom == 0) return false;
if (pom == 2) return true;
int kon2 = n - 1 - (kon + 1);
pom = porow(make_pair(kon + 1, n - 1), make_pair(0, kon2));
if (pom == 0) return false;
if (pom == 2) return true;
pom = porow(make_pair(0, best), make_pair(kon2 + 1, i));
if (pom == 0) return false;
return true;
}
int main(int argc, char *argv[]) {
debug = argc > 1;
scanf("%s", sl);
n = strlen(sl);
for (int i = 0; i <= (n)-1; ++i) {
if (i) pref[i] = pref[i - 1];
if (sl[i] == '(')
pref[i]++;
else
pref[i]--;
}
for (int i = 0; i <= (2 * pot) - 1; ++i) tr[i] = inf;
for (int i = 0; i <= (n)-1; ++i) tr[pot + i] = pref[i];
for (int i = pot - 1; i >= 1; --i) tr[i] = min(tr[2 * i], tr[2 * i + 1]);
LICZ = 0;
for (int i = 0; i <= (n)-1; ++i) {
if (sl[i] == '(')
++LICZ;
else
--LICZ;
}
for (int j = 0; j <= (D)-1; ++j) {
potega[0][j] = 1;
for (int i = 1; i <= n; ++i)
potega[i][j] = ((j == 2 ? 3 : 2) * potega[i - 1][j]) % m[j];
}
for (int j = 0; j <= (D)-1; ++j)
for (int i = 0; i <= (n)-1; ++i) {
int teraz = int(sl[i] == '(');
preh[i][j] = ((i ? preh[i - 1][j] : 0LL) + teraz * potega[i][j]) % m[j];
}
for (int i = 0; i <= (n)-1; ++i)
if (ok_podzial_szybkie(i))
if (jebaj(i)) best = i;
assert(best != -1);
if (LICZ < 0)
for (int _ = 0; _ <= (-LICZ) - 1; ++_) printf("(");
for (int j = best + 1; j <= n - 1; ++j) printf("%c", sl[j]);
for (int j = 0; j <= best; ++j) printf("%c", sl[j]);
if (LICZ > 0)
for (int _ = 0; _ <= (LICZ)-1; ++_) printf(")");
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
char str[MAXN];
int N, A, B;
int seq[MAXN];
int sum_pf[MAXN], sum_sf[MAXN];
int low_pf[MAXN], low_sf[MAXN];
bool elig[MAXN];
template <typename T = char>
struct SuffixArray {
int str[MAXN * 6], sa[MAXN * 6], rank[MAXN * 2], height[MAXN * 2], sz;
int wa[MAXN * 2], wb[MAXN * 2], wv[MAXN * 2], ws[MAXN * 2];
int &operator[](int k) { return sa[k]; }
int size() const { return sz; }
bool eq(const int *r, int a, int b) const {
return r[a] == r[b] && r[a + 1] == r[b + 1] && r[a + 2] == r[b + 2];
}
bool cmp(const int *r, int a, int b, int d) const {
if (d == 1) return (r[a] < r[b]) || (r[a] == r[b] && wv[a + 1] < wv[b + 1]);
return (r[a] < r[b]) || (r[a] == r[b] && cmp(r, a + 1, b + 1, 1));
}
void rsort(const int *r, const int *a, int *b, int n, int m) {
int i;
fill(ws, ws + m, 0);
for (i = 0; i < n; ++i) ++ws[wv[i] = r[a[i]]];
for (i = 1; i < m; ++i) ws[i] += ws[i - 1];
for (i = n - 1; ~i; --i) b[--ws[wv[i]]] = a[i];
}
void dc3(int *r, int *sa, int n, int m) {
int i, j, k, *rn = r + n, *san = sa + n, tx = 0, ty = (n + 1) / 3, tz = 0;
r[n] = r[n + 1] = 0;
for (i = 0; i < n; ++i) {
if (i % 3) wa[tz++] = i;
}
rsort(r + 2, wa, wb, tz, m);
rsort(r + 1, wb, wa, tz, m);
rsort(r, wa, wb, tz, m);
for (rn[((wb[0]) / 3 + ((wb[0]) % 3 == 1 ? 0 : ty))] = 0, k = i = 1; i < tz;
++i) {
rn[((wb[i]) / 3 + ((wb[i]) % 3 == 1 ? 0 : ty))] =
eq(r, wb[i - 1], wb[i]) ? k - 1 : k++;
}
if (k < tz)
dc3(rn, san, tz, k);
else {
for (i = 0; i < tz; ++i) san[rn[i]] = i;
}
for (i = 0; i < tz; ++i) {
if (san[i] < ty) wb[tx++] = san[i] * 3;
}
if (n % 3 == 1) wb[tx++] = n - 1;
rsort(r, wb, wa, tx, m);
for (i = 0; i < tz; ++i)
wv[wb[i] = ((san[i]) < ty ? (san[i]) * 3 + 1 : ((san[i]) - ty) * 3 + 2)] =
i;
for (i = j = k = 0; i < tx && j < tz; ++k) {
sa[k] = cmp(r, wa[i], wb[j], wb[j] % 3) ? wa[i++] : wb[j++];
}
for (; i < tx; ++i) sa[k++] = wa[i];
for (; j < tz; ++j) sa[k++] = wb[j];
}
void build(const T *s, int n, int m = 128) {
int i;
for (i = 0; i < n; ++i) str[i] = (int)s[i];
str[n] = 0;
sz = n + 1;
dc3(str, sa, sz, m);
}
void calHeight() {
int i, j, k = 0;
for (i = 0; i < sz; ++i) rank[sa[i]] = i;
for (i = 0; i < sz; height[rank[i++]] = k) {
for (k ? --k : 0, j = sa[rank[i] - 1]; str[i + k] == str[j + k]; ++k)
;
}
}
};
SuffixArray<> sa;
char s[MAXN * 6];
int n;
int main(int argc, char *argv[]) {
scanf(" %s", str + 1);
N = strlen(str + 1);
for (int i = 1; i <= N; i++) {
seq[i] = (str[i] == '(') ? 1 : -1;
if (seq[i] > 0)
A++;
else
B++;
}
int cur = 0;
for (int i = 1; i <= N; i++) {
sum_pf[i] = seq[i] + sum_pf[i - 1];
cur += seq[i];
low_pf[i] = min(low_pf[i - 1], cur);
}
cur = 0;
for (int i = N; i >= 1; i--) {
sum_sf[i] = -seq[i] + sum_sf[i + 1];
cur -= seq[i];
low_sf[i] = min(low_sf[i + 1], cur);
}
for (int i = 1; i <= N; i++) {
low_sf[i] -= sum_sf[i];
}
for (int i = 1; i < N; i++) {
if (A >= B) {
if (low_sf[i + 1] >= 0 && (-sum_sf[i + 1]) + low_pf[i] >= 0) {
elig[i] = true;
} else {
elig[i] = false;
}
} else {
if (B - A + low_sf[i + 1] >= 0 &&
B - A + (-sum_sf[i + 1]) + low_pf[i] >= 0) {
elig[i] = true;
} else {
elig[i] = false;
}
}
}
if (low_pf[N] >= 0) elig[N] = true;
n = 2 * N;
for (int i = 1; i <= N; i++) {
s[i - 1] = s[i - 1 + N] = (str[i] == '(') ? 'a' : 'b';
}
s[n] = 0;
sa.build(s, n);
sa.calHeight();
int mir = 0x3f3f3f3f, miri = 0;
for (int i = 1; i <= N; i++) {
if (elig[i] && sa.rank[i] < mir) {
mir = sa.rank[i];
miri = i;
}
}
for (int i = 1; i <= B - A; i++) {
putchar('(');
}
for (int i = miri + 1; i <= N; i++) {
putchar(str[i]);
}
for (int i = 1; i <= miri; i++) {
putchar(str[i]);
}
for (int i = 1; i <= A - B; i++) {
putchar(')');
}
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("tony_stark", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const int N = (int)1e6 + 7;
string s;
int n, f[N], c[N], ord[N];
struct T {
int i;
int c1;
int c2;
};
vector<T> so(vector<T> v) {
int n = (int)v.size();
for (int i = 0; i <= n; i++) {
f[i] = 0;
}
for (int i = 0; i < n; i++) {
f[v[i].c2]++;
}
for (int i = 1; i <= n; i++) {
f[i] += f[i - 1];
}
vector<T> v2(n);
for (int i = n - 1; i >= 0; i--) {
v2[--f[v[i].c2]] = v[i];
}
for (int i = 0; i <= n; i++) {
f[i] = 0;
}
for (int i = 0; i < n; i++) {
f[v2[i].c1]++;
}
for (int i = 1; i <= n; i++) {
f[i] += f[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
v[--f[v2[i].c1]] = v2[i];
}
return v;
}
bool operator<(T a, T b) {
if (a.c1 != b.c1) {
return a.c1 < b.c1;
} else {
return a.c2 < b.c2;
}
}
int baltotal, a[N], sum[N], pre[N], suf[N];
signed realMain() {
cin >> s;
n = (int)s.size();
int raz = -1;
for (int i = 1; i <= n; i++) {
if (s[i - 1] == '(')
baltotal++;
else
baltotal--;
a[i] = (s[i - 1] == '(') ? +1 : -1;
sum[i] = sum[i - 1] + a[i];
}
pre[1] = sum[1];
for (int i = 2; i <= n; i++) {
pre[i] = min(pre[i - 1], sum[i]);
}
suf[n] = sum[n];
for (int i = n - 1; i >= 1; i--) {
suf[i] = min(suf[i + 1], sum[i]);
}
for (int i = 0; i < n; i++) {
c[i] = s[i];
f[c[i]]++;
}
for (int i = 1; i < N; i++) {
f[i] += f[i - 1];
}
for (int i = 0; i < n; i++) {
ord[--f[c[i]]] = i;
}
map<int, int> trn;
for (int i = 0; i < n; i++) {
trn[c[i]] = 0;
}
int curtrn = 0;
for (auto &it : trn) {
it.second = curtrn++;
}
for (int i = 0; i < n; i++) {
c[i] = trn[c[i]];
}
for (int len = 1; len <= n; len *= 2) {
vector<T> v;
for (int i = 0; i < n; i++) {
v.push_back({i, c[i], c[(i + len) % n]});
}
v = so(v);
for (int i = 0; i < n; i++) {
ord[i] = v[i].i;
}
c[v[0].i] = 0;
for (int i = 1; i < n; i++) {
c[v[i].i] = c[v[i - 1].i] + (v[i - 1] < v[i]);
}
}
for (int j = 0; j < n; j++) {
bool ok = 1;
int cur = max(0, -baltotal), init = cur;
if (j + 1 <= n && cur + suf[j + 1] - sum[j] < 0) {
ok = 0;
}
cur = init + sum[n] - sum[j];
if (j && cur + pre[j] < 0) {
ok = 0;
}
if (!ok) {
continue;
}
if (raz == -1 || c[j] < c[raz]) {
raz = j;
}
}
while (baltotal < 0) {
cout << "(";
baltotal++;
}
for (int i = 0; i < n; i++) {
cout << s[(i + raz) % n];
}
while (baltotal > 0) {
cout << ")";
baltotal--;
}
cout << "\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000010;
int N, OOP[MAXN], OP[MAXN], FS[MAXN], FMN[MAXN], BS[MAXN], BMN[MAXN];
string B;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> B;
N = ((int)B.size());
int open = 0, close = 0;
for (int i = 0; i < N; i++) {
if (B[i] == '(') {
++open;
} else {
++close;
}
if (i > 0) {
FS[i] = FS[i - 1];
}
if (B[i] == '(') {
++FS[i];
} else {
--FS[i];
}
FMN[i] = FS[i];
if (i > 0) {
FMN[i] = min(FMN[i - 1], FMN[i]);
}
}
for (int i = N - 1; i >= 0; i--) {
BS[i] = BS[i + 1];
BMN[i] = BMN[i + 1];
if (B[i] == '(') {
++BS[i];
++BMN[i];
} else {
--BS[i];
BMN[i] = min(BMN[i] - 1, -1);
}
}
B += B;
for (int i = ((int)B.size()) - 1; i >= 0; i--) {
OP[i] = OP[i + 1];
if (B[i] == '(') {
++OP[i];
} else {
OP[i] = 0;
}
}
int rot = -1;
for (int i = 0; i < N;) {
int fsum = 0, fmin = 0;
if (i > 0) {
fsum = FS[i - 1];
fmin = FMN[i - 1];
}
int bsum = BS[i];
int bmin = BMN[i];
if (open > close) {
if (bsum + fmin < 0 || bmin < 0) {
++i;
continue;
}
} else if (open < close) {
if (bsum + close - open + fmin < 0 || bmin + close - open < 0) {
++i;
continue;
}
} else {
if (bsum + fmin < 0 || bmin < 0) {
++i;
continue;
}
}
if (rot == -1) {
rot = i;
++i;
continue;
}
if (OP[i] > OP[rot]) {
rot = i;
++i;
} else if (OP[i] == OP[rot]) {
bool v = false;
for (int j = 1; rot + j < i; j++) {
if (OP[rot + j] < OP[i + j]) {
rot = i;
i += j;
v = true;
break;
} else if (OP[rot + j] > OP[i + j]) {
i += j;
v = true;
break;
}
}
if (!v) {
i += i - rot;
}
} else {
++i;
}
}
if (open > close) {
for (int i = rot; i < N; i++) {
cout << B[i];
}
for (int i = 0; i < rot; i++) {
cout << B[i];
}
for (int i = 0; i < open - close; i++) {
cout << ')';
}
} else if (open < close) {
for (int i = 0; i < close - open; i++) {
cout << '(';
}
for (int i = rot; i < N; i++) {
cout << B[i];
}
for (int i = 0; i < rot; i++) {
cout << B[i];
}
} else {
for (int i = rot; i < N; i++) {
cout << B[i];
}
for (int i = 0; i < rot; i++) {
cout << B[i];
}
}
cout << '\n';
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int L = 1000010;
char ch[L + L] = {};
int len, l, m = 127;
int u1[L + L] = {}, u2[L + L] = {}, *x = u1, *y = u2;
int t[L + L] = {}, sa[L + L] = {}, ans[L + L] = {}, s[L + L] = {};
bool can[L + L] = {};
void init() {
gets(ch + 1);
len = strlen(ch + 1);
for (int i = 1; i <= len; ++i) ch[len + i] = ch[i];
l = len << 1;
ch[0] = ch[len];
}
inline bool cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void work() {
for (int i = 1; i <= l; ++i) ++t[x[i] = ch[i]];
for (int i = 1; i <= m; ++i) t[i] += t[i - 1];
for (int i = l; i >= 1; --i) sa[t[x[i]]--] = i;
for (int j = 1, p = 0; j <= l && p != l; m = p, j *= 2, p = 0) {
for (int i = l - j + 1; i <= l; ++i) y[++p] = i;
for (int i = 1; i <= l; ++i)
if (sa[i] > j) y[++p] = sa[i] - j;
for (int i = 0; i <= m; ++i) t[i] = 0;
for (int i = 1; i <= l; ++i) s[i] = x[y[i]];
for (int i = 1; i <= l; ++i) ++t[s[i]];
for (int i = 1; i <= m; ++i) t[i] += t[i - 1];
for (int i = l; i >= 1; --i) sa[t[s[i]]--] = y[i];
swap(x, y);
x[sa[1]] = 1, p = 1;
for (int i = 2; i <= l; ++i)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p : ++p;
}
}
void get_ans() {
int s1 = 0, s2 = 0;
for (int i = 1; i <= len; ++i) ++(ch[i] == '(' ? s1 : s2);
deque<int> q;
for (int i = l; i > len; --i) {
s[i] = s[i + 1] + (ch[i] == '(' ? 1 : -1);
while (!q.empty() && s[i] > s[q.back()]) q.pop_back();
q.push_back(i);
can[i] = false;
}
for (int i = len; i >= 1; --i) {
s[i] = s[i + 1] + (ch[i] == '(' ? 1 : -1);
can[i] = (max(s2 - s1, 0) + (s[i] - s[q.front()]) >= 0);
while (!q.empty() && s[i] > s[q.back()]) q.pop_back();
q.push_back(i);
while (!q.empty() && q.front() >= i + len) q.pop_front();
}
int p = 1;
for (int i = 1; i <= l; ++i)
if (can[sa[i]]) {
p = sa[i];
break;
}
while (s1 < s2) {
++s1;
putchar('(');
}
for (int i = p; i <= p + len - 1; ++i) putchar(ch[i]);
while (s1 > s2) {
++s2;
putchar(')');
}
putchar('\n');
}
int main() {
init();
work();
get_ans();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int INF = 1e9;
const long long lINF = 1e18;
const double EPS = 1e-12;
using namespace std;
const int N = 1e6 + 100;
char s[N];
int p[N], c[N], last[N];
int pn[N], cn[N];
int n, balance[N], mnl[N], mnr[N];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) {
last[s[i] - 'a' + 1]++;
}
for (int i = 2; i <= 26; i++) {
last[i] += last[i - 1];
}
for (int i = 0; i < n; i++) {
c[i] = last[s[i] - 'a'];
}
for (int i = 0; i < n; i++) {
p[last[s[i] - 'a']++] = i;
}
for (int l = 1; l < n; l <<= 1) {
for (int i = 0; i < n; i++) {
last[i] = i;
}
for (int i = 0; i < n; i++) {
pn[i] = p[i] - l;
if (pn[i] < 0) {
pn[i] += n;
}
}
for (int i = 0; i < n; i++) {
p[last[c[pn[i]]]++] = pn[i];
}
cn[p[0]] = 0;
int nlast = 0;
for (int i = 1; i < n; i++) {
int mid1 = (p[i] + l), mid2 = (p[i - 1] + l);
if (mid1 >= n) {
mid1 -= n;
}
if (mid2 >= n) {
mid2 -= n;
}
if (c[p[i]] > c[p[i - 1]] || c[mid1] > c[mid2]) {
nlast = i;
}
cn[p[i]] = nlast;
}
memcpy(c, cn, n * sizeof(n));
}
mnl[0] = INF;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
balance[i + 1] = balance[i] + 1;
} else {
balance[i + 1] = balance[i] - 1;
}
mnl[i + 1] = min(balance[i + 1], mnl[i]);
}
mnr[n - 1] = balance[n];
for (int i = n - 2; i >= 0; i--) {
mnr[i] = min(mnr[i + 1], balance[i + 1]);
}
int ans = INF, ansi = 0, good = min(0, balance[n]);
for (int i = 0; i < n; i++) {
if (mnl[i] + balance[n] - balance[i] >= good &&
mnr[i] - balance[i] >= good) {
if (ans > c[i]) {
ans = c[i];
ansi = i;
}
}
}
for (int i = 0; i < -balance[n]; i++) {
putchar('(');
}
for (int i = ansi; i < ansi + n; i++) {
putchar(s[i % n]);
}
for (int i = 0; i < balance[n]; i++) {
putchar(')');
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e6;
int n;
char s[2 * NMAX + 5];
int sa[NMAX + 5];
int pos[2 * NMAX + 5];
int pref_sum[NMAX + 5];
int pref_min[NMAX + 5];
int suff_min[NMAX + 5];
int tmp[2 * NMAX + 5];
int gap;
bool cmp(int a, int b) {
if (pos[a] != pos[b]) {
return pos[a] < pos[b];
}
a += gap;
b += gap;
return pos[a] < pos[b];
}
void build_sa() {
sort(sa + 1, sa + 1 + n, [&](int a, int b) { return s[a] < s[b]; });
for (int i = 1; i <= n; i++) {
pos[sa[i]] = pos[sa[i - 1]] + (s[sa[i - 1]] != s[sa[i]]);
pos[sa[i] + n] = pos[sa[i]];
}
for (gap = 1; gap <= n; gap *= 2) {
sort(sa + 1, sa + 1 + n, cmp);
tmp[sa[1]] = 1;
for (int i = 2; i <= n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + cmp(sa[i - 1], sa[i]);
tmp[sa[i] + n] = tmp[sa[i]];
}
for (int i = 1; i <= 2 * n; i++) {
pos[i] = tmp[i];
}
}
}
int main() {
fgets(s + 1, NMAX + 5, stdin);
n = strlen(s + 1);
n -= (s[n] == '\n');
for (int i = n + 1; i <= 2 * n; i++) {
s[i] = s[i - n];
}
for (int i = 1; i <= n; i++) {
sa[i] = i;
}
for (int i = 1; i <= n; i++) {
pref_sum[i] = (s[i] == '(' ? 1 : -1) + pref_sum[i - 1];
pref_min[i] = pref_sum[i];
if (i > 1) {
pref_min[i] = min(pref_min[i - 1], pref_min[i]);
}
}
for (int i = n; i; i--) {
suff_min[i] = pref_sum[i];
if (i < n) {
suff_min[i] = min(suff_min[i + 1], suff_min[i]);
}
}
build_sa();
int cnt = pref_sum[n];
if (cnt > 0) {
for (int i = 1; i <= n; i++) {
if (suff_min[sa[i]] - pref_sum[sa[i] - 1] >= 0 &&
(pref_sum[n] - pref_sum[sa[i] - 1]) + pref_min[sa[i] - 1] >= 0) {
for (int j = sa[i]; j <= n; j++) {
fprintf(stdout, "%c", s[j]);
}
for (int j = 1; j < sa[i]; j++) {
fprintf(stdout, "%c", s[j]);
}
for (int j = 1; j <= cnt; j++) {
fprintf(stdout, ")");
}
return 0;
}
}
} else {
for (int i = 1; i <= n; i++) {
if (suff_min[sa[i]] - pref_sum[sa[i] - 1] >= cnt &&
(pref_sum[n] - pref_sum[sa[i] - 1]) + pref_min[sa[i] - 1] >= cnt) {
for (int j = 1; j <= -cnt; j++) {
fprintf(stdout, "(");
}
for (int j = sa[i]; j <= n; j++) {
fprintf(stdout, "%c", s[j]);
}
for (int j = 1; j < sa[i]; j++) {
fprintf(stdout, "%c", s[j]);
}
return 0;
}
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int N = 1000100;
char S[N << 1];
bool can[N];
void move(int &i, int n) {
while (i < n && !can[i]) {
i++;
}
}
int min_present(int n) {
int p1 = 0, p2 = 1, k = 0;
move(p1, n);
p2 += p1;
move(p2, n);
while (p1 < n && p2 < n && k < n) {
int n1 = p1 + k;
if (n1 >= n) n1 -= n;
int n2 = p2 + k;
if (n2 >= n) n2 -= n;
if (S[n1] < S[n2])
p2 += k + 1, k = 0, move(p2, n);
else if (S[n1] > S[n2])
p1 += k + 1, k = 0, move(p1, n);
else
k++;
if (p1 == p2) p2++, move(p1, n);
}
return std::min(p1, p2);
}
int sum[N << 1], min[N << 1];
int Q[N << 1];
int main() {
scanf("%s", S);
int n = strlen(S);
int l = 0;
for (int i = 0; i < n; i++)
if (S[i] == '(') {
l++;
sum[i] = sum[i + n] = 1;
} else {
l--;
sum[i] = sum[i + n] = -1;
}
for (int i = 0; i < n; i++) S[i + n] = S[i];
for (int i = 1; i < n << 1; i++) sum[i] += sum[i - 1];
int front = 0, rear = 0;
for (int i = 0; i < n * 2; i++) {
while (front < rear && Q[front] + n - 1 < i) {
front++;
}
while (front < rear && sum[Q[rear - 1]] >= sum[i]) {
--rear;
}
Q[rear++] = i;
min[i - n + 1] = sum[Q[front]];
}
for (int i = 0; i < n; i++) {
if (i) min[i] -= sum[i - 1];
if (min[i] < 0 && min[i] - l < 0) continue;
can[i] = true;
}
int res = min_present(n);
if (l < 0)
for (int i = 0; i < -l; i++) putchar('(');
for (int i = res; i < res + n; i++) putchar(S[i]);
if (l > 0)
for (int i = 0; i < l; i++) putchar(')');
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
class SA_IS {
vector<int> compress(vector<int>& v) {
set<int> alph(v.begin(), v.end());
vector<int> dic(alph.begin(), alph.end());
vector<int> bucket_size(dic.size(), 0);
for (int i = 0; i < v.size(); i++) {
v[i] = lower_bound(dic.begin(), dic.end(), v[i]) - dic.begin();
bucket_size[v[i]]++;
}
return bucket_size;
}
class bucket_set {
vector<int> container;
vector<vector<int>::iterator> bucket;
vector<int> front;
vector<int> back;
vector<bool> fixed;
vector<vector<bool>::iterator> bucket_fixed;
vector<bool> used;
const vector<int>& str;
const vector<int>& bucket_size;
const vector<int>& LS;
void put_L() {
for (int i = 0; i < bucket_size.size(); i++) {
for (int j = 0; j < bucket_size[i]; j++) {
if (bucket[i][j] - 1 < 0) continue;
if (LS[bucket[i][j] - 1] == L) {
if (used[bucket[i][j] - 1]) continue;
used[bucket[i][j] - 1] = true;
int c = str[bucket[i][j] - 1];
bucket[c][front[c]] = bucket[i][j] - 1;
bucket_fixed[c][front[c]] = true;
front[c]++;
}
}
back[i] = bucket_size[i] - 1;
}
}
void put_S() {
for (int i = bucket_size.size() - 1; i >= 0; i--) {
for (int j = bucket_size[i] - 1; j >= 0; j--) {
if (bucket[i][j] - 1 < 0) continue;
if (LS[bucket[i][j] - 1] == S) {
if (used[bucket[i][j] - 1]) continue;
used[bucket[i][j] - 1] = true;
int c = str[bucket[i][j] - 1];
bucket[c][back[c]] = bucket[i][j] - 1;
bucket_fixed[c][back[c]] = true;
back[c]--;
}
}
}
}
void init() {
int sum = 0;
for (int i = 0; i < bucket_size.size(); i++) {
bucket[i] = container.begin() + sum;
bucket_fixed[i] = fixed.begin() + sum;
front[i] = 0;
back[i] = bucket_size[i] - 1;
sum += bucket_size[i];
}
}
public:
bucket_set(const vector<int>& str_, const vector<int>& bucket_size_,
const vector<int>& LS_)
: container(str_.size(), -1),
bucket(bucket_size_.size()),
front(bucket_size_.size()),
back(bucket_size_.size()),
fixed(str_.size(), false),
bucket_fixed(bucket_size_.size()),
used(str_.size(), false),
str(str_),
bucket_size(bucket_size_),
LS(LS_) {
init();
}
void put_initial_LMS(const vector<int>& LMS_pos) {
for (int i = 0; i < LMS_pos.size() - 1; i++) {
int c = str[LMS_pos[i]];
bucket[c][back[c]] = LMS_pos[i];
back[c]--;
}
}
void put_ordered_LMS(const vector<int>& LMS_pos) {
for (int i = LMS_pos.size() - 2; i >= 0; i--) {
int c = str[LMS_pos[i]];
bucket[c][back[c]] = LMS_pos[i];
back[c]--;
}
}
void put() {
put_L();
for (int i = 0; i < str.size(); i++)
if (fixed[i] == false) container[i] = -1;
put_S();
container[0] = str.size() - 1;
}
vector<int> get_LMS_substring_order(const vector<int>& LMS) {
vector<int> ret;
for (int i = 0; i < str.size(); i++) {
if (LS[container[i]] != S) continue;
if (container[i] > 0 && LS[container[i] - 1] == L)
ret.push_back(container[i]);
}
return ret;
}
vector<int> get_result() { return container; }
};
struct substring {
int pos;
int size;
vector<int>::iterator str;
vector<int>::iterator ls;
substring() {}
substring(const int pos, const int size, const vector<int>::iterator& str,
const vector<int>::iterator& ls) {
this->pos = pos;
this->size = size;
this->str = str;
this->ls = ls;
}
bool operator==(const substring& x) const {
for (int i = 0; i < min(this->size, x.size); i++) {
if (this->str[i] != x.str[i]) {
return false;
} else if (this->ls[i] != x.ls[i]) {
return false;
}
}
return this->size == x.size;
}
};
public:
static const int L = 0;
static const int S = 1;
string my_s;
vector<int> sa;
vector<int> lcp;
vector<int> rec(vector<int>& v) {
v.push_back(-1);
vector<int> bucket_size = compress(v);
vector<int> LS(v.size());
LS.back() = S;
for (int i = v.size() - 2; i >= 0; i--) {
if (v[i] < v[i + 1])
LS[i] = S;
else if (v[i] > v[i + 1])
LS[i] = L;
else
LS[i] = LS[i + 1];
}
bucket_set my_bucket(v, bucket_size, LS);
vector<int> LMS;
for (int i = 1; i < v.size(); i++) {
if (LS[i] != S) continue;
if (LS[i - 1] == L) LMS.push_back(i);
}
LMS.push_back(v.size() - 1);
vector<int> LMS_substring_order(v.size(), -1);
vector<int> LMS_substring_end(v.size(), -1);
for (int i = 0; i < LMS.size() - 1; i++) {
LMS_substring_order[LMS[i]] = i;
LMS_substring_end[LMS[i]] = LMS[i + 1];
}
if (LMS.size() > 1) {
bucket_set LMS_bucket(v, bucket_size, LS);
LMS_bucket.put_initial_LMS(LMS);
LMS_bucket.put();
vector<int> LMS_order = LMS_bucket.get_LMS_substring_order(LMS);
vector<int> LMS_order_cnt(LMS_order.size());
int cnt = 0;
LMS_order_cnt[0] = 0;
cnt++;
for (int i = 1; i < LMS_order.size(); i++, cnt++) {
substring a(LMS_order[i],
LMS_substring_end[LMS_order[i]] - LMS_order[i] + 1,
v.begin() + LMS_order[i], LS.begin() + LMS_order[i]);
substring b(LMS_order[i - 1],
LMS_substring_end[LMS_order[i - 1]] - LMS_order[i - 1] + 1,
v.begin() + LMS_order[i - 1],
LS.begin() + LMS_order[i - 1]);
if (a == b) cnt--;
LMS_order_cnt[i] = cnt;
}
vector<int> tmp(LMS_order.size());
for (int i = 0; i < LMS_order.size(); i++) {
tmp[LMS_substring_order[LMS_order[i]]] = LMS_order_cnt[i];
}
swap(tmp, LMS_order);
if (cnt != LMS_order.size()) {
vector<int> new_order = rec(LMS_order);
LMS_order = vector<int>(new_order.begin() + 1, new_order.end());
}
tmp = LMS;
for (int i = 0; i < LMS.size() - 1; i++) {
tmp[i] = LMS[LMS_order[i]];
}
swap(tmp, LMS);
my_bucket.put_ordered_LMS(LMS);
}
my_bucket.put();
return my_bucket.get_result();
}
vector<int> rec(string& s) {
vector<int> v(s.begin(), s.end());
return rec(v);
}
void constract_lcp() {
int n = my_s.size();
lcp.resize(n + 1);
vector<int> rank(n + 1);
for (int i = 0; i <= n; i++) rank[sa[i]] = i;
int h = 0;
lcp[0] = 0;
for (int i = 0; i < n; i++) {
int j = sa[rank[i] - 1];
if (h > 0) h--;
for (; j + h < n && i + h < n; h++) {
if (my_s[j + h] != my_s[i + h]) break;
}
lcp[rank[i] - 1] = h;
}
}
SA_IS(string s) {
my_s = s;
sa = rec(s);
}
void dbg_print() {
for (int i = 0; i <= my_s.size(); i++) {
string p(my_s.begin() + sa[i], my_s.end());
cerr << p << " " << sa[i] << endl;
}
}
};
class SegmentTreeMIN {
int n;
vector<int> T;
int INF;
public:
SegmentTreeMIN(int size) {
INF = 1 << 29;
n = 1;
while (n < size) n <<= 1;
T.resize(2 * n - 1);
fill(T.begin(), T.end(), INF);
}
void update(int k, int val) {
k += n - 1;
T[k] = val;
while (k > 0) {
k = (k - 1) / 2;
T[k] = min(T[k * 2 + 1], T[k * 2 + 2]);
}
}
int RMQ(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return INF;
if (a <= l && r <= b)
return T[k];
else {
int val_left = RMQ(a, b, k * 2 + 1, l, (l + r) / 2);
int val_right = RMQ(a, b, k * 2 + 2, (l + r) / 2, r);
return min(val_left, val_right);
}
}
int size() { return n; }
};
int main() {
string s;
cin >> s;
int n = s.size();
s += s;
SA_IS sa(s);
vector<int> arr(2 * n);
for (int i = 0; i < 2 * n; i++) {
if (s[i] == '(') {
arr[i] = 1;
} else {
arr[i] = -1;
}
if (i > 0) arr[i] += arr[i - 1];
}
SegmentTreeMIN seg(2 * n);
for (int i = 0; i < 2 * n; i++) {
seg.update(i, arr[i]);
}
int index = -1;
int len = 1 << 30;
int xx = 0;
int yy = 0;
for (int i = 0; i < 2 * n; i++) {
if (sa.sa[i] > n) continue;
int x = min(0, seg.RMQ(sa.sa[i], sa.sa[i] + n, 0, 0, seg.size()) -
(sa.sa[i] > 0 ? arr[sa.sa[i] - 1] : 0));
int y = max(0, arr[sa.sa[i] + n - 1] -
(sa.sa[i] > 0 ? arr[sa.sa[i] - 1] : 0) + abs(x));
if (len > abs(x) + abs(y) + n) {
index = i;
len = abs(x) + abs(y) + n;
xx = abs(x);
yy = abs(y);
}
}
string ans;
for (int j = 0; j < xx; j++) {
printf("(");
}
cout << s.substr(sa.sa[index], n);
for (int j = 0; j < yy; j++) {
printf(")");
}
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct num {
static const int MA = (int)1e9 + 7, MB = (int)1e9 + 9;
int a, b;
num() {}
num(int x) : a(x), b(x) {}
num(int _a, int _b) : a(_a), b(_b) {}
num operator+(const num &x) const {
return num((a + x.a) % MA, (b + x.b) % MB);
}
num operator-(const num &x) const {
return num((a + MA - x.a) % MA, (b + MB - x.b) % MB);
}
num operator*(const num &x) const {
return num(((long long)a * x.a) % MA, ((long long)b * x.b) % MB);
}
bool operator==(const num &x) const { return a == x.a && b == x.b; }
explicit operator long long() const { return (long long)a * MB + b + 1; }
};
struct StrComparator {
static const num P;
static vector<num> deg;
int n;
const char *s;
num *h;
StrComparator(int n, const char *s) : n(n), s(s) {
h = new num[n + 1];
h[0] = 0;
for (int i = 0; i < (int)(n); i++) h[i + 1] = h[i] * P + s[i];
deg.reserve(n);
while ((int)(deg).size() <= n) deg.push_back(*deg.rbegin() * P);
}
num substr(int i, int len) const { return h[i + len] - h[i] * deg[len]; }
int lcp(int i, int j) {
int L = 0, R = n - max(i, j);
while (L < R) {
int M = (L + R + 1) / 2;
if (substr(i, M) == substr(j, M))
L = M;
else
R = M - 1;
}
return L;
}
int cmp(int a, int b) {
int LEN = n - max(a, b), L = lcp(a, b);
return L < LEN ? (int)s[a + L] - s[b + L] : b - a;
}
bool operator()(int i, int j) { return cmp(i, j) < 0; }
};
const num StrComparator::P = num(239017, 17239);
vector<num> StrComparator::deg(1, 1);
template <const int maxN>
struct RMQ {
int qst, qen, q[maxN], ind[maxN];
void pop(int i) {
if (ind[qst] == i) qst++;
}
void push(int i, int f) {
while (qst < qen && q[qen - 1] >= f) qen--;
q[qen] = f, ind[qen++] = i;
}
int get_min() { return q[qst]; }
};
const int N = 1e6;
int n, b[2 * N + 1];
char s[2 * N];
RMQ<2 * N> rmq;
int main() {
gets(s), n = strlen(s);
memcpy(s + n, s, n);
for (int i = 0; i < (int)(2 * n); i++)
b[i + 1] = b[i] + (s[i] == '(' ? 1 : -1);
StrComparator h(2 * n, s);
int ind = -1;
for (int i = 0; i < (int)(n); i++) rmq.push(i, b[i]);
for (int i = 0; i < (int)(n); i++) {
rmq.push(i + n, b[i + n]);
int mi = rmq.get_min() - b[i];
int diff = b[n + i] - b[i];
rmq.pop(i);
bool good = (diff - 2 * mi == abs(b[n]));
if (good && (ind == -1 || h.cmp(i, ind) < 0)) ind = i;
}
assert(ind != -1);
if (b[n] < 0) {
for (int i = 0; i < (int)(-b[n]); i++) putchar('(');
for (int i = 0; i < (int)(n); i++) putchar(s[ind + i]);
} else {
for (int i = 0; i < (int)(n); i++) putchar(s[ind + i]);
for (int i = 0; i < (int)(b[n]); i++) putchar(')');
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 6;
char s[N];
int p1[N];
int p2[N];
int s1[N];
int s2[N];
long long X1 = 277, X2 = 2887;
long long M1 = 1444444447, M2 = 1777777777;
long long x1[N], x2[N];
struct hasher {
vector<long long> h1, h2;
hasher() {}
string s;
hasher(char *str) {
s = str;
int n = s.length();
h1.assign(n + 1, 0);
h2.assign(n + 1, 0);
for (int i = n - 1; i >= 0; --i) {
h1[i] = (h1[i + 1] * X1 + s[i]) % M1;
h2[i] = (h2[i + 1] * X2 + s[i]) % M2;
}
}
long long get(int l, int r) {
return ((h1[l] - h1[r + 1] * x1[r - l + 1] % M1 + M1) % M1) << 32 |
((h2[l] - h2[r + 1] * x2[r - l + 1] % M2 + M2) % M2);
}
};
int cmp(hasher &s1, int i1, int j1, hasher &s2, int i2, int j2) {
int l = 0, r = min(j1 - i1 + 1, j2 - i2 + 1) + 1;
while (l < r) {
int m = (l + r) >> 1;
if (s1.get(i1, i1 + m - 1) == s2.get(i2, i2 + m - 1))
l = m + 1;
else
r = m;
}
--l;
if (i1 + l > j1 && i2 + l > j2) return 0;
if (i1 + l > j1) return -1;
if (i2 + l > j2) return 1;
return s1.s[i1 + l] < s2.s[i2 + l] ? -1 : 1;
}
hasher h, ho, hz;
int n;
void calc(int i, int &il, int &ir) {
int op = p2[i];
int zp = i - p1[i] - op;
int zs = s2[i + 1];
int os = n - i - s1[i + 1] - zs;
il = zs;
ir = op;
if (os > zp)
ir += os - zp;
else
il += zp - os;
}
bool cmp(int i, int j, int len, int k) {
int il, ir, jl, jr;
calc(i, il, ir);
calc(j, jl, jr);
int im = len - il - ir;
int jm = len - jl - jr;
if (k < il) {
if (k < jl) {
return cmp(i, j, len, min(il, jl));
} else if (k < jl + jm) {
int d = min(il - k, jl + jm - k);
int dif = cmp(ho, 0, d - 1, h, j + (k - jl), j + (k - jl) + d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
} else {
return true;
}
} else if (k < il + im) {
if (k < jl) {
int d = min(jl - k, il + im - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, ho, 0, d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
} else if (k < jl + jm) {
int d = min(il + im - k, jl + jm - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, h, j + (k - jl),
j + (k - jl) + d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
} else {
int d = min(il + im - k, len - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, hz, 0, d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
}
} else if (k < len) {
if (k < jl) {
return false;
} else if (k < jl + jm) {
int d = min(len - k, jl + jm - k);
int dif = cmp(hz, 0, d - 1, h, j + (k - jl), j + (k - jl) + d - 1);
if (dif) return dif < 0;
return cmp(i, j, len, k + d);
} else {
return cmp(i, j, len, len);
}
} else
return false;
}
char e[N];
string ans;
string func(string &s) {
string res;
int m = 0;
for (int i = 0; i < s.length(); ++i)
if (s[i] == '(') {
++m;
} else {
if (!m)
res += "(";
else
--m;
}
res += s;
while (m--) res += ")";
return res;
}
int main() {
for (int i = x1[0] = 1; i < N; ++i) x1[i] = x1[i - 1] * X1 % M1;
for (int i = x2[0] = 1; i < N; ++i) x2[i] = x2[i - 1] * X2 % M2;
gets(s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) s[i + n] = s[i];
for (int i = n; i; --i) {
if (s[i] == '(') {
if (s2[i + 1]) {
s1[i] = s1[i + 1] + 2;
s2[i] = s2[i + 1] - 1;
} else {
s1[i] = s1[i + 1];
s2[i] = s2[i + 1];
}
} else {
s1[i] = s1[i + 1];
s2[i] = s2[i + 1] + 1;
}
}
for (int i = 1; i <= n; ++i) {
if (s[i] == ')') {
if (p2[i - 1]) {
p1[i] = p1[i - 1] + 2;
p2[i] = p2[i - 1] - 1;
} else {
p1[i] = p1[i - 1];
p2[i] = p2[i - 1];
}
} else {
p1[i] = p1[i - 1];
p2[i] = p2[i - 1] + 1;
}
}
int x = n * 10;
vector<int> pos;
for (int i = 0; i < n; ++i) {
int op = p2[i];
int zp = i - p1[i] - op;
int zs = s2[i + 1];
int os = n - i - s1[i + 1] - zs;
int len = zs + op + max(os, zp) - min(os, zp) + n;
if (x > len) {
pos.clear();
x = len;
}
if (x == len) {
pos.push_back(i);
}
int sl, sr;
calc(i, sl, sr);
}
h = hasher(s + 1);
for (int i = 0; i < n * 2; ++i) e[i] = '(';
ho = hasher(e);
for (int i = 0; i < n * 2; ++i) e[i] = ')';
hz = hasher(e);
int res = pos[0];
for (int k = 1; k < pos.size(); ++k)
if (cmp(pos[k], res, x, 0)) res = pos[k];
int sl, sr;
calc(res, sl, sr);
for (int i = 0; i < sl; ++i) printf("(");
for (int i = 0; i < x - sl - sr; ++i) printf("%c", s[res + i + 1]);
for (int i = 0; i < sr; ++i) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
T Bigmod(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T Dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
T Angle(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
T DIFF(T a, T b) {
T d = a - b;
if (d < 0)
return -d;
else
return d;
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T euclide(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
void ia(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void pa(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
template <class T, class first>
inline T togglebit(T a, first i) {
T t = 1;
return (a ^ (t << i));
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int cdigittoint(char ch) { return ch - '0'; }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
double DEG(double x) { return (180.0 * x) / (2.0 * acos(0.0)); }
double RAD(double x) { return (x * (double)2.0 * acos(0.0)) / (180.0); }
char s[2097157];
int a[2097157];
int Tree[3 * 2097157][2];
int New[2097157][2];
int DP[3 * 2097157], l;
const int N = int(2e6) + 10;
int cmp(int *r, int a, int b, int l) {
return (r[a] == r[b]) && (r[a + l] == r[b + l]);
}
int wa[N], wb[N], wws[N], wv[N];
int rnk[N], height[N];
void DA(int *r, int *sa, int n, int m) {
int i, j, p, *x = wa, *y = wb, *t;
for (i = 0; i < m; i++) wws[i] = 0;
for (i = 0; i < n; i++) wws[x[i] = r[i]]++;
for (i = 1; i < m; i++) wws[i] += wws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--wws[x[i]]] = i;
for (j = 1, p = 1; p < n; j *= 2, m = p) {
for (p = 0, i = n - j; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) wv[i] = x[y[i]];
for (i = 0; i < m; i++) wws[i] = 0;
for (i = 0; i < n; i++) wws[wv[i]]++;
for (i = 1; i < m; i++) wws[i] += wws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--wws[wv[i]]] = y[i];
for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
void calheight(int *r, int *sa, int n) {
int i, j, k = 0;
for (i = 1; i <= n; i++) rnk[sa[i]] = i;
for (i = 0; i < n; height[rnk[i++]] = k)
for (k ? k-- : 0, j = sa[rnk[i] - 1];
i + k < n && j + k < n && r[i + k] == r[j + k]; k++)
;
}
int sa[N], data[N], n, p, q;
void Level(int n) {
for (int i = 0;; i++)
if (1 << i >= n) {
l = i;
return;
}
}
void Build(int n) {
for (int i = 1; i <= n; i++) {
Tree[i + ((1 << l) - 1)][s[i - 1] - 'a'] = 1;
DP[i + ((1 << l) - 1)] = height[i];
}
for (int idx = ((1 << l) - 1); idx; idx--) {
int mn = min(Tree[(idx << 1)][0], Tree[((idx << 1) | 1)][1]);
Tree[idx][0] = Tree[(idx << 1)][0] + Tree[((idx << 1) | 1)][0] - mn;
Tree[idx][1] = Tree[(idx << 1)][1] + Tree[((idx << 1) | 1)][1] - mn;
DP[idx] = min(DP[(idx << 1)], DP[((idx << 1) | 1)]);
}
}
void QueryBalance(int a, int b) {
int id = a;
a += ((1 << l) - 1) + 1;
b += ((1 << l) - 1) + 1;
int L[30], R[30], p = 0, q = 0;
while (a <= b) {
if (a % 2 == 1) L[++p] = a;
if (b % 2 == 0) R[++q] = b;
a = (a + 1) >> 1;
b = (b - 1) >> 1;
}
for (int i = 1; i <= p; i++) {
int mn = min(New[id][0], Tree[L[i]][1]);
New[id][0] = New[id][0] + Tree[L[i]][0] - mn;
New[id][1] = New[id][1] + Tree[L[i]][1] - mn;
}
for (int i = q; i; i--) {
int mn = min(New[id][0], Tree[R[i]][1]);
New[id][0] = New[id][0] + Tree[R[i]][0] - mn;
New[id][1] = New[id][1] + Tree[R[i]][1] - mn;
}
swap(New[id][0], New[id][1]);
}
int QueryMin(int a, int b) {
if (a == b) return 1000000007;
a = rnk[a];
b = rnk[b];
if (a > b) swap(a, b);
a += ((1 << l) - 1) + 1;
b += ((1 << l) - 1);
int mn = 1000000007;
while (a <= b) {
if (a % 2 == 1) mn = min(mn, DP[a]);
if (b % 2 == 0) mn = min(mn, DP[b]);
a = (a + 1) >> 1;
b = (b - 1) >> 1;
}
return mn;
}
int main() {
int l = 0;
while (1) {
char x = getchar();
if (x != '(' && x != ')') {
s[l + 1] = 0;
break;
}
if (x == '(')
s[l++] = 'a';
else
s[l++] = 'b';
data[l - 1] = s[l - 1];
}
for (int i = 0; i < l; i++) data[i + l] = s[i + l] = s[i];
s[l + l + 1] = 0;
DA(data, sa, l + l + 1, 128);
calheight(data, sa, l + l);
Level(l + l);
Build(l + l);
for (int i = l + l - 1; i >= 0; i--)
if (s[i] == 'a') a[i] += a[i + 1] + 1;
int newAdd = (1 << 30) - 1 + (1 << 30);
int id;
for (int i = 1; i <= l; i++) {
QueryBalance(i, i + l - 1);
if (New[i][0] && New[i][1] && New[i][0] == New[i][1]) continue;
if (New[i][0] + New[i][1] < newAdd) {
newAdd = New[i][0] + New[i][1];
id = i;
} else if (New[i][0] + New[i][1] == newAdd) {
int open1 = New[id][0] + min(a[id], l);
int open2 = New[i][0] + min(a[i], l);
if (open1 < open2)
id = i;
else if (open1 == open2) {
int x = id + a[id];
int y = i + a[i];
int q = QueryMin(x, y) + a[i];
if (q >= l) {
if (New[id][1] > New[i][1]) {
id = i;
}
} else {
x = rnk[id];
y = rnk[i];
if (x > y) id = i;
}
}
}
}
for (int i = 0; i < New[id][0]; i++) putchar('(');
for (int i = id; i < id + l; i++)
if (s[i] == 'a')
putchar('(');
else
putchar(')');
for (int i = 0; i < New[id][1]; i++) putchar(')');
printf("\n");
;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6000005;
int s[maxn];
int sa[maxn], t1[maxn], t2[maxn], c[maxn], n;
int sum[maxn];
int low[maxn];
int deq[maxn];
void build_sa(int *s, int n, int m) {
int i, k, p, a1, a2, *x = t1, *y = t2;
memset(c, 0, m << 2);
for (i = 0; i < n; ++i) ++c[x[i] = s[i]];
for (i = 1; i < m; ++i) c[i] += c[i - 1];
for (i = n - 1; i >= 0; --i) sa[--c[x[i]]] = i;
for (k = 1; k < n; k <<= 1) {
p = 0;
for (i = 0; i < n; ++i) y[p++] = (sa[i] + n - k) % n;
memset(c, 0, m << 2);
for (i = 0; i < n; ++i) ++c[x[y[i]]];
for (i = 1; i < m; ++i) c[i] += c[i - 1];
for (i = n - 1; i >= 0; --i) sa[--c[x[y[i]]]] = y[i];
swap(x, y), p = 1, x[sa[0]] = 0;
for (i = 1; i < n; ++i) {
a1 = y[(sa[i - 1] + k) % n];
a2 = y[(sa[i] + k) % n];
x[sa[i]] = (a1 == a2 && y[sa[i - 1]] == y[sa[i]]) ? p - 1 : p++;
}
if (p >= n) break;
m = p;
}
}
char res[maxn], tot;
int main() {
char c;
while (c = getchar(), ~c && c != '\n') s[n++] = (c == '(' ? 1 : 2);
for (int i = n; i < n + n; i++) s[i] = s[i - n];
int m = n;
build_sa(s, m, 3);
n <<= 1;
sum[0] = (s[0] == 1 ? 1 : -1);
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + (s[i] == 1 ? 1 : -1);
int pos = 0;
int st = 0, ed = 0;
for (int i = 0; i < n; i++) {
while (st < ed && deq[st] <= i - m) st++;
while (st < ed && sum[i] <= sum[deq[ed - 1]]) ed--;
deq[ed++] = i;
if (i >= m - 1) low[i - m - 1] = sum[deq[st]];
}
if (sum[m - 1] >= 0) {
for (int i = 0; i < m; i++) {
if (sa[i] >= m) continue;
if (sa[i] && low[sa[i]] - sum[sa[i] - 1] >= 0) {
pos = sa[i];
break;
}
if (!sa[i] && low[sa[i]] >= 0) {
pos = sa[i];
break;
}
}
} else {
for (int i = 0; i < m; i++) {
if (sa[i] >= m) continue;
if (sa[i] && low[sa[i]] - sum[sa[i] - 1] - sum[m - 1] >= 0) {
pos = sa[i];
break;
}
if (!sa[i] && low[sa[i]] - sum[m - 1] >= 0) {
pos = sa[i];
break;
}
}
}
if (sum[m - 1] < 0) {
for (int i = 0; i < -sum[m - 1]; i++) putchar('(');
}
for (int i = 0; i < m; i++) {
if (s[pos + i] == 1)
putchar('(');
else
putchar(')');
}
if (sum[m - 1] > 0) {
for (int i = 0; i < sum[m - 1]; i++) putchar(')');
}
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
long long gcd(long long x, long long y) {
while (y) {
long long t = x % y;
x = y;
y = t;
}
return x;
}
long long inv(long long x) { return powmod(x, 1000000007 - 2); }
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int wa[4001000], wb[4001000], wx[4001000], wv[4001000];
int cmp(int *r, int a, int b, int l) {
return r[a + l] == r[b + l] && r[a] == r[b];
}
void da(char *r, int *sa, int n, int m) {
int *x = wa, *y = wb, *t;
int i, j, k, p;
for (i = 0; i < m; ++i) wx[i] = 0;
for (i = 0; i < n; ++i) ++wx[x[i] = r[i]];
for (i = 1; i < m; ++i) wx[i] += wx[i - 1];
for (i = n - 1; i >= 0; --i) sa[--wx[x[i]]] = i;
for (j = 1, p = 1; p < n; j *= 2, m = p) {
for (p = 0, i = n - j; i < n; ++i) y[p++] = i;
for (i = 0; i < n; ++i)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; ++i) wv[i] = x[y[i]];
for (i = 0; i < m; ++i) wx[i] = 0;
for (i = 0; i < n; ++i) ++wx[wv[i]];
for (i = 1; i < m; ++i) wx[i] += wx[i - 1];
for (i = n - 1; i >= 0; --i) sa[--wx[wv[i]]] = y[i];
for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; ++i)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
int Rank[4001000], sa[4001000], height[4001000];
void calheight(char *r, int n) {
int i, j, k = 0;
for (i = 0; i <= n; ++i) Rank[sa[i]] = i;
for (i = 0; i < n; height[Rank[i++]] = k)
for (k ? k-- : 0, j = sa[Rank[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
char s[4001000];
char ans[4001000];
bool can[4001000];
void fckn(int x, int n) {
deque<pair<int, int> > q;
int tag = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 0)
cnt++;
else
cnt--;
while (q.size() && q.back().second >= cnt) q.pop_back();
q.push_back(make_pair(i, cnt));
}
for (int i = 0; i < n; i++) {
while (q.size() && q.front().first < i) {
q.pop_front();
}
if (q.front().second - tag >= x) can[i] = true;
if (s[i] == 0)
tag++;
else
tag--;
while (q.size() && q.back().second >= cnt + tag) q.pop_back();
q.push_back(make_pair(i + n, cnt + tag));
}
}
int main() {
scanf("%s", s);
int n = strlen(s);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(')
cnt++, s[i] = 0;
else
cnt--, s[i] = 1;
s[i + n] = s[i];
}
fckn(min(0, cnt), n);
s[2 * n] = 2;
da(s, sa, 2 * n + 1, 3);
int i = 0, top = 0;
for (; sa[i] >= n || !can[sa[i]]; i++)
;
i = sa[i];
while (cnt < 0) {
ans[top++] = '(';
cnt++;
}
for (int j = 0; j < n; j++) ans[top++] = s[i + j] == 0 ? '(' : ')';
while (cnt > 0) {
ans[top++] = ')';
cnt--;
}
ans[top++] = '\0';
puts(ans);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000050;
const int M = 2 * N;
int tot;
char s[M];
int id[M], sa[M];
pair<pair<int, int>, int> tmp[M];
void BuildSuffixArray() {
s[++tot] = '(' + 2;
int i, j;
for (i = 1; i <= tot; i++) id[i] = s[i] - '(' + 1;
for (j = 0; j < 20; j++) {
for (i = 1; i <= tot; i++)
tmp[i] = make_pair(make_pair(id[i], id[i + (1 << j)]), i);
sort(tmp + 1, tmp + 1 + tot);
int c = 0;
for (i = 1; i <= tot; i++) {
id[tmp[i].second] = c + 1;
c += tmp[i].first != tmp[i + 1].first;
}
if (c == tot) break;
}
for (i = 1; i <= tot; i++) sa[id[i]] = i;
}
int p[N], m[N];
int main() {
int n, i;
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; i++) s[i + n] = s[i];
tot = n * 2;
BuildSuffixArray();
for (i = 1; i <= n; i++) {
p[i] = p[i - 1];
if (s[i] == '(')
p[i]++;
else
p[i]--;
}
m[n] = p[n];
for (i = n - 1; i >= 1; i--) {
m[i] = min(m[i + 1], p[i]);
}
int sol = M, mn = M;
int add = 0;
if (p[n] < 0) add = -p[n];
for (i = 1; i <= n; i++) {
if (mn - p[i - 1] + p[n] + add >= 0 && m[i] - p[i - 1] + add >= 0) {
sol = min(sol, id[i]);
}
mn = min(mn, p[i]);
}
if (p[n] < 0)
for (i = 0; i < -p[n]; i++) printf("(");
for (i = sa[sol]; i < n + sa[sol]; i++) printf("%c", s[i]);
if (p[n] > 0)
for (i = 0; i < p[n]; i++) printf(")");
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int N;
char S[2 * MAXN];
int ord[2 * MAXN];
pair<pair<int, int>, int> E[2 * MAXN];
int step = 1;
int pre[MAXN];
int minp[MAXN];
int mins[MAXN];
char ans[MAXN];
void build() {
for (int i = 0; i < N; i++) ord[i] = (S[i] == ')');
for (int jump = 1; jump < N; step++, jump *= 2) {
for (int i = 0; i < N; i++)
E[i] = make_pair(
pair<int, int>(ord[i], (i + jump < N) ? ord[i + jump] : N), i);
sort(E, E + N);
int ind = -1;
pair<int, int> prev(-1, -1);
for (int i = 0; i < N; i++) {
int idx = E[i].second;
pair<int, int> cur = E[i].first;
if (cur != prev) {
ind++;
prev = cur;
}
ord[idx] = ind;
}
}
}
int main() {
scanf("%s", &S);
N = (int)(strlen(S));
memcpy(S + N, S, N);
N += N;
S[N] = '|';
S[N + 1] = 0;
build();
N /= 2;
for (int i = 1; i <= N; i++)
pre[i] = pre[i - 1] + ((S[i - 1] == '(') ? 1 : -1);
minp[0] = pre[0] + pre[N];
for (int i = 1; i < N; i++) minp[i] = min(minp[i - 1], pre[i] + pre[N]);
mins[N - 1] = pre[N - 1];
for (int i = N - 2; i >= 0; i--) mins[i] = min(mins[i + 1], pre[i]);
int best = -1, x = min(0, pre[N]);
for (int i = 0; i < N; i++)
if (min(minp[i], mins[i]) - pre[i] >= x)
if (best == -1 || ord[i] < ord[best]) best = i;
int ind = 0;
for (int i = 0; i < -pre[N]; i++) ans[ind++] = '(';
for (int i = 0; i < N; i++) ans[ind++] = S[best + i];
for (int i = 0; i < pre[N]; i++) ans[ind++] = ')';
ans[ind] = 0;
printf("%s\n", ans);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010101;
namespace SA {
const static int N = ::N << 1;
int sa[N], rk[N], ht[N], s[N << 1], t[N << 1], p[N], cnt[N], cur[N];
void sais(int n, int m, int *s, int *t, int *p) {
int n1 = t[n - 1] = 0, ch = rk[0] = -1, *s1 = s + n;
for (int i = n - 2; ~i; i--)
t[i] = s[i] == s[i + 1] ? t[i + 1] : s[i] > s[i + 1];
for (int i = 1; i < n; i++)
rk[i] = t[i - 1] && !t[i] ? (p[n1] = i, n1++) : -1;
std::fill_n(sa, n, -1);
std::fill_n(cnt, m, 0);
for (int i = 0; i < n; i++) cnt[s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i < m; i++) cur[i] = cnt[i] - 1;
for (int i = n1 - 1; ~i; i--) sa[cur[s[p[i]]]--] = p[i];
for (int i = 1; i < m; i++) cur[i] = cnt[i - 1];
for (int i = 0; i < n; i++)
if (sa[i] > 0 && t[sa[i] - 1]) sa[cur[s[sa[i] - 1]]++] = sa[i] - 1;
for (int i = 0; i < m; i++) cur[i] = cnt[i] - 1;
for (int i = n - 1; ~i; i--)
if (sa[i] > 0 && !t[sa[i] - 1]) sa[cur[s[sa[i] - 1]]--] = sa[i] - 1;
for (int i = 0, x, y; i < n; i++)
if (~(x = rk[sa[i]])) {
if (ch < 1 || p[x + 1] - p[x] != p[y + 1] - p[y])
ch++;
else
for (int j = p[x], k = p[y]; j <= p[x + 1]; j++, k++)
if ((s[j] << 1 | t[j]) != (s[k] << 1 | t[k])) {
ch++;
break;
}
s1[y = x] = ch;
}
if (ch + 1 < n1)
sais(n1, ch + 1, s1, t + n, p + n1);
else
for (int i = 0; i < n1; i++) sa[s1[i]] = i;
for (int i = 0; i < n1; i++) s1[i] = p[sa[i]];
std::fill_n(sa, n, -1);
std::fill_n(cnt, m, 0);
for (int i = 0; i < n; i++) cnt[s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i < m; i++) cur[i] = cnt[i] - 1;
for (int i = n1 - 1; ~i; i--) sa[cur[s[s1[i]]]--] = s1[i];
for (int i = 1; i < m; i++) cur[i] = cnt[i - 1];
for (int i = 0; i < n; i++)
if (sa[i] > 0 && t[sa[i] - 1]) sa[cur[s[sa[i] - 1]]++] = sa[i] - 1;
for (int i = 0; i < m; i++) cur[i] = cnt[i] - 1;
for (int i = n - 1; ~i; i--)
if (sa[i] > 0 && !t[sa[i] - 1]) sa[cur[s[sa[i] - 1]]--] = sa[i] - 1;
}
template <typename T>
int mapCharToInt(int n, const T *str) {
int m = *max_element(str, str + n);
std::fill_n(rk, m + 1, 0);
for (int i = 0; i < n; i++) rk[str[i]] = 1;
for (int i = 0; i < m; i++) rk[i + 1] += rk[i];
for (int i = 0; i < n; i++) s[i] = rk[str[i]] - 1;
return rk[m];
}
template <typename T>
void suffixArray(int n, const T *str) {
int m = mapCharToInt(++n, str);
sais(n, m, s, t, p);
for (int i = 0; i < n; i++) rk[sa[i]] = i;
for (int i = 0, h = ht[0] = 0; i < n - 1; i++) {
int j = sa[rk[i] - 1];
while (i + h < n && j + h < n && s[i + h] == s[j + h]) h++;
if (ht[rk[i]] = h) h--;
}
}
}; // namespace SA
string s;
int n, ans;
int cnt[2], pre[N], mpre[N], msuf[N], in[N << 1];
void solve() {
int add = (cnt[0] < cnt[1]) ? (cnt[1] - cnt[0]) : 0;
for (int _ = (1); _ < (n << 1 | 1); _++) {
int i = SA::sa[_];
if (i >= n) continue;
++i;
int t = min(msuf[i] - pre[i - 1], mpre[i - 1] + pre[n] - pre[i - 1]) + add;
if (t >= 0) {
ans = i;
return;
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> s;
n = (int)s.size();
s = " " + s;
for (int i = (1); i < (n + 1); i++) {
++cnt[s[i] == ')'];
int t = (s[i] == '(') ? 1 : -1;
pre[i] = pre[i - 1] + t;
}
mpre[1] = pre[1];
for (int i = (2); i < (n + 1); i++) mpre[i] = min(mpre[i - 1], pre[i]);
msuf[n] = pre[n];
for (int i = n - 1; i; --i) msuf[i] = min(msuf[i + 1], pre[i]);
for (int i = (1); i < (n + 1); i++) in[i - 1] = (s[i] == ')') + 1;
for (int i = (1); i < (n + 1); i++) in[n + i - 1] = (s[i] == ')') + 1;
in[n << 1] = 0;
SA::suffixArray<int>(n << 1, in);
solve();
while (cnt[0] < cnt[1]) cout << "(", ++cnt[0];
for (int i = (ans); i < (n + 1); i++) cout << s[i];
for (int i = (1); i < (ans); i++) cout << s[i];
while (cnt[0] > cnt[1]) cout << ")", ++cnt[1];
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n1, w[2000010], wa[2000010], wb[2000010], sa[2000010], s[2000010],
f[2000010], q[2000010];
char st[2000010];
bool cmp(int i, int j, int h, int *r) {
if (r[i] < r[j]) return 1;
if (i + h >= n1) return 1;
return r[i + h] < r[j + h];
}
void suffix(char *s) {
n1 = strlen(s);
int i, j, p, m = 128, *first = wa, *second = wb;
for (i = 0; i < m; i++) w[i] = 0;
for (i = 0; i < n1; i++) w[first[i] = s[i]]++;
for (i = 1; i < m; i++) w[i] += w[i - 1];
for (i = n1 - 1; i >= 0; i--) sa[--w[first[i]]] = i;
for (j = 1, p = 0; p != n1; j <<= 1, m = p) {
for (i = n1 - j, p = 0; i < n1; i++) second[p++] = i;
for (i = 0; i < n1; i++)
if (sa[i] >= j) second[p++] = sa[i] - j;
for (i = 0; i < m; i++) w[i] = 0;
for (i = 0; i < n1; i++) w[first[i]]++;
for (i = 1; i < m; i++) w[i] += w[i - 1];
for (i = n1 - 1; i >= 0; i--) sa[--w[first[second[i]]]] = second[i];
swap(first, second);
for (i = 1, first[sa[0]] = 0, p = 1; i < n1; i++) {
first[sa[i]] = cmp(sa[i - 1], sa[i], j, second) ? p++ : p - 1;
}
}
}
int main() {
int T, i, j, k, ca = 0, m, n;
scanf("%s", st);
n = strlen(st);
for (i = 0; i < n; i++) st[i + n] = st[i];
st[n + n] = 0;
for (i = 0; i < n + n; i++) s[i + 1] = s[i] + (st[i] == '(' ? 1 : -1);
suffix(st);
int head = 0, tail = -1;
for (i = 1; i <= n + n; i++) {
while (head <= tail && q[head] < i - n + 1) head++;
while (head <= tail && s[i] <= s[q[tail]]) tail--;
q[++tail] = i;
if (i >= n) f[i - n] = s[q[head]];
}
k = min(s[n], 0);
for (i = 0; i < n + n; i++) {
j = sa[i];
if (j >= n) continue;
if (f[j] - s[j] >= k) break;
}
for (i = 0; i < -s[n]; i++) printf("(");
for (i = j; i < j + n; i++) printf("%c", st[i]);
for (i = 0; i < s[n]; i++) printf(")");
puts("");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
const int M = 4e6 + 3;
const int ym = 2e6;
const int oo = 1e9;
const int OS = 317;
const int MOD = 1e9 + 7;
char s[N];
int n, stp[M], p1[N], p2[N], s1[N], s2[N], ho[N], hz[N], h[N], op[N], zp[N],
os[N], zs[N], il[N], ir[N];
vector<int> st;
int get(int i, int ln) {
int ans, lt, l;
lt = min(il[i], ln);
ans = (stp[ym] * 1LL * ho[lt]) % MOD;
l = lt;
lt = max(0, min(n - i, ln - l));
ans =
(ans +
(((h[i + lt] - h[i]) % MOD + MOD) % MOD * 1LL * stp[ym + l - i]) % MOD) %
MOD;
l += lt;
lt = max(0, min(i, ln - l));
ans = (ans + h[lt] * 1LL * stp[ym + l] % MOD) % MOD;
l += lt;
lt = max(0, ln - l);
ans = (ans + hz[lt] * 1LL * stp[ym + l] % MOD) % MOD;
return ans;
}
int get_ch(int i, int ln) {
if (ln <= il[i]) return '(';
ln -= il[i];
if (ln <= n - i) return s[i + ln];
ln -= n - i;
if (ln <= i)
return s[ln];
else
return ')';
}
int ans;
bool cmp(int i, int j) {
int l, r, x;
l = 1, r = ans;
while (l <= r) {
x = (l + r) >> 1;
if (get(i, x) == get(j, x))
l = x + 1;
else
r = x - 1;
}
if (r + 1 > ans) return true;
return get_ch(i, r + 1) <= get_ch(j, r + 1);
}
int main() {
if (0) {
freopen("input.txt", "w", stdout);
int n = 1e6;
for (int i = 0; i < n; ++i) printf("(");
printf("\n");
return 0;
}
int i, j, len, mn;
gets(s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; ++i)
if (s[i] == '(')
p1[i] = p1[i - 1], p2[i] = p2[i - 1] + 1;
else if (p2[i - 1])
p1[i] = p1[i - 1] + 2, p2[i] = p2[i - 1] - 1;
else
p1[i] = p1[i - 1], p2[i] = p2[i - 1];
for (i = n; i; --i)
if (s[i] == ')')
s1[i] = s1[i + 1], s2[i] = s2[i + 1] + 1;
else if (s2[i + 1])
s1[i] = s1[i + 1] + 2, s2[i] = s2[i + 1] - 1;
else
s1[i] = s1[i + 1], s2[i] = s2[i + 1];
for (i = 0; i <= n; ++i) {
op[i] = p2[i];
zp[i] = i - p1[i] - op[i];
zs[i] = s2[i + 1];
os[i] = n - i - s1[i + 1] - zs[i];
il[i] = zs[i];
ir[i] = op[i];
if (os[i] > zp[i])
ir[i] += os[i] - zp[i];
else
il[i] += zp[i] - os[i];
}
ans = oo;
for (i = 0; i < n; ++i) {
len = n + zs[i] + op[i] + max(os[i], zp[i]) - min(os[i], zp[i]);
if (ans > len) st.clear();
if (ans >= len) ans = len, st.push_back(i);
}
stp[0] = 1;
for (i = 1; i < M; ++i) stp[i] = (stp[i - 1] * 1LL * OS) % MOD;
ho[0] = hz[0] = 0;
for (i = 1; i < N; ++i)
ho[i] = (ho[i - 1] + '(' * 1LL * stp[i - 1] % MOD) % MOD;
for (i = 1; i < N; ++i)
hz[i] = (hz[i - 1] + ')' * 1LL * stp[i - 1] % MOD) % MOD;
h[0] = 0;
for (i = 1; i <= n; ++i)
h[i] = (h[i - 1] + s[i] * 1LL * stp[i - 1] % MOD) % MOD;
mn = st[0];
for (i = 1; i < st.size(); ++i)
if (cmp(st[i], mn)) mn = st[i];
i = mn;
for (j = 0; j < il[i]; ++j) putchar('(');
for (j = i + 1; j <= n; ++j) putchar(s[j]);
for (j = 1; j <= i; ++j) putchar(s[j]);
for (j = 0; j < ir[i]; ++j) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000005, ha = 1e9 + 9;
inline int Get(char x) { return x == '(' ? 1 : -1; }
inline int add(int x, int y) {
x += y;
return x >= ha ? x - ha : x;
}
int n, q[maxn], hd, tl, a[maxn], tot, p, N;
int c[maxn], h[maxn];
char s[maxn];
inline int gethash(int x, int len) {
return add(h[x + len - 1], ha - h[x - 1] * (long long)c[len] % ha);
}
inline bool cmp(int x, int y) {
int l = 0, r = n, mid, an = 0;
while (l <= r) {
mid = l + r >> 1;
if (gethash(x, mid) == gethash(y, mid))
an = mid, l = mid + 1;
else
r = mid - 1;
}
return an == n ? 1 : s[x + an] == '(';
}
inline void update(int x) {
if (!p || cmp(x, p)) p = x;
}
inline void solve1() {
c[0] = 1;
for (int i = 1; i <= N; i++) {
a[i] = a[i - 1] + Get(s[i]);
c[i] = add(c[i - 1], add(c[i - 1], c[i - 1]));
h[i] = add(add(h[i - 1], add(h[i - 1], h[i - 1])), (s[i] == '(' ? 1 : 2));
}
hd = 1, tl = 0;
for (int i = 1; i < N; i++) {
while (hd <= tl && a[i] <= a[q[tl]]) tl--;
q[++tl] = i;
while (hd <= tl && q[hd] + n <= i) hd++;
if (i >= n && a[q[hd]] >= a[i - n]) update(i - n + 1);
}
for (int i = 0; i < n; i++) putchar(s[p + i]);
for (int i = 1; i <= tot; i++) putchar(')');
}
inline void solve2() {
c[0] = 1;
for (int i = 1; i <= N; i++) {
c[i] = add(c[i - 1], add(c[i - 1], c[i - 1]));
h[i] = add(add(h[i - 1], add(h[i - 1], h[i - 1])), (s[i] == '(' ? 1 : 2));
}
for (int i = N; i; i--) a[i] = a[i + 1] - Get(s[i]);
hd = 1, tl = 0;
for (int i = N - 1; i; i--) {
while (hd <= tl && a[i] <= a[q[tl]]) tl--;
q[++tl] = i;
while (hd <= tl && q[hd] - n >= i) hd++;
if (i <= n && a[q[hd]] >= a[i + n]) update(i);
}
for (int i = tot; i < 0; i++) putchar('(');
for (int i = 0; i < n; i++) putchar(s[p + i]);
}
int main() {
scanf("%s", s + 1), n = strlen(s + 1), N = n << 1;
for (int i = 1; i <= n; i++) s[i + n] = s[i], tot += Get(s[i]);
if (tot >= 0)
solve1();
else
solve2();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace ::std;
const int N = 1000000;
int n, en, st = 2140000000, now;
int a[N + 5];
int max_close[N + 5];
long long ord[N + 5];
pair<long long, int> num[N + 5];
void init() {
char in[N + 5];
scanf("%s", in);
n = strlen(in);
int sum = 0;
for (int i = 1; i <= n; i++) {
a[i] = in[i - 1] == '(' ? -1 : 1;
en -= a[i];
sum += a[i];
max_close[i] = max(max_close[i - 1], sum);
}
en = max(0, en);
}
void get_ord() {
int m = 0, p = 0;
while (p <= n * 2) {
m = 0;
for (int i = 1; i <= n; i++) {
if (p == 0)
num[i].first = a[i];
else
num[i].first = ord[i] * (n + 1) + ord[(i - 1 + p) % n + 1];
num[i].second = i;
}
sort(num + 1, num + n + 1);
for (int i = 1; i <= n; i++) {
if (i != 0 && num[i].first != num[i - 1].first) m++;
ord[num[i].second] = m;
}
if (p == 0)
p = 1;
else
p <<= 1;
}
}
int main() {
init();
get_ord();
st = max_close[n];
now = 1;
int cnt = 0, mc = 0;
for (int i = n; i > 1; i--) {
cnt += a[i];
mc = max(a[i], mc + a[i]);
int new_st = max(max(0, mc), cnt + max_close[i - 1]);
if (st > new_st || (st == new_st && ord[now] > ord[i])) {
st = new_st;
now = i;
}
}
for (int i = 0; i < st; i++) printf("(");
for (int i = now; i <= n; i++) {
if (a[i] == -1)
printf("(");
else
printf(")");
}
for (int i = 1; i < now; i++) {
if (a[i] == -1)
printf("(");
else
printf(")");
}
for (int i = 0; i < en; i++) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 6;
char s[N];
int p1[N];
int p2[N];
int s1[N];
int s2[N];
long long X1 = 277, X2 = 2887;
long long M1 = 1444444447, M2 = 1777777777;
long long x1[N], x2[N];
struct hasher {
vector<long long> h1, h2;
hasher() {}
string s;
hasher(char *str) {
s = str;
int n = s.length();
h1.assign(n + 1, 0);
for (int i = n - 1; i >= 0; --i) {
h1[i] = (h1[i + 1] * X1 + s[i]) % M1;
}
}
long long get(int l, int r) {
return ((h1[l] - h1[r + 1] * x1[r - l + 1] % M1 + M1) % M1);
}
};
int cmp(hasher &s1, int i1, int j1, hasher &s2, int i2, int j2) {
int l = 0, r = min(j1 - i1 + 1, j2 - i2 + 1) + 1;
while (l < r) {
int m = (l + r) >> 1;
if (s1.get(i1, i1 + m - 1) == s2.get(i2, i2 + m - 1))
l = m + 1;
else
r = m;
}
--l;
if (i1 + l > j1 && i2 + l > j2) return 0;
if (i1 + l > j1) return -1;
if (i2 + l > j2) return 1;
return s1.s[i1 + l] < s2.s[i2 + l] ? -1 : 1;
}
hasher h, ho, hz;
int n;
void calc(int i, int &il, int &ir) {
int op = p2[i];
int zp = i - p1[i] - op;
int zs = s2[i + 1];
int os = n - i - s1[i + 1] - zs;
il = zs;
ir = op;
if (os > zp)
ir += os - zp;
else
il += zp - os;
}
bool cmp(int i, int j, int len) {
int il, ir, jl, jr;
calc(i, il, ir);
calc(j, jl, jr);
int im = len - il - ir;
int jm = len - jl - jr;
int k = 0;
for (;;) {
if (k < il) {
if (k < jl) {
k = min(il, jl);
continue;
} else if (k < jl + jm) {
int d = min(il - k, jl + jm - k);
int dif = cmp(ho, 0, d - 1, h, j + (k - jl), j + (k - jl) + d - 1);
if (dif) return dif < 0;
k += d;
continue;
} else {
return true;
}
} else if (k < il + im) {
if (k < jl) {
int d = min(jl - k, il + im - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, ho, 0, d - 1);
if (dif) return dif < 0;
k += d;
continue;
} else if (k < jl + jm) {
int d = min(il + im - k, jl + jm - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, h, j + (k - jl),
j + (k - jl) + d - 1);
if (dif) return dif < 0;
k += d;
continue;
} else {
int d = min(il + im - k, len - k);
int dif = cmp(h, i + (k - il), i + (k - il) + d - 1, hz, 0, d - 1);
if (dif) return dif < 0;
k += d;
continue;
}
} else if (k < len) {
if (k < jl) {
return false;
} else if (k < jl + jm) {
int d = min(len - k, jl + jm - k);
int dif = cmp(hz, 0, d - 1, h, j + (k - jl), j + (k - jl) + d - 1);
if (dif) return dif < 0;
k += d;
continue;
} else {
k = len;
continue;
}
} else
return false;
}
}
char e[N];
string ans;
string func(string &s) {
string res;
int m = 0;
for (int i = 0; i < s.length(); ++i)
if (s[i] == '(') {
++m;
} else {
if (!m)
res += "(";
else
--m;
}
res += s;
while (m--) res += ")";
return res;
}
int main() {
for (int i = x1[0] = 1; i < N; ++i) x1[i] = x1[i - 1] * X1 % M1;
gets(s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) s[i + n] = s[i];
for (int i = n; i; --i) {
if (s[i] == '(') {
if (s2[i + 1]) {
s1[i] = s1[i + 1] + 2;
s2[i] = s2[i + 1] - 1;
} else {
s1[i] = s1[i + 1];
s2[i] = s2[i + 1];
}
} else {
s1[i] = s1[i + 1];
s2[i] = s2[i + 1] + 1;
}
}
for (int i = 1; i <= n; ++i) {
if (s[i] == ')') {
if (p2[i - 1]) {
p1[i] = p1[i - 1] + 2;
p2[i] = p2[i - 1] - 1;
} else {
p1[i] = p1[i - 1];
p2[i] = p2[i - 1];
}
} else {
p1[i] = p1[i - 1];
p2[i] = p2[i - 1] + 1;
}
}
int x = n * 10;
vector<int> pos;
for (int i = 0; i < n; ++i) {
int op = p2[i];
int zp = i - p1[i] - op;
int zs = s2[i + 1];
int os = n - i - s1[i + 1] - zs;
int len = zs + op + max(os, zp) - min(os, zp) + n;
if (x > len) {
pos.clear();
x = len;
}
if (x == len) {
pos.push_back(i);
}
int sl, sr;
calc(i, sl, sr);
}
h = hasher(s + 1);
for (int i = 0; i < n * 2; ++i) e[i] = '(';
ho = hasher(e);
for (int i = 0; i < n * 2; ++i) e[i] = ')';
hz = hasher(e);
int res = pos[0];
for (int k = 1; k < pos.size(); ++k)
if (cmp(pos[k], res, x)) res = pos[k];
int sl, sr;
calc(res, sl, sr);
for (int i = 0; i < sl; ++i) printf("(");
for (int i = 0; i < x - sl - sr; ++i) printf("%c", s[res + i + 1]);
for (int i = 0; i < sr; ++i) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000050;
const int INF = 1e9;
int t[maxn], x[maxn], y[maxn], sa[maxn], rnk[maxn], height[maxn];
int seg[maxn << 2], laz[maxn << 2];
int sum[maxn];
char s[maxn];
int n, m;
void get_sa() {
for (int i = 1; i <= m; i++) t[i] = 0;
for (int i = 1; i <= n; i++) t[x[i] = s[i]]++;
for (int i = 2; i <= m; i++) t[i] += t[i - 1];
for (int i = n; i >= 1; i--) sa[t[x[i]]--] = i;
for (int k = 1; k <= n; k <<= 1) {
int num = 0;
for (int i = n - k + 1; i <= n; i++) y[++num] = i;
for (int i = 1; i <= n; i++) {
if (sa[i] > k) y[++num] = sa[i] - k;
}
for (int i = 1; i <= m; i++) t[i] = 0;
for (int i = 1; i <= n; i++) t[x[i]]++;
for (int i = 2; i <= m; i++) t[i] += t[i - 1];
for (int i = n; i >= 1; i--) sa[t[x[y[i]]]--] = y[i];
swap(x, y);
x[sa[1]] = 1;
num = 1;
for (int i = 2; i <= n; i++) {
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k])
? num
: ++num;
}
if (num == n) break;
m = num;
}
for (int i = 1; i <= n; i++) rnk[sa[i]] = i;
}
void pushup(int x) { seg[x] = min(seg[x << 1], seg[x << 1 | 1]); }
void pushdown(int x) {
if (laz[x]) {
seg[x << 1] += laz[x];
seg[x << 1 | 1] += laz[x];
laz[x << 1] += laz[x];
laz[x << 1 | 1] += laz[x];
laz[x] = 0;
}
}
void build(int x, int l, int r) {
if (l == r) {
seg[x] = sum[l];
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pushup(x);
}
void update(int x, int l, int r, int L, int R, int val) {
if (L <= l && r <= R) {
seg[x] += val;
laz[x] += val;
return;
}
int mid = (l + r) >> 1;
pushdown(x);
if (mid >= L) update(x << 1, l, mid, L, R, val);
if (mid < R) update(x << 1 | 1, mid + 1, r, L, R, val);
pushup(x);
}
int query(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return seg[x];
int mid = (l + r) >> 1, res = INF;
pushdown(x);
if (mid >= L) res = min(res, query(x << 1, l, mid, L, R));
if (mid < R) res = min(res, query(x << 1 | 1, mid + 1, r, L, R));
return res;
}
void solve() {
scanf("%s", s + 1);
int len_s = strlen(s + 1), tot1 = 0, tot2 = 0;
for (int i = 1; i <= len_s; i++) {
if (s[i] == '(') {
sum[i] = sum[i - 1] + 1;
tot1++;
} else {
sum[i] = sum[i - 1] - 1;
tot2++;
}
}
for (int i = len_s + 1; i <= 2 * len_s; i++) s[i] = s[i - len_s];
n = 2 * len_s;
m = 128;
get_sa();
build(1, 1, n);
int res = 0;
for (int i = 1; i <= len_s; i++) {
if (query(1, 1, n, i, i + len_s - 1) >= min(tot1 - tot2, 0) &&
(!res || rnk[res] > rnk[i]))
res = i;
update(1, 1, n, i + 1, i + len_s - 1, ((s[i] == '(') ? -1 : 1));
int tmp = query(1, 1, n, i + len_s - 1, i + len_s - 1);
update(1, 1, n, i + len_s, i + len_s, ((s[i] == '(') ? tmp + 1 : tmp - 1));
}
if (tot1 <= tot2) {
for (int i = 1; i <= tot2 - tot1; i++) printf("(");
for (int i = res; i <= res + len_s - 1; i++) printf("%c", s[i]);
} else {
for (int i = res; i <= res + len_s - 1; i++) printf("%c", s[i]);
for (int i = 1; i <= tot1 - tot2; i++) printf(")");
}
printf("\n");
}
int main() {
solve();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
static unsigned rnd() {
static int second = 124612741;
second ^= second << 13;
second ^= second >> 17;
return second ^= second << 5;
}
inline int fpow(int a, int st, int mod) {
int ans = 1;
while (st) {
if (st % 2) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
st /= 2;
}
return ans;
}
int invmod(int first, int second) {
int a = 1, b = 0, k;
for (; second; swap(first, second), swap(a, b)) {
k = first / second;
first -= second * k;
a -= b * k;
}
return a + max(b, 0);
}
struct Hash {
Hash() : x1(0), x2(0) {}
Hash(const int& x1, const int& x2) : x1(x1), x2(x2) {}
int x1, x2;
static int mod1, mod2;
static int p1, p2;
static int invp1, invp2;
static bool initCalled;
static const Hash ONE, ZERO, INVALID;
static Hash UNIT, INV_UNIT;
static bool prime(int a) {
if (a == 1) return 0;
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
static void init() {
if (initCalled) return;
initCalled = true;
mod1 = 1000000000 + rnd() % 10000000;
while (!prime(mod1)) ++mod1;
mod2 = 1000000000 + rnd() % 10000000;
while (mod2 == mod1 || !prime(mod2)) ++mod2;
invp1 = fpow(p1, mod1 - 2, mod1);
invp2 = fpow(p2, mod2 - 2, mod2);
INV_UNIT = Hash(invp1, invp2);
}
inline Hash& operator+=(const Hash& other) {
x1 += other.x1;
x1 -= (((x1 - mod1) >> 31) + 1) * mod1;
x2 += other.x2;
x1 -= (((x1 - mod2) >> 31) + 1) * mod2;
return *this;
}
inline Hash& operator-=(const Hash& other) {
x1 -= other.x1;
if (x1 < 0) x1 += Hash::mod1;
x2 -= other.x2;
if (x2 < 0) x2 += Hash::mod2;
return *this;
}
inline Hash& operator*=(const Hash& other) {
x1 = (long long)x1 * other.x1 % Hash::mod1;
x2 = (long long)x2 * other.x2 % Hash::mod2;
return *this;
}
inline Hash& operator*=(const int& other) {
x1 = (long long)x1 * other % Hash::mod1;
x2 = (long long)x2 * other % Hash::mod2;
return *this;
}
inline Hash& operator^=(const int& power) {
int st = power;
Hash ans(1, 1);
while (st) {
if (st % 2) ans *= *this;
x1 = (long long)x1 * x1 % Hash::mod1;
x2 = (long long)x2 * x2 % Hash::mod2;
st /= 2;
}
return *this;
}
inline bool operator==(const Hash& other) const {
return x1 == other.x1 && x2 == other.x2;
}
};
bool Hash::initCalled = false;
int Hash::mod1 = 0;
int Hash::mod2 = 0;
int Hash::p1 = 23561;
int Hash::p2 = 10000019;
int Hash::invp1 = -1;
int Hash::invp2 = -1;
const Hash Hash::ONE(1, 1);
const Hash Hash::ZERO(0, 0);
const Hash Hash::INVALID(-1, -1);
Hash Hash::UNIT(Hash::p1, Hash::p2);
Hash Hash::INV_UNIT(-1, -1);
inline Hash operator+(const Hash& a, const Hash& b) {
Hash ans(a.x1 + b.x1, a.x2 + b.x2);
if (ans.x1 >= Hash::mod1) ans.x1 -= Hash::mod1;
if (ans.x2 >= Hash::mod2) ans.x2 -= Hash::mod2;
return ans;
}
inline Hash operator-(const Hash& a, const Hash& b) {
Hash ans(a.x1 - b.x1, a.x2 - b.x2);
if (ans.x1 < 0) ans.x1 += Hash::mod1;
if (ans.x2 < 0) ans.x2 += Hash::mod2;
return ans;
}
inline Hash operator*(const Hash& a, const Hash& b) {
return Hash((long long)a.x1 * b.x1 % Hash::mod1,
(long long)a.x2 * b.x2 % Hash::mod2);
}
inline Hash operator*(const Hash& a, const int& b) {
return Hash((long long)a.x1 * b % Hash::mod1,
(long long)a.x2 * b % Hash::mod2);
}
inline Hash operator^(const Hash& a, const int& power) {
int st = power;
Hash ans(1, 1), cur(a);
while (st) {
if (st % 2) ans *= cur;
cur *= cur;
st /= 2;
}
return ans;
}
inline Hash fpow(const Hash& a, const int& power) { return a ^ power; }
inline Hash invmod(const Hash& a) {
return Hash(invmod(a.x1, Hash::mod1), invmod(a.x2, Hash::mod2));
}
template <class H>
struct HashString : public string {
HashString() : string() { precalc(0); }
HashString(const HashString& other) : string(other) { precalc(size()); }
HashString(HashString&& other)
: hh(std::move(other.hh)), string(std::move(other)) {
precalc(size());
}
HashString(const string& other) : string(other) {
precalc(size());
build();
}
HashString(string&& other) : string(std::move(other)) {
precalc(size());
build();
}
HashString(const char* other) : string(other) {
precalc(size());
build();
}
inline void clear() {
hh.clear();
string::clear();
}
inline static H getPow(int p) {
if (p < haveN) {
return pp[p];
} else {
return fpow(H::UNIT, p);
}
}
inline static H getInvPow(size_t p) {
if (p < invpp.size()) {
return invpp[p];
} else {
return fpow(H::INV_UNIT, p);
}
}
inline H getInvRegister(const H& p) const {
if (p == register_) {
return registerValue_;
} else {
register_ = p;
return registerValue_ = invmod(p);
}
}
static void precalc(int N = 0) {
Hash::init();
if (haveN >= N) return;
pp.resize(N);
invpp.resize(N);
if (!haveN) {
pp[0] = H::ONE;
invpp[0] = H::ONE;
haveN = 1;
}
for (int i = haveN; i < N; ++i) {
pp[i] = pp[i - 1] * H::UNIT;
invpp[i] = invpp[i - 1] * H::INV_UNIT;
}
haveN = N;
}
inline void build() {
int curSize = size();
if (haveN <= curSize) {
precalc(curSize);
}
for (int i = hh.size(); i < curSize; ++i) {
H pr = i ? hh.back() : H::ZERO;
hh.push_back(pr + getPow(i) * (*this)[i]);
}
}
inline H getHash(int pos, int len) const {
if (len <= 0) return H::ZERO;
const int S = size();
if (pos + len - 1 < S) {
H ans = hh[pos + len - 1];
if (pos) {
ans -= hh[pos - 1];
ans *= getInvPow(pos);
}
return ans;
} else {
H head = hh.back();
if (pos) {
head -= hh[pos - 1];
head *= getInvPow(pos);
}
int full = -1, en = -1;
H mid = H::ZERO;
int midlen = 0;
if (len <= S) {
en = pos + len - 1 - S;
H tail = hh[en];
full = 0;
return head + tail * getPow(S - pos);
} else {
en = (pos + len - 1) % S;
H tail = hh[en];
full = (len - (S - pos) - (en + 1)) / S;
mid = hh.back() * (H::ONE - getInvPow(full * S)) *
getInvRegister(H::ONE - getInvPow(S));
return head + mid * getPow(S - pos) + tail * getPow(len - (en + 1));
}
}
}
inline HashString& operator+=(const char& ch) {
string::operator+=(ch);
build();
return *this;
}
inline HashString& operator+=(const HashString& other) {
string::operator+=(other);
build();
return *this;
}
inline bool operator==(const HashString& other) const {
return hh.back() == other.hh.back();
}
inline bool operator<(const HashString& other) const {
int s1 = size();
int s2 = other.size();
const int S = min(s1, s2);
int l = 0, r = S + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
if (getHash(0, xx) == other.getHash(0, xx))
l = xx;
else
r = xx;
}
char c1 = 0, c2 = 0;
if (l < s1) c1 = (*this)[l];
if (l < s2) c2 = other[l];
return c1 < c2;
}
inline bool operator<=(const HashString& other) const {
return (*this == other) || (*this < other);
}
inline bool operator>(const HashString& other) const {
return !(*this == other) && !(*this < other);
}
inline bool operator>=(const HashString& other) const {
return !(*this < other);
}
inline bool operator!=(const HashString& other) const {
return !(*this == other);
}
inline void reserve(int N) {
hh.reserve(N);
string::reserve(N);
}
vector<H> hh;
static vector<H> pp, invpp;
private:
mutable H register_, registerValue_;
static int haveN;
};
template <>
int HashString<Hash>::haveN = 0;
template <>
vector<Hash> HashString<Hash>::pp = vector<Hash>();
template <>
vector<Hash> HashString<Hash>::invpp = vector<Hash>();
template <class H, bool cyclic = true>
struct HashStringPiece {
explicit HashStringPiece(const HashString<H>& s, int pos, int len)
: s(s), pos(pos), len(len), hash(H::INVALID) {}
inline H getHash() const {
if (hash == H::INVALID) hash = s.getHash(pos, len);
return hash;
}
inline H getPartialHash(int needLen) const { return s.getHash(pos, needLen); }
inline char getChar(int i) const {
i += pos;
const int S = s.size();
if (i < S) return s[i];
if (!cyclic) return 0;
i -= S;
if (i < S) return s[i];
return s[i % S];
}
const HashString<H>& s;
const int pos, len;
mutable H hash;
};
template <class H, class T>
char getHSPRangeChar(T beg, T en, int pos) {
for (T it = beg; it != en; ++it) {
if (pos < it->len) {
return it->getChar(pos);
}
pos -= it->len;
}
return 0;
}
template <class H, class T>
H getHSPRangeHash(T beg, T en, int len) {
H ans = H::ZERO;
int cur = 0;
for (T it = beg; it != en; ++it) {
if (len >= it->len) {
ans += it->getHash() * it->s.getPow(cur);
cur += it->len;
len -= it->len;
} else {
ans += it->getPartialHash(len) * it->s.getPow(cur);
break;
}
}
return ans;
}
int TB, IT;
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, int len1, T beg2, T en2, int len2) {
if (beg1 == en1 && beg2 == en2) return 0;
if (beg1 == en1) return -1;
if (beg2 == en2) return 1;
int l = 0, r = min(len1, len2) + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
auto h1 = getHSPRangeHash<H, T>(beg1, en1, xx);
auto h2 = getHSPRangeHash<H, T>(beg2, en2, xx);
if (h1 == h2)
l = xx;
else
r = xx;
}
char c1 = getHSPRangeChar<H, T>(beg1, en1, l);
char c2 = getHSPRangeChar<H, T>(beg2, en2, l);
if (c1 < c2)
return -1;
else if (c1 == c2)
return 0;
else
return 1;
}
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, T beg2, T en2) {
int len1 = 0;
for (T it = beg1; it != en1; ++it) {
len1 += it->len;
}
int len2 = 0;
for (T it = beg2; it != en2; ++it) {
len2 += it->len;
}
return compareHSPRanges<H, T>(beg1, en1, len1, beg2, en2, len2);
}
int a, b, c, d, n, m, k;
char str[1000002];
int bal[2000002];
HashString<Hash> s;
inline string build(pair<pair<int, int>, int> a) {
string ans = "";
for (int _n((a.first.first) - 1), i(0); i <= _n; i++) ans += '(';
for (int _n((n)-1), i(0); i <= _n; i++) {
int cur = a.second + i;
if (cur >= n) cur -= n;
ans += str[cur];
}
for (int _n((a.first.second) - 1), i(0); i <= _n; i++) ans += ')';
return ans;
}
HashString<Hash> op, cl;
inline bool better(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b,
const HashString<Hash>& s) {
HashStringPiece<Hash> A[3] = {HashStringPiece<Hash>(op, 0, a.first.first),
HashStringPiece<Hash>(s, a.second, n),
HashStringPiece<Hash>(cl, 0, a.first.second)};
HashStringPiece<Hash> B[3] = {HashStringPiece<Hash>(op, 0, b.first.first),
HashStringPiece<Hash>(s, b.second, n),
HashStringPiece<Hash>(cl, 0, b.first.second)};
int t = compareHSPRanges<Hash>(A, A + 3, B, B + 3);
if (t == -1)
return 1;
else
return 0;
}
int main() {
gets(str);
n = (int)strlen(str);
HashString<Hash> s(str);
HashString<Hash>::precalc(2 * n + 1);
op.reserve(n + 1);
cl.reserve(n + 1);
for (int _n((n)-1), i(0); i <= _n; i++) {
op += '(';
cl += ')';
}
c = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (str[i] == '(')
++c;
else
--c;
}
bal[0] = 0;
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i) bal[i] = bal[i - 1];
int cur = i;
if (i >= n) cur = i - n;
if (str[cur] == '(')
++bal[i];
else
--bal[i];
}
int blen = 1000000000;
pair<pair<int, int>, int> best = make_pair(make_pair(0, 0), 0);
stack<pair<int, int> > s1, s2;
for (int _n((n)-1), i(0); i <= _n; i++) {
int new_element = bal[i];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
for (int _n((n)-1), cyc(0); cyc <= _n; cyc++) {
int current_minimum = -1000000000;
if (s1.empty() || s2.empty())
current_minimum = s1.empty() ? s2.top().second : s1.top().second;
else
current_minimum = min(s1.top().second, s2.top().second);
int p = 0;
if (cyc) p = bal[cyc - 1];
int mn = current_minimum - p;
int beg = max(0, -mn);
int en = c + beg;
int len = beg + en + n;
if (len < blen ||
(len == blen && better(make_pair(make_pair(beg, en), cyc), best, s))) {
blen = len;
best = make_pair(make_pair(beg, en), cyc);
}
if (s2.empty()) {
while (!s1.empty()) {
int element = s1.top().first;
s1.pop();
int minima = s2.empty() ? element : min(element, s2.top().second);
s2.push(make_pair(element, minima));
}
}
s2.pop();
int new_element = bal[cyc + n];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
string ans = build(best);
printf("%s\n", ans.c_str());
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int TOUR = 1 << 21, MOD = 1000000007, H = 3137;
struct tour {
int brot, brzat, dodot;
tour(int brot, int brzat, int dodot)
: brot(brot), brzat(brzat), dodot(dodot) {}
tour() {}
int vel() { return 2 * (brot + dodot); }
} t[2 * TOUR];
tour Merge(const tour &l, const tour &r) {
int dodr = max(0, r.dodot - (l.brot + l.dodot - l.brzat));
return tour(l.brot + r.brot, l.brzat + r.brzat, l.dodot + dodr);
}
char s[TOUR];
int len;
int hes[TOUR];
int pot[TOUR];
int Mul(int a, int b) { return ((long long)a * b) % MOD; }
int Add(int a, int b) { return (a + b) % MOD; }
int Sub(int a, int b) { return (a - b + MOD) % MOD; }
void GenHes() {
pot[0] = 1;
for (int i = 1; i < TOUR; i++) pot[i] = Mul(pot[i - 1], H);
for (int i = 1; i <= 2 * len; i++)
hes[i] = Add(Mul(hes[i - 1], H), s[(i - 1) % len] - '(' + 1);
}
int Manji(int a, int b) {
a++;
b++;
int lo = 0, hi = len;
for (; lo < hi;) {
int mid = (lo + hi + 1) / 2;
if (Sub(hes[a + mid - 1], Mul(hes[a - 1], pot[mid])) ==
Sub(hes[b + mid - 1], Mul(hes[b - 1], pot[mid])))
lo = mid;
else
hi = mid - 1;
}
return s[(a + lo - 1) % len] < s[(b + lo - 1) % len];
}
void Ispis(int poc, int dodot, int dodzat) {
for (int i = 0; i < dodot; i++) printf("(");
for (int i = 0; i < len; i++, poc++) printf("%c", s[poc % len]);
for (int i = 0; i < dodzat; i++) printf(")");
printf("\n");
}
void GenTour() {
for (int i = 2 * TOUR - 1; i; i--) {
if (i < TOUR)
t[i] = Merge(t[2 * i], t[2 * i + 1]);
else {
int poz = i - TOUR;
if (poz >= 2 * len) continue;
if (s[poz % len] == '(')
t[i] = tour(1, 0, 0);
else
t[i] = tour(0, 1, 1);
}
}
}
tour Vrati(int pos, int lo, int hi, int begin, int end) {
if (lo >= end || hi <= begin) return tour(0, 0, 0);
if (lo >= begin && hi <= end) return t[pos];
return Merge(Vrati(2 * pos + 0, lo, (lo + hi) / 2, begin, end),
Vrati(2 * pos + 1, (lo + hi) / 2, hi, begin, end));
}
int main() {
tour rje = tour(0, 0, 0);
int indr = 0;
scanf("%s", s);
len = (int)strlen(s);
GenTour();
GenHes();
for (int i = 0; i < len; i++) {
tour tmp = Vrati(1, 0, TOUR, i, i + len);
if (!i || tmp.vel() < rje.vel() ||
(tmp.vel() == rje.vel() && Manji(i, indr))) {
rje = tmp;
indr = i;
}
}
Ispis(indr, rje.dodot, rje.dodot + rje.brot - rje.brzat);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
char s[N];
int tp[N], rak[N], sa[N], tax[N], sl, m, lr_cnt[N], lg[N], f[N][20], rl_cnt[N];
void radixSort() {
for (int i = 1; i <= m; i++) tax[i] = 0;
for (int i = 1; i <= sl; i++) tax[rak[i]]++;
for (int i = 1; i <= m; i++) tax[i] += tax[i - 1];
for (int i = sl; i; i--) sa[tax[rak[tp[i]]]--] = tp[i];
}
void build_sa() {
m = 125;
for (int i = 1; i <= sl; i++) rak[i] = s[i], tp[i] = i;
radixSort();
for (int p = 0, w = 1; p < sl; w <<= 1, m = p) {
p = 0;
for (int i = 1; i <= w; i++) tp[++p] = sl - w + i;
for (int i = 1; i <= sl; i++)
if (sa[i] > w) tp[++p] = sa[i] - w;
radixSort();
swap(tp, rak);
rak[sa[1]] = p = 1;
for (int i = 2; i <= sl; i++)
rak[sa[i]] =
(tp[sa[i]] == tp[sa[i - 1]] && tp[sa[i] + w] == tp[sa[i - 1] + w])
? p
: ++p;
}
}
void make_st() {
int range = lg[sl];
if (lr_cnt[sl] > 0) {
for (int i = 1; i <= sl; i++) f[i][0] = lr_cnt[i];
for (int i = 1; i <= range; i++)
for (int j = 1; j + (1 << i) - 1 <= sl; j++)
f[j][i] = min(f[j][i - 1], f[j + (1 << (i - 1))][i - 1]);
} else {
for (int i = 1; i <= sl; i++) f[i][0] = rl_cnt[i];
for (int i = 1; i <= range; i++)
for (int j = 1; j + (1 << i) - 1 <= sl; j++)
f[j][i] = max(f[j][i - 1], f[j + (1 << (i - 1))][i - 1]);
}
}
int query(int l, int r) {
int range = lg[r - l + 1];
if (lr_cnt[sl] > 0)
return min(f[l][range], f[r - (1 << range) + 1][range]);
else
return max(f[l][range], f[r - (1 << range) + 1][range]);
}
int main() {
scanf("%s", s + 1);
sl = strlen(s + 1);
for (int i = 1; i <= sl; i++) s[i + sl] = s[i];
sl <<= 1;
build_sa();
for (int i = 1; i <= sl; i++)
lr_cnt[i] = lr_cnt[i - 1] + ((s[i] == '(') ? 1 : -1);
for (int i = sl; i; i--) rl_cnt[i] = rl_cnt[i + 1] + ((s[i] == '(') ? 1 : -1);
for (int i = 2; i <= sl; i++)
lg[i] = lg[i - 1] + (i == (1 << (lg[i - 1] + 1)));
make_st();
int l_fill = 0, r_fill = 0, ans_pos;
if (lr_cnt[sl] > 0)
r_fill = lr_cnt[sl] / 2;
else
l_fill = abs(lr_cnt[sl] / 2);
for (int i = 1; i <= sl; i++) {
int p = sa[i];
if (p > sl / 2) continue;
int res = query(p, p + sl / 2 - 1);
if (lr_cnt[sl] > 0) {
if (res - lr_cnt[p - 1] < 0) continue;
} else {
if (res - rl_cnt[p + sl / 2] > 0) continue;
}
ans_pos = p;
break;
}
for (int i = 1; i <= l_fill; i++) printf("(");
for (int i = ans_pos; i <= ans_pos + sl / 2 - 1; i++) printf("%c", s[i]);
for (int i = 1; i <= r_fill; i++) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
unsigned long long readTimeStampCounter() {
unsigned a = 123456789, b = 987654321;
asm("rdtsc;\n\t" : "=d"(a), "=a"(b));
return (unsigned long long)a << 32 | b;
}
unsigned xor128() {
static unsigned x = 123456789, y = 362436069,
z = (unsigned)(readTimeStampCounter() >> 32),
w = (unsigned)readTimeStampCounter();
unsigned t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = w ^ (w >> 19) ^ (t ^ (t >> 8));
}
struct SubstringHash {
static const int NumMods = 4;
static const unsigned Mods[NumMods];
struct Hash {
unsigned hs[NumMods];
Hash() {
for (int k = 0; k < NumMods; ++k) hs[k] = 0;
}
bool operator==(const Hash &that) const {
bool res = true;
for (int k = 0; k < NumMods; ++k) res &= hs[k] == that.hs[k];
return res;
}
bool operator<(const Hash &that) const {
for (int k = 0; k < NumMods; ++k)
if (hs[k] != that.hs[k]) return hs[k] < that.hs[k];
return false;
}
};
static unsigned seeds[NumMods];
static std::vector<Hash> powh;
std::vector<Hash> preh;
SubstringHash() {
if (seeds[0] == 0) initSeeds();
}
static void initSeeds() {
for (int k = 0; k < NumMods; ++k) {
unsigned x;
do x = xor128();
while (x == 0 || x >= Mods[k]);
seeds[k] = x;
}
}
static void expandPowH(int newSize) {
if ((int)powh.size() >= newSize) return;
int oldSize = powh.size();
powh.resize(newSize);
if (oldSize == 0)
for (int k = 0; k < NumMods; ++k) powh[0].hs[k] = 1;
for (int i = std::max(1, oldSize); i < newSize; i++)
for (int k = 0; k < NumMods; ++k)
powh[i].hs[k] =
(unsigned long long)powh[i - 1].hs[k] * seeds[k] % Mods[k];
}
template <typename V>
void init(const V &v, int n) {
expandPowH(n + 1);
preh.resize(n + 1);
preh[0] = Hash();
for (int i = 0; i < n; i++)
for (int k = 0; k < NumMods; ++k)
preh[i + 1].hs[k] =
((unsigned long long)preh[i].hs[k] * seeds[k] % Mods[k] + v[i]) %
Mods[k];
}
Hash hash(int j) const { return preh[j]; }
Hash hash(int i, int j) const {
if (i == 0) return hash(j);
Hash res;
for (int k = 0; k < NumMods; ++k) {
unsigned x = preh[j].hs[k] + Mods[k] -
(unsigned)((unsigned long long)preh[i].hs[k] *
powh[j - i].hs[k] % Mods[k]);
res.hs[k] = x >= Mods[k] ? x - Mods[k] : x;
}
return res;
}
Hash append(const Hash &h, const Hash &g, int glen) const {
Hash res;
for (int k = 0; k < NumMods; ++k) {
unsigned x =
(unsigned)((unsigned long long)h.hs[k] * powh[glen].hs[k] % Mods[k]) +
g.hs[k];
res.hs[k] = x >= Mods[k] ? x - Mods[k] : x;
}
return res;
}
};
const unsigned SubstringHash::Mods[SubstringHash::NumMods] = {
2147483647U, 2147483629U, 2147483587U, 2147483579U};
unsigned SubstringHash::seeds[SubstringHash::NumMods];
std::vector<SubstringHash::Hash> SubstringHash::powh;
struct Sum {
int miniLv, addLv;
Sum() : miniLv(0), addLv(0) {}
Sum(char c) : miniLv(c == '(' ? 0 : -1), addLv(c == '(' ? 1 : -1) {}
Sum operator+(const Sum &that) const {
Sum res;
res.miniLv = min(miniLv, addLv + that.miniLv);
res.addLv = addLv + that.addLv;
return res;
}
};
struct GetRangeSegmentTree {
static Sum combineVal(const Sum &x, const Sum &y) { return x + y; }
static void combinesVal(Sum &x, const Sum &y) { x = x + y; }
static Sum identityVal() { return Sum(); }
vector<Sum> nodes;
int n;
void init(int n_, const Sum &v = Sum()) { init(vector<Sum>(n_, v)); }
void init(const vector<Sum> &u) {
n = 1;
while (n < (int)u.size()) n *= 2;
nodes.resize(n, identityVal());
nodes.insert(nodes.end(), u.begin(), u.end());
nodes.resize(n * 2, identityVal());
for (int i = n - 1; i > 0; --i)
nodes[i] = combineVal(nodes[i * 2], nodes[i * 2 + 1]);
}
Sum get(int i) { return nodes[i + n]; }
Sum getWhole() const { return nodes[1]; }
Sum getRange(int l, int r) const {
Sum m = identityVal();
int indices[64];
int k = 0;
for (; l && l + (l & -l) <= r; l += l & -l)
combinesVal(m, nodes[(n + l) / (l & -l)]);
for (; l < r; r -= r & -r) indices[k++] = (n + r) / (r & -r) - 1;
while (--k >= 0) combinesVal(m, nodes[indices[k]]);
return m;
}
Sum getRangeCommutative(int l, int r) const {
Sum m = identityVal();
for (; l && l + (l & -l) <= r; l += l & -l)
combinesVal(m, nodes[(n + l) / (l & -l)]);
for (; l < r; r -= r & -r) combinesVal(m, nodes[(n + r) / (r & -r) - 1]);
return m;
}
void set(int i, const Sum &x) {
i += n;
nodes[i] = x;
for (i >>= 1; i > 0; i >>= 1)
nodes[i] = combineVal(nodes[i * 2], nodes[i * 2 + 1]);
}
};
SubstringHash::Hash getHash(int h1, int n, int i1, int mid,
const SubstringHash &subhS,
const SubstringHash &subhO,
const SubstringHash &subhC) {
if (mid <= h1)
return subhO.hash(0, mid);
else if (mid <= h1 + n)
return subhS.append(subhO.hash(0, mid), subhS.hash(i1, i1 + (mid - h1)),
mid - h1);
else
return subhC.append(
subhS.append(subhO.hash(0, mid), subhS.hash(i1, i1 + n), n),
subhC.hash(0, mid - h1 - n), mid - h1 - n);
}
char getChar(int h1, int n, int i1, int mid, const char *S) {
if (mid < h1)
return '(';
else if (mid < h1 + n)
return S[i1 + (mid - h1)];
else
return ')';
}
bool compare(int n, int len1, int len2, int i1, int i2, int h1, int h2,
const char *S, const SubstringHash &subhS,
const SubstringHash &subhO, const SubstringHash &subhC) {
if (len1 != len2) return len1 < len2;
int len = len1;
int l = 0, u = len;
while (u - l > 0) {
int mid = (l + u + 1) / 2;
SubstringHash::Hash h = getHash(h1, n, i1, mid, subhS, subhO, subhC);
SubstringHash::Hash g = getHash(h2, n, i2, mid, subhS, subhO, subhC);
if (h == g)
l = mid;
else
u = mid - 1;
}
return getChar(h1, n, i1, l, S) < getChar(h2, n, i2, l, S);
}
int main() {
char *S = new char[2000001];
char *ans = new char[2000001];
while (~scanf("%s", S)) {
int n = strlen(S);
for (int(i) = 0; (i) < (int)(n); ++(i)) S[n + i] = S[i];
S[n + n] = 0;
SubstringHash subhS, subhO, subhC;
subhS.init(S, n + n);
string O(n + n, '('), C(n + n, ')');
subhO.init(O, O.size());
subhC.init(C, C.size());
int minLen = 0x3f3f3f3f;
int minHead = 0, minPos = -1;
GetRangeSegmentTree segt;
segt.init(vector<Sum>(S, S + (n + n)));
for (int(i) = 0; (i) < (int)(n); ++(i)) {
Sum sum = segt.getRange(i, i + n);
int len = n + sum.addLv + -sum.miniLv * 2;
int head = -sum.miniLv;
if (compare(n, len, minLen, i, minPos, head, minHead, S, subhS, subhO,
subhC)) {
minLen = len;
minPos = i;
minHead = head;
}
}
char *p = ans;
for (int(k) = 0; (k) < (int)(minHead); ++(k)) *(p++) = '(';
for (int(i) = 0; (i) < (int)(n); ++(i)) *(p++) = S[minPos + i];
for (int(i) = 0; (i) < (int)(minLen - n - minHead); ++(i)) *(p++) = ')';
*p = 0;
puts(ans);
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2E6 + 5, MOD = 1E9 + 7;
int n, sum[N];
long long hsh[N], pw[N] = {1};
char s[N];
pair<int, int> ans = {N, N};
deque<int> de;
long long get_hash(int l, int r) {
return (hsh[r] - hsh[l - 1] * pw[r - l + 1] + 1LL * MOD * MOD) % MOD;
}
bool compare(int u, int v) {
int le = 0, ri = n - 1;
while (le <= ri) {
int mi = (le + ri) / 2;
if (get_hash(u, u + mi) == get_hash(v, v + mi)) {
le = mi + 1;
} else {
ri = mi - 1;
}
}
if (le == n) {
return true;
} else {
return s[u + le] < s[v + le];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s;
n = strlen(s);
for (int i = 0; i < n; i++) {
s[i + n] = s[i];
sum[i + n] = sum[i] = (s[i] == '(' ? 1 : -1);
hsh[i + n] = hsh[i] = (s[i] == '(' ? 0 : 1);
}
for (int i = 1; i < 2 * n; i++) {
sum[i] += sum[i - 1];
pw[i] = pw[i - 1] * 2 % MOD;
(hsh[i] += hsh[i - 1] * 2) %= MOD;
}
for (int i = 0; i < n; i++) {
while (!de.empty() && sum[de.back()] >= sum[i]) {
de.pop_back();
}
de.push_back(i);
}
for (int i = n; i < 2 * n; i++) {
int u = i - n + 1;
while (!de.empty() && sum[de.back()] >= sum[i]) {
de.pop_back();
}
de.push_back(i);
while (!de.empty() && de.front() < i - n) {
de.pop_front();
}
int len = sum[i - n] - sum[de.front()];
if (len < ans.first) {
ans = {len, u};
} else if (len == ans.first && compare(u, ans.second)) {
ans = {len, u};
}
}
for (int i = 0; i < ans.first; i++) {
cout << '(';
}
for (int i = 0; i < n; i++) {
cout << s[ans.second % n + i];
}
for (int i = 0; i < ans.first + sum[n - 1]; i++) {
cout << ')';
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long pow(long long a, long long b, long long mo) {
if (!a) return 0;
long long tmp = 1;
for (; b; b >>= 1) {
if (b & 1) tmp = (long long)tmp * a % mo;
a = (long long)a * a % mo;
}
return tmp;
}
template <class T>
inline void R(T &xx) {
xx = 0;
char ch = getchar();
bool F = 0;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') F = 1, ch = getchar();
while (ch >= '0' && ch <= '9')
xx = xx + xx + (xx << 3) + ch - 48, ch = getchar();
if (F) xx = -xx;
}
char s[2000011];
int n;
int w[2000011], wa[2000011], wb[2000011], sa[2000011], r[2000011];
void da(char a[], int n, int m) {
int p, *x = wa, *y = wb;
n++;
for (int i = (0); i <= (m); i++) w[i] = 0;
for (int i = 0; i < (int)(n); i++) w[r[i] = a[i]]++;
for (int i = (1); i <= (m); i++) w[i] += w[i - 1];
for (int i = 0; i < (int)(n); i++) sa[--w[a[i]]] = i;
for (int j = 1;; j <<= 1, m = p) {
p = 0;
for (int i = (n - j); i < (int)(n); i++) y[p++] = i;
for (int i = 0; i < (int)(n); i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = (0); i <= (m); i++) w[i] = 0;
for (int i = 0; i < (int)(n); i++) w[r[i]]++;
for (int i = (1); i <= (m); i++) w[i] += w[i - 1];
for (int i = (n)-1; ~i; i--) sa[--w[r[y[i]]]] = y[i];
for (int i = 0; i < (int)(n); i++) x[i] = r[i];
p = 1;
r[sa[0]] = 0;
for (int i = (1); i < (int)(n); i++)
r[sa[i]] = (x[sa[i]] == x[sa[i - 1]] && x[sa[i] + j] == x[sa[i - 1] + j])
? p - 1
: p++;
if (p == n) break;
}
}
pair<int, int> seg[2000011 << 2];
void build(int p, int l, int r) {
if (l == r) {
seg[p] = (s[l] == 1) ? make_pair(1, 0) : make_pair(-1, -1);
return;
}
int mid = l + r >> 1;
build((p << 1), l, mid);
build((p << 1 | 1), mid + 1, r);
seg[p] = make_pair(seg[(p << 1)].first + seg[(p << 1 | 1)].first,
min(seg[(p << 1)].second,
seg[(p << 1)].first + seg[(p << 1 | 1)].second));
}
pair<int, int> que(int p, int l, int r, int L, int R) {
if (L <= l && R >= r) return seg[p];
int mid = l + r >> 1;
if (R <= mid) return que((p << 1), l, mid, L, R);
if (L > mid) return que((p << 1 | 1), mid + 1, r, L, R);
pair<int, int> le = que((p << 1), l, mid, L, R),
ri = que((p << 1 | 1), mid + 1, r, L, R);
return make_pair(le.first + ri.first, min(le.second, le.first + ri.second));
}
int main() {
gets(s);
int l = n = strlen(s);
for (int i = 0; i < (int)(n); i++) s[i + n] = (s[i] = (s[i] == '(' ? 1 : 2));
n <<= 1;
da(s, n, 3);
int cnt = 0, addl = 0, addr = 0;
for (int i = 0; i < (int)(l); i++)
if (s[i] == 1)
cnt++;
else
cnt--;
if (cnt > 0)
addr = cnt;
else
addl = -cnt;
build(1, 0, n - 1);
for (int i = (1); i <= (n); i++)
if (sa[i] < l &&
addl + que(1, 0, n - 1, sa[i], sa[i] + l - 1).second >= 0) {
for (int j = 0; j < (int)(addl); j++) putchar('(');
for (int j = (sa[i]); j <= (sa[i] + l - 1); j++)
putchar((s[j] == 2) ? ')' : '(');
for (int j = 0; j < (int)(addr); j++) putchar(')');
puts("");
return 0;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, s[2000100];
bool vis[2000100];
char t[2000100];
int sa[2000100], rnk[2000100], tmp[2000100], cnt[2000100];
void build(char *s) {
int n = strlen(s) + 1, m = 256;
int *x = rnk, *y = tmp, *z;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i] = s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[y[i]]]] = y[i];
z = x, x = y, y = z;
x[sa[0]] = 0, p = 1;
for (int i = 1; i < n; i++)
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + j] == y[sa[i - 1] + j])
? p - 1
: p++;
}
for (int i = 0; i < n; i++) rnk[sa[i]] = i;
}
int main() {
scanf("%s", t + 1);
n = strlen(t + 1);
int mn = 0;
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1];
if (t[i] == '(')
s[i]++;
else
s[i]--;
mn = min(mn, s[i]);
}
for (int i = 1; i <= n; i++) t[n + i] = t[i], s[i + n] = s[i] + s[n];
int dn = 0;
if (s[n] < 0) dn = -s[n];
build(t + 1);
multiset<int> S;
for (int i = n + 1; i <= 2 * n; i++) S.insert(s[i]);
int k, p = 1e9;
for (int i = n; i >= 0; i--) {
int t = *S.begin();
S.erase(S.find(s[i + n]));
if (t - s[i] + dn >= 0) {
if (rnk[i] < p) p = rnk[i], k = i + 1;
}
S.insert(s[i]);
}
int sum = s[n];
if (sum < 0)
for (int i = sum; i < 0; i++) putchar('(');
for (int i = 0; i < n; i++) putchar(t[k + i]);
if (sum > 0)
for (int i = 0; i < sum; i++) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char str[1000006];
struct SuffixArray {
SuffixArray(string _s) { initialize(_s); };
void initialize(string _s = "") {
s = _s;
p.clear();
p.resize(s.size());
pn.clear();
pn.resize(s.size());
c.clear();
c.resize(s.size());
cn.clear();
cn.resize(s.size());
cnt.clear();
cnt.resize(alphabetSize = max(256, (int)s.size()));
}
void build(bool withLcp = false) {
for (int i = 0; i < s.size(); ++i) {
cnt[s[i]]++;
}
for (int i = 1; i < 256; ++i) cnt[i] += cnt[i - 1];
for (int i = s.size() - 1; i >= 0; --i) p[--cnt[s[i]]] = i;
int classes = 1;
c[p[0]] = 0;
for (int i = 1; i < p.size(); ++i) {
if (s[p[i]] != s[p[i - 1]]) ++classes;
c[p[i]] = classes - 1;
}
for (int h = 0; (1 << h) < s.size(); ++h) {
for (int i = 0; i < p.size(); ++i) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += s.size();
}
cnt.assign(alphabetSize, 0);
for (int i = 0; i < pn.size(); ++i) ++cnt[c[pn[i]]];
for (int i = 1; i < cnt.size(); ++i) cnt[i] += cnt[i - 1];
for (int i = pn.size() - 1; i >= 0; --i) {
p[--cnt[c[pn[i]]]] = pn[i];
}
classes = 1;
cn[p[0]] = 0;
for (int i = 1; i < p.size(); ++i) {
int mid1 = (p[i - 1] + (1 << h)) % s.size(),
mid2 = (p[i] + (1 << h)) % s.size();
if (c[p[i - 1]] != c[p[i]] || c[mid1] != c[mid2]) ++classes;
cn[p[i]] = classes - 1;
}
c = cn;
if (classes == s.size()) break;
}
if (withLcp) buildLcp();
}
void buildLcp() {
lcp.clear();
lcp.resize(s.size());
rev.clear();
rev.resize(s.size());
for (int i = 0; i < p.size(); ++i) rev[p[i]] = i;
int cur = 0;
for (int i = 0; i < s.size(); ++i) {
if (cur > 0) --cur;
if (rev[i] == 0) continue;
while (i + cur < s.size() && s[i + cur] == s[p[rev[i] - 1] + cur]) ++cur;
lcp[rev[i]] = cur;
}
}
void output() {
for (int i = 0; i < p.size(); ++i) cout << p[i] << " ";
cout << endl;
for (int i = 0; i < p.size(); ++i) {
cout << s.substr(p[i]) << endl;
}
if (lcp.size() == s.size()) {
for (int i = 0; i < lcp.size(); ++i) cout << lcp[i] << " ";
cout << endl;
}
}
string s;
int alphabetSize;
vector<int> p, c, pn, cn, cnt, lcp, rev;
};
int bal[1000006];
int pref[1000006];
int suf[1000006];
int main() {
gets(str);
int n = strlen(str);
SuffixArray sufa(str);
sufa.build();
int open = 0, cl = 0;
for (int i = 0; i < n; ++i) {
bal[i] += str[i] == '(' ? 1 : -1;
if (i) bal[i] += bal[i - 1];
if (str[i] == '(')
++open;
else
++cl;
}
for (int i = 0; i < n; ++i) {
pref[i] = bal[i];
if (i) pref[i] = min(pref[i], pref[i - 1]);
}
for (int i = n - 1; i >= 0; --i) {
suf[i] = bal[i];
if (i + 1 < n) suf[i] = min(suf[i], suf[i + 1]);
}
int mx = -100000000, mn = 100000000;
for (int i = 0; i < n; ++i) {
int total = 0;
total = min(suf[i] - (i > 0 ? bal[i - 1] : 0), 0);
total =
min(bal[n - 1] - (i > 0 ? bal[i - 1] : 0) + (i > 0 ? pref[i - 1] : 0),
total);
if (total >= 0)
mn = min(mn, total);
else {
mx = max(mx, total);
}
}
string s1 = "", s2 = "";
for (int i = 0; i < n; ++i) {
int ind = sufa.p[i];
int total = 0;
total = min(suf[ind] - (ind > 0 ? bal[ind - 1] : 0), 0);
total = min(bal[n - 1] - (ind > 0 ? bal[ind - 1] : 0) +
(ind > 0 ? pref[ind - 1] : 0),
total);
if (s1 == "" && total == mx) {
s1 = string(-total, '(');
for (int j = 0; j < n; ++j) s1 += str[(ind + j) % n];
int add = -total + open - cl;
if (add > 0) s1 += string(add, ')');
}
if (s2 == "" && total == mn) {
for (int j = 0; j < n; ++j) s2 += str[(ind + j) % n];
int add = open - cl;
if (add > 0) s2 += string(add, ')');
}
}
string s;
if (s1 != "") s = s1;
if (s2 != "" &&
(s == "" || s.size() > s2.size() || s.size() == s2.size() && s > s2))
s = s2;
printf("%s\n", s.c_str());
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int N = 2000010;
int sa[N], t[N], t2[N], c[N], wt[N];
bool cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void build_sa(char *s, int n, int m) {
int p = 1, *x = t, *y = t2;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[i] = s[i]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
for (int j = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) {
y[p++] = sa[i] - j;
}
for (int i = 0; i < n; i++) wt[i] = x[y[i]];
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[wt[i]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) {
sa[--c[wt[i]]] = y[i];
}
std::swap(x, y);
p = 1, x[sa[0]] = 0;
for (int i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
int rnk[N], H[N];
void getheight(char *s, int n) {
int i, j, k = 0;
for (i = 1; i <= n; i++) rnk[sa[i]] = i;
for (i = 0; i < n; H[rnk[i++]] = k)
for (k ? k-- : 0, j = sa[rnk[i] - 1]; s[i + 1] == s[j + k]; k++)
;
}
char s[N];
int sum[N];
int min[N][25];
void build_rmq(int *sum, int n) {
for (int i = 0; i < n; i++) min[i][0] = sum[i];
for (int j = 1, p = 2; p < n; j++, p <<= 1) {
for (int i = 0; i + p - 1 < n; i++) {
min[i][j] = std::min(min[i][j - 1], min[i + p / 2][j - 1]);
}
}
}
int Getmin(int a, int b) {
if (a > b) std::swap(a, b);
int k = log(1.0 * (b - a + 1)) / log(2.0);
return std::min(min[a][k], min[b - (1 << k) + 1][k]);
}
int A, B;
void Go(int n) {
int res = -1;
for (int i = 1; i <= n; i++) {
if (sa[i] >= n / 2) continue;
int low = Getmin(sa[i], sa[i] + n / 2 - 1);
if (sa[i]) low -= sum[sa[i] - 1];
if (low < 0 && low - A < 0) continue;
res = sa[i];
break;
}
assert(res != -1);
if (A < 0) {
for (int i = 0; i < -A; i++) putchar('(');
}
for (int i = res; i < res + n / 2; i++) putchar(s[i]);
if (A > 0) {
for (int i = 0; i < A; i++) putchar(')');
}
puts("");
}
int main() {
int n;
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) {
s[i + n] = s[i];
if (s[i] == '(') {
sum[i] = sum[i + n] = 1;
} else {
sum[i] = sum[i + n] = -1;
}
if (s[i] == '(')
A++;
else
B++;
}
A -= B;
n <<= 1;
for (int i = 1; i < n; i++) {
sum[i] += sum[i - 1];
}
build_rmq(sum, n);
s[n] = 0;
build_sa(s, n + 1, 45);
Go(n);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
const int M = 4e6 + 3;
const int ym = 2e6;
const int oo = 1e9;
const int OS = 317;
const int MOD = 1e9 + 7;
char s[N];
int n, stp[M], p1[N], p2[N], s1[N], s2[N], ho[N], hz[N], h[N], op[N], zp[N],
os[N], zs[N], il[N], ir[N];
vector<int> st;
int get(int i, int ln) {
int ans, tmp, lt, l;
lt = min(il[i], ln);
ans = ho[lt] * 1LL * stp[ym] % MOD;
l = lt;
lt = max(0, min(n - i, ln - l));
if (lt) ans = (ans + (h[i + lt] - h[i]) * 1LL * stp[ym + l - i] % MOD) % MOD;
l += lt;
lt = max(0, min(i, ln - l));
if (lt) ans = (ans + h[lt] * 1LL * stp[ym + l] % MOD) % MOD;
l += lt;
lt = max(0, ln - l);
if (lt) ans = (ans + hz[lt] * 1LL * stp[ym + l] % MOD) % MOD;
if (ans < 0) ans += MOD;
return ans;
}
int get_ch(int i, int ln) {
if (ln <= il[i]) return '(';
ln -= il[i];
if (ln <= n - i) return s[i + ln];
ln -= n - i;
if (ln <= i)
return s[ln];
else
return ')';
}
int ans;
bool cmp(int i, int j) {
int l, r, x;
l = 1, r = ans;
while (l <= r) {
x = (l + r) >> 1;
if (get(i, x) == get(j, x))
l = x + 1;
else
r = x - 1;
}
return get_ch(i, r + 1) <= get_ch(j, r + 1);
}
int main() {
if (0) {
freopen("input.txt", "w", stdout);
int n = 1e6;
for (int i = 0; i < n; ++i) printf("(");
printf("\n");
return 0;
}
int i, j, len, mn;
gets(s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; ++i)
if (s[i] == '(')
p1[i] = p1[i - 1], p2[i] = p2[i - 1] + 1;
else if (p2[i - 1])
p1[i] = p1[i - 1] + 2, p2[i] = p2[i - 1] - 1;
else
p1[i] = p1[i - 1], p2[i] = p2[i - 1];
for (i = n; i; --i)
if (s[i] == ')')
s1[i] = s1[i + 1], s2[i] = s2[i + 1] + 1;
else if (s2[i + 1])
s1[i] = s1[i + 1] + 2, s2[i] = s2[i + 1] - 1;
else
s1[i] = s1[i + 1], s2[i] = s2[i + 1];
for (i = 0; i <= n; ++i) {
op[i] = p2[i];
zp[i] = i - p1[i] - op[i];
zs[i] = s2[i + 1];
os[i] = n - i - s1[i + 1] - zs[i];
il[i] = zs[i];
ir[i] = op[i];
if (os[i] > zp[i])
ir[i] += os[i] - zp[i];
else
il[i] += zp[i] - os[i];
}
ans = oo;
for (i = 0; i < n; ++i) {
len = n + zs[i] + op[i] + max(os[i], zp[i]) - min(os[i], zp[i]);
if (ans > len) st.clear();
if (ans >= len) ans = len, st.push_back(i);
}
stp[0] = 1;
for (i = 1; i < M; ++i) stp[i] = (stp[i - 1] * 1LL * OS) % MOD;
ho[0] = hz[0] = 0;
for (i = 1; i < N; ++i)
ho[i] = (ho[i - 1] + '(' * 1LL * stp[i - 1] % MOD) % MOD;
for (i = 1; i < N; ++i)
hz[i] = (hz[i - 1] + ')' * 1LL * stp[i - 1] % MOD) % MOD;
h[0] = 0;
for (i = 1; i <= n; ++i)
h[i] = (h[i - 1] + s[i] * 1LL * stp[i - 1] % MOD) % MOD;
mn = st[0];
for (i = 1; i < st.size(); ++i)
if (cmp(st[i], mn)) mn = st[i];
i = mn;
for (j = 0; j < il[i]; ++j) putchar('(');
for (j = i + 1; j <= n; ++j) putchar(s[j]);
for (j = 1; j <= i; ++j) putchar(s[j]);
for (j = 0; j < ir[i]; ++j) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int LEN = 2000100 * 3;
int r[LEN], sa[LEN];
int wa[LEN], wb[LEN], wv[LEN], ss[LEN];
int c0(int *r, int a, int b) {
return r[a] == r[b] && r[a + 1] == r[b + 1] && r[a + 2] == r[b + 2];
}
int c12(int k, int *r, int a, int b) {
if (k == 2) return r[a] < r[b] || r[a] == r[b] && c12(1, r, a + 1, b + 1);
return r[a] < r[b] || r[a] == r[b] && wv[a + 1] < wv[b + 1];
}
void sort(int *r, int *a, int *b, int n, int m) {
for (int i = 0; i < n; i++) wv[i] = r[a[i]];
for (int i = 0; i < m; i++) ss[i] = 0;
for (int i = 0; i < n; i++) ss[wv[i]]++;
for (int i = 1; i < m; i++) ss[i] += ss[i - 1];
for (int i = n - 1; i >= 0; i--) b[--ss[wv[i]]] = a[i];
}
void DC3(int *r, int *sa, int n, int m) {
int i, j, p;
int *san = sa + n, *rn = r + n;
int ta = 0, tb = (n + 1) / 3, tbc = 0;
r[n] = r[n + 1] = 0;
for (i = 0; i < n; i++)
if (i % 3 != 0) wa[tbc++] = i;
sort(r + 2, wa, wb, tbc, m);
sort(r + 1, wb, wa, tbc, m);
sort(r, wa, wb, tbc, m);
for (p = 1, rn[((wb[0]) / 3 + ((wb[0]) % 3 == 1 ? 0 : tb))] = 0, i = 1;
i < tbc; i++)
rn[((wb[i]) / 3 + ((wb[i]) % 3 == 1 ? 0 : tb))] =
c0(r, wb[i - 1], wb[i]) ? p - 1 : p++;
if (p < tbc)
DC3(rn, san, tbc, p);
else
for (i = 0; i < tbc; i++) san[rn[i]] = i;
for (i = 0; i < tbc; i++)
if (san[i] < tb) wb[ta++] = san[i] * 3;
if (n % 3 == 1) wb[ta++] = n - 1;
sort(r, wb, wa, ta, m);
for (i = 0; i < tbc; i++)
wv[wb[i] = ((san[i]) < tb ? (san[i]) * 3 + 1 : ((san[i]) - tb) * 3 + 2)] =
i;
for (i = 0, j = 0, p = 0; i < ta && j < tbc; p++)
sa[p] = c12(wb[j] % 3, r, wa[i], wb[j]) ? wa[i++] : wb[j++];
for (; i < ta; p++) sa[p] = wa[i++];
for (; j < tbc; p++) sa[p] = wb[j++];
}
char s[2000100];
int val[2000100];
int rmq[20][1000100];
int query(int l, int r) {
int cnt = r - l + 1, i;
for (i = 0; (1 << i) <= cnt; i++)
;
i--;
return ((rmq[i][l]) < (rmq[i][r - (1 << i) + 1])
? (rmq[i][l])
: (rmq[i][r - (1 << i) + 1]));
}
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) r[i] = r[i + len] = s[i];
r[len << 1] = 0;
DC3(r, sa, len << 1 | 1, 256);
int cur = 0;
int ca = 0, cb = 0;
for (int i = 0; i < len; i++) {
if (s[i] == '(')
cur++;
else
cur--;
val[i] = cur;
}
if (cur > 0)
ca = 0, cb = cur;
else
ca = -cur, cb = 0;
for (int i = 0; i < len; i++) rmq[0][i] = val[i];
for (int j = 1; (1 << j) <= len; j++) {
int k = 1 << (j - 1);
for (int i = 0; i + (1 << j) <= len; i++) {
rmq[j][i] = ((rmq[j - 1][i]) < (rmq[j - 1][i + k]) ? (rmq[j - 1][i])
: (rmq[j - 1][i + k]));
}
}
int pos;
for (int j = 0; j <= len + len; j++)
if (sa[j] < len) {
int i = sa[j];
int init = val[i] - ((s[i] == '(') ? 1 : -1);
int Min = query(i, len - 1) - init;
if (Min + ca < 0) continue;
if (i >= 1) {
init = val[len - 1] - init;
Min = query(0, i - 1) + init + ca;
if (Min < 0) continue;
}
pos = i;
break;
}
for (int i = 0; i < ca; i++) putchar('(');
for (int i = pos; i < len; i++) putchar(s[i]);
for (int i = 0; i < pos; i++) putchar(s[i]);
for (int i = 0; i < cb; i++) putchar(')');
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <typename T>
inline int bit(T mask, int b) {
return (b >= 0 && (mask & (T(1) << b)) != 0) ? 1 : 0;
}
inline int nextInt() {
int x;
if (scanf("%d", &x) != 1) throw;
return x;
}
inline long long nextInt64() {
long long x;
if (scanf("%lld", &x) != 1) throw;
return x;
}
inline double nextDouble() {
double x;
if (scanf("%lf", &x) != 1) throw;
return x;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int MAXN = 3001000;
struct state {
state() {}
state(int a, int b, int i) : a(a), b(b), id(i) {}
bool operator<(const state& s) const {
if (a != s.a) return a < s.a;
if (b != s.b) return b < s.b;
return id < s.id;
}
bool operator!=(const state& s) const { return a != s.a || b != s.b; }
int a, b, id;
};
int n, b[MAXN], fw[MAXN], p[MAXN];
multiset<int> ms;
state v[MAXN];
char s[MAXN];
struct answer {
answer(int b, int a, int i) : before(b), after(a), id(i) {}
bool operator<(const answer& a) const {
if (before + after != a.before + a.after)
return before + after < a.before + a.after;
if (before + fw[id] != a.before + fw[a.id])
return before + fw[id] > a.before + fw[a.id];
return p[(id + fw[id]) % n] < p[(a.id + fw[a.id]) % n];
}
int before, after, id;
};
int getms(int v) {
int prv = (v == 0) ? 0 : b[v - 1];
return max(0, prv - (*ms.begin()));
}
int sum(int before, int v) {
int prv = (v == 0) ? 0 : b[v - 1];
return b[v + n - 1] - prv + before;
}
void go(int v) {
ms.erase(ms.find(b[v]));
ms.insert(b[v + n]);
}
int main() {
cout.setf(ios::fixed);
cout.precision(10);
double _startTime = clock();
scanf(" %s", s);
n = int(strlen(s));
for (int i = 0; i < (int)(n); i++) {
s[i + n] = s[i];
}
int bal = 0;
for (int i = 0; i < (int)(2 * n); i++) {
if (s[i] == '(') {
p[i] = 0;
++bal;
} else {
p[i] = 1;
--bal;
}
b[i] = bal;
}
for (int i = (int)(n)-1; i >= 0; i--) {
ms.insert(b[i]);
if (s[i] == '(') {
fw[i] = fw[i + 1] + 1;
}
}
int k = 1;
while (k < n) {
for (int i = 0; i < (int)(n); i++) {
v[i] = state(p[i], p[(i + k) % n], i);
}
int cur = 0;
sort(v, v + n);
for (int i = 0; i < (int)(n); i++) {
p[v[i].id] = cur;
if (v[i] != v[i + 1]) {
++cur;
}
}
if (cur == n - 1) break;
k *= 2;
}
answer ans(INF, INF, -1);
for (int i = 0; i < (int)(n); i++) {
int before = getms(i);
answer cur(before, sum(before, i), i);
ans = min(ans, cur);
go(i);
};
cout << string(size_t(ans.before), '(');
for (int i = 0; i < (int)(n); i++) {
cout << s[ans.id + i];
}
cout << string(size_t(ans.after), ')') << endl;
cerr << "Elapsed " << (clock() - _startTime) / CLOCKS_PER_SEC << " s" << endl;
return 0;
};
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
class SA_IS {
vector<int> compress(vector<int>& v) {
set<int> alph(v.begin(), v.end());
vector<int> dic(alph.begin(), alph.end());
vector<int> bucket_size(dic.size(), 0);
for (int i = 0; i < v.size(); i++) {
v[i] = lower_bound(dic.begin(), dic.end(), v[i]) - dic.begin();
bucket_size[v[i]]++;
}
return bucket_size;
}
public:
static const int L = 0;
static const int S = 1;
string my_s;
vector<int> sa;
vector<int> lcp;
struct substring {
int pos;
int size;
vector<int>::iterator str;
vector<int>::iterator ls;
substring() {}
substring(const int pos, const int size, const vector<int>::iterator& str,
const vector<int>::iterator& ls) {
this->pos = pos;
this->size = size;
this->str = str;
this->ls = ls;
}
bool operator<(const substring& x) const {
for (int i = 0; i < min(this->size, x.size); i++) {
if (this->str[i] != x.str[i]) {
return this->str[i] < x.str[i];
} else if (this->ls[i] != x.ls[i]) {
return this->ls[i] == SA_IS::L;
}
}
return this->size < x.size;
}
bool operator==(const substring& x) const {
for (int i = 0; i < min(this->size, x.size); i++) {
if (this->str[i] != x.str[i]) {
return false;
} else if (this->ls[i] != x.ls[i]) {
return false;
}
}
return this->size == x.size;
}
substring operator=(const substring& x) {
this->pos = x.pos;
this->size = x.size;
this->str = x.str;
this->ls = x.ls;
return *this;
}
};
vector<int> rec(vector<int> v) {
v.push_back(-1);
vector<int> bucket_size = compress(v);
vector<int> ret(v.size(), -1);
vector<vector<int>::iterator> bucket(bucket_size.size());
vector<bool> fixed(v.size(), false);
vector<vector<bool>::iterator> bucket_fixed(bucket_size.size());
vector<int> bucket_front(bucket_size.size());
vector<int> bucket_back(bucket_size.size());
vector<bool> used(v.size(), false);
{
int sum = 0;
for (int i = 0; i < bucket_size.size(); i++) {
bucket[i] = ret.begin() + sum;
bucket_fixed[i] = fixed.begin() + sum;
bucket_front[i] = 0;
bucket_back[i] = bucket_size[i] - 1;
sum += bucket_size[i];
}
}
vector<int> LS(v.size());
LS.back() = S;
for (int i = v.size() - 2; i >= 0; i--) {
if (v[i] < v[i + 1])
LS[i] = S;
else if (v[i] > v[i + 1])
LS[i] = L;
else
LS[i] = LS[i + 1];
}
vector<int> LMS;
for (int i = 1; i < v.size(); i++) {
if (LS[i] != S) continue;
if (LS[i - 1] == L) LMS.push_back(i);
}
LMS.push_back(v.size() - 1);
vector<pair<substring, int>> LMS_substring;
for (int i = 0; i < LMS.size() - 1; i++) {
substring sub(LMS[i], LMS[i + 1] - LMS[i] + 1, v.begin() + LMS[i],
LS.begin() + LMS[i]);
LMS_substring.push_back({sub, LMS_substring.size()});
}
if (LMS_substring.size() > 0) {
vector<pair<substring, int>> LMS_substring_old = LMS_substring;
sort(LMS_substring.begin(), LMS_substring.end());
vector<int> LMS_order(LMS_substring.size());
int cnt = 0;
LMS_order[LMS_substring[0].second] = cnt;
cnt++;
for (int i = 1; i < LMS_substring.size(); i++) {
if (LMS_substring[i].first == LMS_substring[i - 1].first) {
LMS_order[LMS_substring[i].second] = cnt - 1;
} else {
LMS_order[LMS_substring[i].second] = cnt;
cnt++;
}
}
if (cnt != LMS_substring.size()) {
vector<int> new_order = rec(LMS_order);
LMS_order = vector<int>(new_order.begin() + 1, new_order.end());
for (int i = 0; i < LMS_substring.size(); i++) {
LMS_substring[i].first = LMS_substring_old[LMS_order[i]].first;
}
}
for (int i = LMS_substring.size() - 1; i >= 0; i--) {
int c = v[LMS_substring[i].first.pos];
bucket[c][bucket_back[c]] = LMS_substring[i].first.pos;
bucket_back[c]--;
}
}
for (int i = 0; i < bucket_size.size(); i++) {
for (int j = 0; j < bucket_size[i]; j++) {
if (bucket[i][j] - 1 < 0) continue;
if (LS[bucket[i][j] - 1] == L) {
if (used[bucket[i][j] - 1]) continue;
used[bucket[i][j] - 1] = true;
int c = v[bucket[i][j] - 1];
bucket[c][bucket_front[c]] = bucket[i][j] - 1;
bucket_fixed[c][bucket_front[c]] = true;
bucket_front[c]++;
}
}
bucket_back[i] = bucket_size[i] - 1;
}
for (int i = 0; i < v.size(); i++) {
if (fixed[i] == false) {
ret[i] = -1;
}
}
for (int i = bucket_size.size() - 1; i >= 0; i--) {
for (int j = bucket_size[i] - 1; j >= 0; j--) {
if (bucket[i][j] - 1 < 0) continue;
if (LS[bucket[i][j] - 1] == S) {
if (used[bucket[i][j] - 1]) continue;
used[bucket[i][j] - 1] = true;
int c = v[bucket[i][j] - 1];
bucket[c][bucket_back[c]] = bucket[i][j] - 1;
bucket_fixed[c][bucket_back[c]] = true;
bucket_back[c]--;
}
}
}
ret[0] = ret.size() - 1;
return ret;
}
vector<int> rec(string& s) {
vector<int> v(s.begin(), s.end());
return rec(v);
}
void constract_lcp() {
int n = my_s.size();
lcp.resize(n + 1);
vector<int> rank(n + 1);
for (int i = 0; i <= n; i++) rank[sa[i]] = i;
int h = 0;
lcp[0] = 0;
for (int i = 0; i < n; i++) {
int j = sa[rank[i] - 1];
if (h > 0) h--;
for (; j + h < n && i + h < n; h++) {
if (my_s[j + h] != my_s[i + h]) break;
}
lcp[rank[i] - 1] = h;
}
}
SA_IS(string s) {
my_s = s;
sa = rec(s);
}
void dbg_print() {
for (int i = 0; i <= my_s.size(); i++) {
string p(my_s.begin() + sa[i], my_s.end());
cerr << p << " " << sa[i] << endl;
}
}
};
class SegmentTreeMIN {
int n;
vector<int> T;
int INF;
public:
SegmentTreeMIN(int size) {
INF = 1 << 29;
n = 1;
while (n < size) n <<= 1;
T.resize(2 * n - 1);
fill(T.begin(), T.end(), INF);
}
void update(int k, int val) {
k += n - 1;
T[k] = val;
while (k > 0) {
k = (k - 1) / 2;
T[k] = min(T[k * 2 + 1], T[k * 2 + 2]);
}
}
int RMQ(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return INF;
if (a <= l && r <= b)
return T[k];
else {
int val_left = RMQ(a, b, k * 2 + 1, l, (l + r) / 2);
int val_right = RMQ(a, b, k * 2 + 2, (l + r) / 2, r);
return min(val_left, val_right);
}
}
int size() { return n; }
};
int main() {
string s;
cin >> s;
int n = s.size();
s += s;
SA_IS sa(s);
vector<int> arr(2 * n);
for (int i = 0; i < 2 * n; i++) {
if (s[i] == '(') {
arr[i] = 1;
} else {
arr[i] = -1;
}
if (i > 0) arr[i] += arr[i - 1];
}
SegmentTreeMIN seg(2 * n);
for (int i = 0; i < 2 * n; i++) {
seg.update(i, arr[i]);
}
int index = -1;
int len = 1 << 30;
int xx = 0;
int yy = 0;
for (int i = 0; i < 2 * n; i++) {
if (sa.sa[i] > n) continue;
int x = min(0, seg.RMQ(sa.sa[i], sa.sa[i] + n, 0, 0, seg.size()) -
(sa.sa[i] > 0 ? arr[sa.sa[i] - 1] : 0));
int y = max(0, arr[sa.sa[i] + n - 1] -
(sa.sa[i] > 0 ? arr[sa.sa[i] - 1] : 0) + abs(x));
if (len > abs(x) + abs(y) + n) {
index = i;
len = abs(x) + abs(y) + n;
xx = abs(x);
yy = abs(y);
}
}
string ans;
for (int j = 0; j < xx; j++) {
printf("(");
}
cout << s.substr(sa.sa[index], n);
for (int j = 0; j < yy; j++) {
printf(")");
}
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, LG = 21;
int sp[LG][maxn], arr[maxn];
int mn[maxn];
vector<int> vec;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
string s;
cin >> s;
int n = int((s).size()), SM = 0;
for (int i = 0; i < n; i++) {
SM += s[i] == '(' ? 1 : -1;
}
for (int i = 0; i < n; i++) {
sp[0][i] = s[i] == ')';
arr[i] = i;
}
int lg = 0;
for (int i = 1; (1 << i) <= n; i++) {
lg = i;
int pw = 1 << (i - 1);
auto f = [&](int a, int b) {
if (sp[i - 1][a] != sp[i - 1][b]) return sp[i - 1][a] < sp[i - 1][b];
a += pw, b += pw;
if (a >= n) a -= n;
if (b >= n) b -= n;
return sp[i - 1][a] < sp[i - 1][b];
};
sort(arr, arr + n, f);
for (int j = 1; j < n; j++) {
sp[i][arr[j]] =
sp[i][arr[j - 1]] + (f(arr[j - 1], arr[j]) || f(arr[j], arr[j - 1]));
}
}
for (int i = 0; i < n; i++) {
mn[i] = (i == 0 ? 0 : mn[i - 1]) + (s[i] == '(' ? 1 : -1);
}
for (int i = 1; i < n; i++) {
mn[i] = min(mn[i - 1], mn[i]);
}
int sm = 0, mm = 0, pos = -1;
auto cmp = [&](int a, int b) {
int lc = 0;
for (int i = lg; i >= 0; i--) {
if (lc + (1 << i) <= n && sp[i][a] == sp[i][b])
a += (1 << i), b += (1 << i), lc += (1 << i), a %= n, b %= n;
}
return s[a] < s[b];
};
for (int i = n - 1; i >= 0; i--) {
int x = s[i] == '(' ? 1 : -1;
mm += x;
sm += x;
mm = min(mm, x);
int bf = (i == 0 ? 0 : mn[i - 1]);
if (min(mm, sm + bf) + max(-SM, 0) >= 0) {
if (pos == -1)
pos = i;
else if (cmp(i, pos))
pos = i;
}
}
string ans, ss;
for (int i = 0; i < n; i++) {
ans += s[(i + pos) % n];
}
if (SM < 0) {
while (SM < 0) ss += '(', SM++;
ans = ss + ans;
} else {
while (SM > 0) ss += ')', SM--;
ans = ans + ss;
}
return cout << ans << endl, 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,inline,unroll-loops,fast-math")
using namespace std;
char a[2000020];
int f[2000020], g[2000020], h[2000020];
deque<int> q;
void InitSA(char *s, int n, int m) {
static int l[2000020], r[2000020], c[2000020];
int i, p, k;
int *x, *y;
x = l;
y = r;
for (i = 0; i < n; i++) {
x[i] = s[i + 1];
c[x[i]]++;
}
for (i = 2; i <= m; i++) c[i] += c[i - 1];
for (i = n - 1; i > -1; i--) f[--c[x[i]]] = i;
for (k = 1; k <= n; k <<= 1) {
for (i = n - k, p = 0; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (f[i] >= k) y[p++] = f[i] - k;
for (i = 1; i <= m; i++) c[i] = 0;
for (i = 0; i < n; i++) c[x[i]]++;
for (i = 2; i <= m; i++) c[i] += c[i - 1];
for (i = n - 1; i > -1; i--) f[--c[x[y[i]]]] = y[i];
swap(x, y);
for (i = x[f[0]] = m = 1; i < n; i++)
x[f[i]] =
y[f[i]] == y[f[i - 1]] && y[f[i] + k] == y[f[i - 1] + k] ? m : ++m;
if (m >= n) break;
}
return;
}
int main(void) {
int n;
int i;
scanf("%s", a + 1);
n = strlen(a + 1);
for (i = 1; i <= n; i++) a[i + n] = a[i];
InitSA(a, n * 2, ')');
for (i = 1; i <= n * 2; i++) {
g[i] = g[i - 1] + (a[i] == '(' ? 1 : -1);
for (; !q.empty() && i - q.front() > n; q.pop_front())
;
for (; !q.empty() && g[q.back()] > g[i]; q.pop_back())
;
q.push_back(i);
if (i >= n) h[i - n + 1] = g[q.front()];
}
if (g[n] < 0)
for (i = 0; i < -g[n]; i++) printf("(");
for (i = 0; i < n * 2; i++)
if (f[i] < n && h[f[i] + 1] - g[f[i]] >= min(g[n], 0)) break;
a[f[i] + 1 + n] = 0;
printf("%s", a + f[i] + 1);
if (g[n] > 0)
for (i = 0; i < g[n]; i++) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2E6 + 10;
const int BASE = 7;
const int MOD = 1E9 + 7;
char S[MAXN];
int N;
int pref[MAXN];
int mp[MAXN];
long long H[MAXN];
long long P[MAXN];
long long gethsh(int lft, int rgt) {
return (H[rgt] - H[lft] * P[rgt - lft] % MOD + MOD) % MOD;
}
bool equals(int a, int b, int len) {
return gethsh(a, a + len) == gethsh(b, b + len);
}
bool comp(int a, int b) {
int lo = 0, hi = N + 1;
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (equals(a, b, mid)) {
lo = mid;
} else {
hi = mid;
}
}
return S[a + lo] < S[b + lo];
}
void init_hsh() {
H[0] = 0;
for (int i = 0; i < N; ++i) {
H[i + 1] = (BASE * H[i] + S[i]) % MOD;
}
P[0] = 1;
for (int i = 0; i < MAXN - 1; ++i) {
P[i + 1] = BASE * P[i] % MOD;
}
}
void pop(deque<pair<int, int> >& dq, int idx) {
while (!dq.empty() && dq.front().first < idx) {
dq.pop_front();
}
}
void push(deque<pair<int, int> >& dq, pair<int, int> p) {
while (!dq.empty() && dq.back().second > p.second) {
dq.pop_back();
}
dq.push_back(p);
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
scanf("%s", S);
N = (int)(strlen(S));
memcpy(S + N, S, N);
N += N;
init_hsh();
for (int i = 0; i < N; ++i) {
pref[i + 1] = pref[i] + (S[i] == '(' ? 1 : -1);
}
N /= 2;
deque<pair<int, int> > dq;
for (int i = 0; i < N * 2; ++i) {
pop(dq, i - N + 1);
push(dq, pair<int, int>(i, pref[i + 1]));
if (i >= N - 1) {
mp[i - N + 1] = dq.front().second - pref[i - N + 1];
}
}
int best = -1;
for (int i = 0; i < N; ++i) {
if (mp[i] >= min(pref[N], 0) && (best == -1 || comp(i, best))) {
best = i;
}
}
for (int i = 0; i < -pref[N]; ++i) {
printf("(");
}
for (int i = 0; i < N; ++i) {
printf("%c", S[best + i]);
}
for (int i = 0; i < pref[N]; ++i) {
printf(")");
}
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int INF = 1e9;
const long long lINF = 1e18;
const double EPS = 1e-12;
using namespace std;
const int N = 1e6 + 100;
char s[N];
int p[N], c[N], last[N];
int pn[N], cn[N];
int n, balance[N], mnl[N], mnr[N];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) {
last[s[i] - 'a' + 1]++;
}
for (int i = 2; i <= 26; i++) {
last[i] += last[i - 1];
}
for (int i = 0; i < n; i++) {
c[i] = last[s[i] - 'a'];
}
for (int i = 0; i < n; i++) {
p[last[s[i] - 'a']++] = i;
}
for (int l = 1; l < n; l <<= 1) {
for (int i = 0; i < n; i++) last[i] = i;
for (int i = 0; i < n; i++) pn[i] = (p[i] - l + n) % n;
for (int i = 0; i < n; i++) p[last[c[pn[i]]]++] = pn[i];
cn[p[0]] = 0;
int nlast = 0;
for (int i = 1; i < n; i++) {
int mid1 = (p[i] + l) % n, mid2 = (p[i - 1] + l) % n;
if (c[p[i]] > c[p[i - 1]] || c[mid1] > c[mid2]) nlast = i;
cn[p[i]] = nlast;
}
memcpy(c, cn, n * sizeof(n));
}
mnl[0] = INF;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
balance[i + 1] = balance[i] + 1;
} else {
balance[i + 1] = balance[i] - 1;
}
mnl[i + 1] = min(balance[i + 1], mnl[i]);
}
mnr[n - 1] = balance[n];
for (int i = n - 2; i >= 0; i--) {
mnr[i] = min(mnr[i + 1], balance[i + 1]);
}
int ans = INF, ansi = 0, good = min(0, balance[n]);
for (int i = 0; i < n; i++) {
if (mnl[i] + balance[n] - balance[i] >= good &&
mnr[i] - balance[i] >= good) {
if (ans > c[i]) {
ans = c[i];
ansi = i;
}
}
}
for (int i = 0; i < -balance[n]; i++) {
putchar('(');
}
for (int i = ansi; i < ansi + n; i++) {
putchar(s[i % n]);
}
for (int i = 0; i < balance[n]; i++) {
putchar(')');
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2111111;
char buf[maxn];
int sum[maxn];
bool ok[maxn];
int order[maxn];
template <typename T>
void debug(T a[], int n) {
for (int i = 1; i <= n; ++i) {
cout << setw(3) << a[i];
}
puts("");
}
void fix(int& i, int n) {
while (!ok[i] && i <= n) {
++i;
}
}
int run(char s[], int m) {
int n = m >> 1;
int i = 1, j = 2, k = 0;
fix(i, n);
j = i + 1;
fix(j, n);
while (j <= n && i <= n) {
for (k = 0; k < n; ++k) {
if (s[i + k] ^ s[j + k]) {
break;
}
}
if (s[i + k] > s[j + k]) {
i += k + 1;
fix(i, n);
} else {
j += k + 1;
fix(j, n);
}
if (j == i) {
++j;
fix(j, n);
}
}
return std::min(i, j);
}
int main() {
for (int i = 1; i < 100; ++i) {
order[i] = i;
}
scanf("%s", buf + 1);
int n = std::strlen(buf + 1);
int A, B;
A = B = 0;
for (int i = 1; i <= n; ++i) {
buf[i + n] = buf[i];
if (buf[i] == '(') {
++A;
} else {
++B;
}
}
int m = n << 1;
for (int i = 1; i <= m; ++i) {
if (buf[i] == '(') {
sum[i] = 1;
} else {
sum[i] = -1;
}
sum[i] += sum[i - 1];
}
static int q[maxn];
int front, rear;
front = rear = 0;
static int min[maxn];
int add = 0;
if (A < B) {
add = B - A;
}
for (int i = 1; i <= m; ++i) {
if (front < rear && q[front] + n <= i) {
++front;
}
while (front < rear && sum[q[rear - 1]] >= sum[i]) {
--rear;
}
q[rear++] = i;
min[i] = sum[q[front]];
}
for (int i = 1; i <= n; ++i) {
if (add + min[i + n - 1] >= sum[i - 1]) {
ok[i] = true;
}
}
int index = run(buf, m);
auto print = [](char ch, int n) {
while (n--) {
putchar(ch);
}
};
if (A < B) {
print('(', B - A);
}
for (int i = index; i < index + n; ++i) {
putchar(buf[i]);
}
if (B < A) {
print(')', A - B);
}
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug;
const int inf = 1e9 + 5;
const long long INF = (long long)inf * inf;
const int nax = 1e6 + 5;
const int D = 2;
const long long MM = 1000 * 1000 * 1000;
const long long m[5] = {MM + 7, MM + 9, MM + 21, MM + 33, 333333361LL};
char sl[nax];
long long preh[nax][D];
int n;
long long potega[nax][D];
long long h(pair<int, int> a, int j) {
long long x = preh[a.second][j];
if (a.first) x -= preh[a.first - 1][j];
if (x < 0) x += m[j];
x = (x * potega[n - a.first][j]) % m[j];
return x;
}
bool rowne(pair<int, int> a, pair<int, int> b) {
for (int j = 0; j <= (D)-1; ++j)
if (h(a, j) != h(b, j)) return false;
return true;
}
int porow(pair<int, int> a, pair<int, int> b) {
assert(a.second - a.first == b.second - b.first);
if (a.first > a.second) return true;
if (rowne(a, b)) return 1;
int low = 0, high = a.second - a.first;
while (low != high) {
int med = (low + high) / 2;
if (rowne(make_pair(a.first, a.first + med),
make_pair(b.first, b.first + med)))
low = med + 1;
else
high = med;
}
if (sl[a.first + low] == '(') return 0;
return 2;
}
int pref[nax];
int LICZ;
const int pot = 1024 * 1024;
int tr[2 * pot];
int mi(int a, int b) {
a += pot;
b += pot;
int ku = min(tr[a], tr[b]);
while (a < b - 1) {
ku = min(ku, tr[a + 1]);
ku = min(ku, tr[b - 1]);
a /= 2;
b /= 2;
}
return ku;
}
bool ok_podzial_szybkie(int i) {
int s1 = pref[i];
int s2 = LICZ - pref[i];
int k = 0;
if (LICZ < 0) k = -LICZ;
if (i + 1 <= n - 1 && k + mi(i + 1, n - 1) - s1 < 0) return false;
if (0 <= i && k + s2 + mi(0, i) < 0) return false;
return true;
}
bool ok_podzial(int i) {
int teraz = 0;
if (LICZ < 0) teraz = -LICZ;
for (int j = i + 1; j <= n - 1; ++j) {
if (sl[j] == '(')
++teraz;
else
--teraz;
if (teraz < 0) return false;
}
for (int j = 0; j <= i; ++j) {
if (sl[j] == '(')
++teraz;
else
--teraz;
if (teraz < 0) return false;
}
return true;
}
int best = -1;
bool jebaj(int i) {
if (best == -1) return true;
int kon = best + 1 + (n - 1 - (i + 1));
int pom = porow(make_pair(best + 1, kon), make_pair(i + 1, n - 1));
if (pom == 0) return false;
if (pom == 2) return true;
int kon2 = n - 1 - (kon + 1);
pom = porow(make_pair(kon + 1, n - 1), make_pair(0, kon2));
if (pom == 0) return false;
if (pom == 2) return true;
pom = porow(make_pair(0, best), make_pair(kon2 + 1, i));
if (pom == 0) return false;
return true;
}
int main(int argc, char *argv[]) {
debug = argc > 1;
scanf("%s", sl);
n = strlen(sl);
for (int i = 0; i <= (n)-1; ++i) {
if (i) pref[i] = pref[i - 1];
if (sl[i] == '(')
pref[i]++;
else
pref[i]--;
}
for (int i = 0; i <= (2 * pot) - 1; ++i) tr[i] = inf;
for (int i = 0; i <= (n)-1; ++i) tr[pot + i] = pref[i];
for (int i = pot - 1; i >= 1; --i) tr[i] = min(tr[2 * i], tr[2 * i + 1]);
LICZ = 0;
for (int i = 0; i <= (n)-1; ++i) {
if (sl[i] == '(')
++LICZ;
else
--LICZ;
}
for (int j = 0; j <= (D)-1; ++j) {
potega[0][j] = 1;
for (int i = 1; i <= n; ++i)
potega[i][j] = ((j == 2 ? 3 : 2) * potega[i - 1][j]) % m[j];
}
for (int j = 0; j <= (D)-1; ++j)
for (int i = 0; i <= (n)-1; ++i) {
int teraz = int(sl[i] == '(');
preh[i][j] = ((i ? preh[i - 1][j] : 0LL) + teraz * potega[i][j]) % m[j];
}
for (int i = 0; i <= (n)-1; ++i)
if (ok_podzial_szybkie(i))
if (jebaj(i)) best = i;
assert(best != -1);
if (LICZ < 0)
for (int _ = 0; _ <= (-LICZ) - 1; ++_) printf("(");
for (int j = best + 1; j <= n - 1; ++j) printf("%c", sl[j]);
for (int j = 0; j <= best; ++j) printf("%c", sl[j]);
if (LICZ > 0)
for (int _ = 0; _ <= (LICZ)-1; ++_) printf(")");
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> scs(const string& s) {
int n = s.size();
vector<int> p(n), c(s.begin(), s.end());
vector<vector<int>> g(max(n, 256));
for (int i = 0; i < n; i++) g[c[i]].push_back(i);
int b = 0;
for (auto& gr : g) {
for (int x : gr) p[b++] = x;
gr.clear();
}
for (int h = 1; h < n; h <<= 1) {
vector<int> p2(n), c2(n);
for (int j : p) {
int jp = (j + n - h) % n;
g[c[jp]].push_back(jp);
}
b = 0;
for (auto& gr : g) {
for (int x : gr) p2[b++] = x;
gr.clear();
}
b = 0;
c2[p2[0]] = 0;
for (int i = 1; i < n; i++) {
int x = p2[i];
int y = p2[i - 1];
if (c[x] == c[y] && c[(x + h) % n] == c[(y + h) % n])
c2[x] = b;
else
c2[x] = ++b;
}
swap(c, c2);
swap(p, p2);
}
return p;
}
struct stvar {
int a, b;
stvar(int x = 0) : a(x), b(min(0, x)) {}
stvar(int p, int q) : a(p), b(q) {}
stvar operator+(const stvar& o) const {
return stvar(a + o.a, min(b, a + o.b));
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
string s;
cin >> s;
int n = s.size();
vector<int> p = scs(s);
vector<stvar> pref(n + 1), suff(n + 1);
for (int i = 0; i < n; i++)
pref[i + 1] = pref[i] + stvar(s[i] == '(' ? 1 : -1);
for (int i = n - 1; i >= 0; i--)
suff[i] = stvar(s[i] == '(' ? 1 : -1) + suff[i + 1];
for (int j : p) {
auto t = suff[j] + pref[j];
if (t.a < 0) {
if (t.a == t.b) {
cout << string(-t.a, '(') << s.substr(j) << s.substr(0, j) << '\n';
return 0;
}
} else {
if (t.b == 0) {
cout << s.substr(j) << s.substr(0, j) << string(t.a, ')') << '\n';
return 0;
}
}
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
const int MOD = 100000009;
const int B = 31337;
int n;
int off = 1;
int lo, hi;
char S[N];
pair<int, int> T[4 * N];
long long H[N];
long long PW[N];
void load() {
scanf("%s", S);
n = strlen(S);
while (off < 2 * n) off <<= 1;
for (int i = n; i < 2 * n; i++) S[i] = S[i - n];
H[0] = S[0];
for (int i = 1; i < 2 * n; i++) H[i] = H[i - 1] * B + S[i], H[i] %= MOD;
PW[0] = 1;
for (int i = 1; i < N; i++) PW[i] = PW[i - 1] * B, PW[i] %= MOD;
}
long long get(int first, int second) {
if (!first) return H[second];
return (H[second] - (H[first - 1] * PW[second - first + 1] % MOD) + MOD) %
MOD;
}
int lcp(int first, int second) {
int low = 0, high = 2 * n - max(first, second) - 1, middle;
while (low <= high) {
middle = (low + high) / 2;
if (get(first, first + middle) != get(second, second + middle))
high = middle - 1;
else
low = middle + 1;
}
return S[first + low] < S[second + low];
}
pair<int, int> merge(pair<int, int> A, pair<int, int> B) {
pair<int, int> C;
int brackets = min(A.first, B.second);
C.first = A.first + B.first - brackets;
C.second = A.second + B.second - brackets;
return C;
}
pair<int, int> query(int a, int b, int node) {
if (a > hi || b < lo) return make_pair(0, 0);
if (a >= lo && b <= hi) return T[node];
return merge(query(a, (a + b) / 2, node * 2),
query((a + b) / 2 + 1, b, node * 2 + 1));
}
void solve() {
for (int i = 0; i < 2 * n; i++) {
if (S[i] == '(')
T[i + off].first++;
else
T[i + off].second++;
}
for (int i = off - 1; i >= 1; i--) {
T[i] = merge(T[i * 2], T[i * 2 + 1]);
}
int sol = (1 << 30);
int sol_left = 0;
int sol_right = 0;
int idx = 0;
for (int i = 0; i < n; i++) {
lo = i, hi = i + n - 1;
pair<int, int> AA = query(0, off - 1, 1);
int curr = AA.first + AA.second;
if (curr < sol) {
sol = curr;
sol_left = AA.first;
sol_right = AA.second;
idx = i;
} else if (curr == sol && lcp(i, idx)) {
sol_left = AA.first;
sol_right = AA.second;
idx = i;
}
}
for (int i = 0; i < sol_right; i++) printf("(");
for (int i = idx; i < idx + n; i++) printf("%c", S[i]);
for (int i = 0; i < sol_left; i++) printf(")");
printf("\n");
}
int main(void) {
load();
solve();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
class data {
public:
int op, cl, x, y;
} a[2000005];
int n;
char s[4000005];
int arr[4000005];
int kd[8000000];
int art[8000000];
int update(int root, int bas, int son, int x, int y, int val) {
if (son < x or y < bas) return kd[root];
if (x <= bas and son <= y) {
art[root] += val;
return kd[root] += val;
}
return kd[root] =
min(update(root * 2, bas, (bas + son) / 2, x, y, val),
update(root * 2 + 1, (bas + son) / 2 + 1, son, x, y, val)) +
art[root];
}
int query(int root, int bas, int son, int x, int y) {
if (son < x or y < bas) return 1000000007LL;
if (x <= bas and son <= y) return kd[root];
return min(query(root * 2, bas, (bas + son) / 2, x, y),
query(root * 2 + 1, (bas + son) / 2 + 1, son, x, y)) +
art[root];
}
long long int h[4000005], pows[4000005] = {1}, OP[4000005], CL[4000005];
long long int f(int x, int y) {
return (h[y] - h[x - 1] * pows[y - x + 1] + 1000000007LL * 1000000007LL) %
1000000007LL;
}
long long int giveHash(data A, int x) {
if (x <= A.op) return OP[x];
if (x <= A.op + n)
return (OP[A.op] * pows[x - A.op] + f(A.x, A.x + x - A.op - 1)) %
1000000007LL;
return (OP[A.op] * pows[x - A.op] + f(A.x, A.y) * pows[x - A.op - n] +
CL[x - A.op - n]) %
1000000007LL;
}
char giveChar(data A, int x) {
if (x <= A.op) return '(';
if (x <= A.op + n) return s[A.x + x - A.op - 1];
return ')';
}
int lcp(data A, data B) {
int bas = 0, son = min(A.op + n + A.cl, B.op + n + B.cl), orta;
while (bas < son) {
orta = (bas + son) / 2 + 1;
if (giveHash(A, orta) == giveHash(B, orta))
bas = orta;
else
son = orta - 1;
}
return bas;
}
bool cmp(data A, data B) {
int u1, u2;
u1 = A.op + n + A.cl;
u2 = B.op + n + B.cl;
if (u1 != u2) return u1 < u2;
int l = lcp(A, B);
if (l == u1) return 1;
return giveChar(A, l + 1) == '(';
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int R = 0;
for (long long int i = 1; i <= n; i++) {
s[i + n] = s[i];
R += arr[i] = arr[i + n] = (s[i] == '(' ? 1 : -1);
}
for (long long int i = n + 1; i <= 2 * n; i++)
update(1, 1, 2 * n, i, 2 * n, arr[i]);
for (long long int i = n; i >= 1; i--) {
int mini = query(1, 1, 2 * n, i + 1, i + n);
a[i].op = max(0, -mini);
a[i].cl = R + a[i].op;
a[i].x = i + 1;
a[i].y = i + n;
update(1, 1, 2 * n, i, i + n - 1, arr[i]);
}
for (long long int i = 1; i <= 4000001; i++)
h[i] = (h[i - 1] * 9973 + s[i]) % 1000000007LL,
pows[i] = (pows[i - 1] * 9973) % 1000000007LL,
OP[i] = (OP[i - 1] * 9973 + '(') % 1000000007LL,
CL[i] = (CL[i - 1] * 9973 + ')') % 1000000007LL;
data res = a[1];
for (long long int i = 2; i <= n; i++)
if (cmp(a[i], res)) res = a[i];
string result;
for (long long int i = 1; i <= res.op; i++) result += '(';
for (long long int i = res.x; i <= res.y; i++) result += s[i];
for (long long int i = 1; i <= res.cl; i++) result += ')';
if (s[1] == '(' and s[4] == '(' and s[6] == '(' and s[2] == ')' and
s[3] == ')' and n >= 100000) {
}
printf("%s\n", result.c_str());
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool fast_greater(const string& s, const vector<long long>& h,
const vector<long long>& p, int i1, int i2, int n) {
if (s[i1] != s[i2]) return s[i1] > s[i2];
int lo{0};
int up{n - 1};
while (up - lo > 1) {
int mid{(lo + up) / 2};
if ((h[i1 + mid] - h[i1] * p[mid] % 1234567890 + 1234567890) % 1234567890 ==
(h[i2 + mid] - h[i2] * p[mid] % 1234567890 + 1234567890) % 1234567890)
lo = mid;
else
up = mid;
}
if ((h[i1 + up] - h[i1] * p[up] % 1234567890 + 1234567890) % 1234567890 ==
(h[i2 + up] - h[i2] * p[up] % 1234567890 + 1234567890) % 1234567890)
return s[i1 + up + 1] > s[i2 + up + 1];
else
return s[i1 + lo + 1] > s[i2 + lo + 1];
}
int main() {
string s;
cin >> s;
int n = s.size();
vector<int> minPre(n), minSuf(n), bal(n);
transform((s).begin(), (s).end(), bal.begin(),
[](char ch) { return ch == '(' ? 1 : -1; });
partial_sum((bal).begin(), (bal).end(), bal.begin());
partial_sum((bal).begin(), (bal).end(), minPre.begin(),
[](int x, int y) { return x < y ? x : y; });
partial_sum((bal).rbegin(), (bal).rend(), minSuf.rbegin(),
[](int x, int y) { return x < y ? x : y; });
s += s;
vector<long long> h(2 * n);
vector<long long> p(2 * n);
h[0] = 0;
p[0] = 1;
for (int i = 1; i < 2 * n; ++i) {
h[i] = (h[i - 1] * 1000007 + s[i]) % 1234567890;
p[i] = p[i - 1] * 1000007 % 1234567890;
}
int I{-1};
int totBal{bal[n - 1]};
for (int i = 0; i < n; ++i) {
int minRot{i == 0 ? minSuf[0]
: min(minSuf[i] - bal[i - 1],
minPre[i - 1] + totBal - bal[i - 1])};
if (totBal >= 0 && minRot >= 0 || totBal < 0 && minRot - totBal >= 0)
if (I == -1 || fast_greater(s, h, p, I, i, n)) I = i;
}
string ans = (totBal < 0 ? string(-totBal, '(') : string()) +
string(s.begin() + I, s.begin() + I + n) +
(totBal > 0 ? string(totBal, ')') : string());
cout << ans << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug;
const int inf = 1e9 + 5;
const long long INF = (long long)inf * inf;
const int nax = 1e6 + 5;
const int D = 1;
const long long MM = 1000 * 1000 * 1000;
const long long m[5] = {MM + 7, MM + 9, MM + 21, MM + 33, 333333361LL};
char sl[nax];
long long preh[nax][D];
int n;
long long potega[nax][D];
long long h(pair<int, int> a, int j) {
long long x = preh[a.second][j];
if (a.first) x -= preh[a.first - 1][j];
if (x < 0) x += m[j];
x = (x * potega[n - a.first][j]) % m[j];
return x;
}
bool rowne(pair<int, int> a, pair<int, int> b) {
for (int j = 0; j <= (D)-1; ++j)
if (h(a, j) != h(b, j)) return false;
return true;
}
int porow(pair<int, int> a, pair<int, int> b) {
assert(a.second - a.first == b.second - b.first);
if (a.first > a.second) return true;
if (rowne(a, b)) return 1;
int low = 0, high = a.second - a.first;
while (low != high) {
int med = (low + high) / 2;
if (rowne(make_pair(a.first, a.first + med),
make_pair(b.first, b.first + med)))
low = med + 1;
else
high = med;
}
if (sl[a.first + low] == '(') return 0;
return 2;
}
int pref[nax];
int LICZ;
const int pot = 1024 * 1024;
int tr[2 * pot];
int mi(int a, int b) {
a += pot;
b += pot;
int ku = min(tr[a], tr[b]);
while (a < b - 1) {
ku = min(ku, tr[a + 1]);
ku = min(ku, tr[b - 1]);
a /= 2;
b /= 2;
}
return ku;
}
bool ok_podzial_szybkie(int i) {
int s1 = pref[i];
int s2 = LICZ - pref[i];
int k = 0;
if (LICZ < 0) k = -LICZ;
if (i + 1 <= n - 1 && k + mi(i + 1, n - 1) - s1 < 0) return false;
if (0 <= i && k + s2 + mi(0, i) < 0) return false;
return true;
}
bool ok_podzial(int i) {
int teraz = 0;
if (LICZ < 0) teraz = -LICZ;
for (int j = i + 1; j <= n - 1; ++j) {
if (sl[j] == '(')
++teraz;
else
--teraz;
if (teraz < 0) return false;
}
for (int j = 0; j <= i; ++j) {
if (sl[j] == '(')
++teraz;
else
--teraz;
if (teraz < 0) return false;
}
return true;
}
int best = -1;
bool jebaj(int i) {
if (best == -1) return true;
int kon = best + 1 + (n - 1 - (i + 1));
int pom = porow(make_pair(best + 1, kon), make_pair(i + 1, n - 1));
if (pom == 0) return false;
if (pom == 2) return true;
int kon2 = n - 1 - (kon + 1);
pom = porow(make_pair(kon + 1, n - 1), make_pair(0, kon2));
if (pom == 0) return false;
if (pom == 2) return true;
pom = porow(make_pair(0, best), make_pair(kon2 + 1, i));
if (pom == 0) return false;
return true;
}
int main(int argc, char *argv[]) {
debug = argc > 1;
scanf("%s", sl);
n = strlen(sl);
for (int i = 0; i <= (n)-1; ++i) {
if (i) pref[i] = pref[i - 1];
if (sl[i] == '(')
pref[i]++;
else
pref[i]--;
}
for (int i = 0; i <= (2 * pot) - 1; ++i) tr[i] = inf;
for (int i = 0; i <= (n)-1; ++i) tr[pot + i] = pref[i];
for (int i = pot - 1; i >= 1; --i) tr[i] = min(tr[2 * i], tr[2 * i + 1]);
LICZ = 0;
for (int i = 0; i <= (n)-1; ++i) {
if (sl[i] == '(')
++LICZ;
else
--LICZ;
}
for (int j = 0; j <= (D)-1; ++j) {
potega[0][j] = 1;
for (int i = 1; i <= n; ++i)
potega[i][j] = ((j == 2 ? 3 : 2) * potega[i - 1][j]) % m[j];
}
for (int j = 0; j <= (D)-1; ++j)
for (int i = 0; i <= (n)-1; ++i) {
int teraz = int(sl[i] == '(');
preh[i][j] = ((i ? preh[i - 1][j] : 0LL) + teraz * potega[i][j]) % m[j];
}
for (int i = 0; i <= (n)-1; ++i)
if (ok_podzial_szybkie(i))
if (jebaj(i)) best = i;
assert(best != -1);
if (LICZ < 0)
for (int _ = 0; _ <= (-LICZ) - 1; ++_) printf("(");
for (int j = best + 1; j <= n - 1; ++j) printf("%c", sl[j]);
for (int j = 0; j <= best; ++j) printf("%c", sl[j]);
if (LICZ > 0)
for (int _ = 0; _ <= (LICZ)-1; ++_) printf(")");
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct suff_arr {
vector<int> p, c, np, nc, h;
string s;
int n;
suff_arr(string &s) {
this->s = s;
this->n = s.size();
build();
}
int mode1(int a, int k) { return (a + (1 << (k - 1))) % n; }
int mode2(int a, int k) { return (a - (1 << (k - 1)) + n) % n; }
bool prov(int i, int j, int k) {
return c[i] != c[j] || c[mode1(i, k)] != c[mode1(j, k)];
}
void build() {
p.resize(n), c = nc = np = h = p;
vector<pair<char, int>> in;
for (int i = 0; i < s.size(); i++) in.push_back({s[i], i});
sort(in.begin(), in.end());
for (int i = 0; i < in.size(); i++) p[i] = in[i].second;
int g = h[0] = c[p[0]] = 0, k = 1;
for (int i = 1; i < n; i++) {
if (in[i].first != in[i - 1].first) g++, h[g] = i;
c[p[i]] = g;
}
while ((1 << (k - 1)) < n) {
for (int i = 0; i < n; i++) {
int v = mode2(p[i], k);
np[h[c[v]]++] = v;
}
g = h[0] = nc[np[0]] = 0;
for (int i = 1; i < n; i++) {
if (prov(np[i], np[i - 1], k)) g++, h[g] = i;
nc[np[i]] = g;
}
c = nc, p = np, k++;
if (g == n) break;
}
}
};
struct que {
stack<pair<int, int>> s1, s2;
void add(int x) {
int ane = 1e9;
if (s1.size()) ane = min(ane, s1.top().second);
s1.push({x, min(ane, x)});
}
void res() {
while (s1.size()) {
int g = s1.top().first;
s1.pop();
int ane = 1e9;
if (s2.size()) ane = min(ane, s2.top().second);
s2.push({g, min(ane, g)});
}
}
int mi() {
int ane1 = 1e9, ane2 = 1e9;
if (s1.size()) ane1 = min(ane1, s1.top().second);
if (s2.size()) ane2 = min(ane2, s2.top().second);
return min(ane1, ane2);
}
int gy() {
if (!s2.size()) res();
int x = s2.top().first;
return x;
}
int del() {
if (!s2.size()) res();
int x = s2.top().first;
s2.pop();
return x;
}
};
const int maxn = 1e6 + 113;
bool used[maxn];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.setf(ios::fixed);
cout.precision(0);
string s;
cin >> s;
int yt = s.size();
int b1 = 0, b2 = 0;
int de = 0, su = 0, lasty = 0;
que mu;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(') {
b1++;
su++;
} else {
b2++;
su--;
}
mu.add(su);
lasty = su;
}
int vs = max(b2 - b1, 0);
for (int i = 0; i < s.size(); i++) {
int u = mu.mi();
if (u + de >= -vs) used[i] = 1;
if (s[i] == '(')
de--;
else
de++;
mu.del();
mu.add(lasty - de);
}
suff_arr mg(s);
int pos;
for (int i = 0; i < s.size(); i++)
if (used[mg.p[i]]) {
pos = mg.p[i];
break;
}
string h;
for (int i = pos; i < s.size(); i++) h.push_back(s[i]);
for (int i = 0; i < pos; i++) h.push_back(s[i]);
while (b1 < b2) {
cout << "(";
b1++;
}
cout << h;
while (b1 > b2) {
cout << ")";
b2++;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
char a[2 * N + 1];
int q[2 * N];
int main() {
gets(a);
int n = strlen(a), ans = 0, l = 0, r = 0;
copy_n(a, n, a + n);
for (int i = (0); i < (n); i++)
if (a[i] == '(')
q[r++] = i, ans++;
else
r &&r--, ans--;
int i = -1;
for (int k, jj = 0, j = 0; j < n;) {
while (l < r && q[l] < j) l++;
for (; jj < j; jj++)
if (a[jj] == '(')
q[r++] = jj + n;
else if (l < r)
r--;
if (r - l > max(ans, 0)) {
j++;
continue;
}
if (i == -1) {
i = j++;
continue;
}
for (k = 0; k < n && a[i + k] == a[j + k]; k++)
;
if (a[i + k] <= a[j + k])
j += k + 1;
else {
i += k + 1;
if (i < j)
i = j++;
else
j = i + 1;
}
}
for (int j = (0); j < (-ans); j++) putchar('(');
i %= n;
for (int j = (i); j < (n); j++) putchar(a[j]);
for (int j = (0); j < (i); j++) putchar(a[j]);
for (int j = (0); j < (ans); j++) putchar(')');
puts("");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
class mint {
public:
int first;
mint(long long second = 0) {
second %= Mod;
first = (int)second;
}
};
mint operator+(mint a, mint b) {
a.first += b.first;
if (a.first >= Mod) a.first -= Mod;
return a;
}
mint operator-(mint a, mint b) {
a.first -= b.first;
if (a.first < 0) a.first += Mod;
return a;
}
mint operator*(mint a, mint b) { return mint((long long)a.first * b.first); }
bool operator==(mint a, mint b) { return a.first == b.first; }
bool operator!=(mint a, mint b) { return a.first != b.first; }
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
if (a.second < b.first)
b.first -= a.second, a.second = 0;
else
a.second -= b.first, b.first = 0;
return {a.first + b.first, a.second + b.second};
}
pair<int, int> F(char c) {
if (c == '(')
return {0, 1};
else
return {1, 0};
}
string s;
int l;
pair<int, int> Pref[1000015], Suff[1000015];
mint _H[1000015], *H = _H + 1;
mint HP = 101;
mint Hpot[1000015];
mint HL[1000015], HR[1000015];
mint Hash(int lo, int hi) {
if (lo < 0) return HL[hi - lo + 1];
if (lo > 2000000) return HR[hi - lo + 1];
return H[hi] - H[lo - 1] * Hpot[hi - lo + 1];
}
mint Hash(pair<int, int> t) { return Hash(t.first, t.first + t.second - 1); }
mint Hash(int t) { return Hash(t, t); }
int LCP(int a, int b, int MaxLen) {
int lo = 0, hi = MaxLen, mid = (lo + hi + 1) / 2;
while (lo != hi) {
if (Hash(a, a + mid - 1) == Hash(b, b + mid - 1))
lo = mid;
else
hi = mid - 1;
mid = (lo + hi + 1) / 2;
}
return lo;
}
vector<pair<int, int> > Func(int id) {
pair<int, int> t = Suff[l - id] + Pref[id];
return {{-2000000, t.first}, {id, l - id}, {0, id}, {3000000, t.second}};
}
bool Cmp(int id1, int id2) {
if (id2 == -1) return true;
vector<pair<int, int> > V1 = Func(id1), V2 = Func(id2);
vector<int> Vp = {0};
for (int i = 0, j = V1[0].second; i < 4; ++i, j += V1[i].second)
Vp.push_back(j);
for (int i = 0, j = V2[0].second; i < 4; ++i, j += V2[i].second)
Vp.push_back(j);
sort(Vp.begin(), Vp.end());
vector<pair<int, int> > VV1, VV2;
int tmp = 0;
for (int i = 0, j = 1; i < 4; ++i) {
while (j < (int)Vp.size() && Vp[j] <= tmp + V1[i].second) {
VV1.push_back({V1[i].first + Vp[j - 1] - tmp, Vp[j] - Vp[j - 1]});
++j;
}
tmp += V1[i].second;
}
tmp = 0;
for (int i = 0, j = 1; i < 4; ++i) {
while (j < (int)Vp.size() && Vp[j] <= tmp + V2[i].second) {
VV2.push_back({V2[i].first + Vp[j - 1] - tmp, Vp[j] - Vp[j - 1]});
++j;
}
tmp += V2[i].second;
}
for (int i = (int)(0); i < (int)(Vp.size() - 1); ++i)
if (Hash(VV1[i]) != Hash(VV2[i])) {
tmp = LCP(VV1[i].first, VV2[i].first, VV1[i].second);
return Hash(VV1[i].first + tmp).first < Hash(VV2[i].first + tmp).first;
}
return false;
}
int main() {
Hpot[0] = 1;
for (int i = (int)(1); i < (int)(1000005); ++i)
Hpot[i] = Hpot[i - 1] * HP, HL[i] = HL[i - 1] * HP + ')',
HR[i] = HR[i - 1] * HP + '(';
cin >> s;
l = (int)s.size();
for (int i = (int)(0); i < (int)(l); ++i) H[i] = H[i - 1] * HP + s[i];
for (int i = (int)(0); i < (int)(l); ++i) Pref[i + 1] = Pref[i] + F(s[i]);
for (int i = (int)(0); i < (int)(l); ++i)
Suff[i + 1] = F(s[l - i - 1]) + Suff[i];
int MinLen = l * 2;
for (int i = (int)(0); i < (int)(l + 1); ++i) {
pair<int, int> t = Suff[l - i] + Pref[i];
MinLen = min(MinLen, l + t.first + t.second);
}
cerr << "MinLen"
<< " = " << MinLen << endl;
int Best = -1;
for (int i = (int)(0); i < (int)(l + 1); ++i) {
pair<int, int> t = Suff[l - i] + Pref[i];
if (MinLen != l + t.first + t.second) continue;
if (Cmp(i, Best)) Best = i;
}
pair<int, int> r = Suff[l - Best] + Pref[Best];
for (int i = (int)(0); i < (int)(r.first); ++i) cout << "(";
cout << string(s.begin() + Best, s.end())
<< string(s.begin(), s.begin() + Best);
for (int i = (int)(0); i < (int)(r.second); ++i) cout << ")";
cout << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
struct SAIS {
int s[maxn << 1], t[maxn << 1], sa[maxn], rk[maxn], hi[maxn], p[maxn],
tax[maxn], cur[maxn];
void inducedSort(int n, int m, int n1, int *s, int *s1, int *t) {
for (int i = 0; i < n; ++i) sa[i] = -1;
for (int i = 0; i < m; ++i) tax[i] = 0;
for (int i = 0; i < n; ++i) ++tax[s[i]];
for (int i = 1; i < m; ++i) tax[i] += tax[i - 1];
for (int i = 0; i < m; ++i) cur[i] = tax[i] - 1;
for (int i = n1 - 1; ~i; --i) sa[cur[s[s1[i]]]--] = s1[i];
for (int i = 1; i < m; ++i) cur[i] = tax[i - 1];
for (int i = 0; i < n; ++i)
if (sa[i] > 0 && t[sa[i] - 1]) sa[cur[s[sa[i] - 1]]++] = sa[i] - 1;
for (int i = 0; i < m; ++i) cur[i] = tax[i] - 1;
for (int i = n - 1; ~i; --i)
if (sa[i] > 0 && !t[sa[i] - 1]) sa[cur[s[sa[i] - 1]]--] = sa[i] - 1;
}
void sais(int n, int m, int *s, int *t, int *p) {
int n1 = t[n - 1] = 0, ch = rk[0] = -1, *s1 = s + n;
for (int i = n - 2; ~i; --i)
t[i] = s[i] == s[i + 1] ? t[i + 1] : s[i] > s[i + 1];
for (int i = 1; i < n; ++i)
rk[i] = t[i - 1] && !t[i] ? p[n1] = i, n1++ : -1;
inducedSort(n, m, n1, s, p, t);
for (int i = 0, x, y; i < n; ++i) {
if ((x = rk[sa[i]]) == -1) continue;
if (ch < 1 || p[x + 1] - p[x] != p[y + 1] - p[y])
++ch;
else
for (int j = p[x], k = p[y]; j <= p[x + 1]; ++j, ++k)
if ((s[j] << 1 | t[j]) != (s[k] << 1 | t[k])) {
++ch;
break;
}
s1[y = x] = ch;
}
if (ch + 1 < n1)
sais(n1, ch + 1, s1, t + n, p + n1);
else
for (int i = 0; i < n1; ++i) sa[s1[i]] = i;
for (int i = 0; i < n1; ++i) s1[i] = p[sa[i]];
inducedSort(n, m, n1, s, s1, t);
}
void solve(char *str, int n, int m) {
for (int i = 0; i < n; ++i) s[i] = str[i];
s[n++] = 0;
sais(n, m, s, t, p);
for (int i = 0; i < n; ++i) rk[sa[i]] = i;
--n;
for (int i = 0, k = hi[0] = 0; i < n; ++i) {
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) ++k;
if (hi[rk[i]] = k) --k;
}
for (int i = n; i >= 1; --i) ++sa[i], rk[i] = rk[i - 1];
}
} sais;
char s[maxn];
int sum[maxn], mn[maxn], que[maxn];
int n, p1, p2;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) s[i + n] = s[i];
int tn = n;
n <<= 1;
sais.solve(s + 1, n, 256);
for (int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1] + (s[i] == '(' ? 1 : -1);
}
p1 = 1, p2 = 0;
for (int i = 1; i <= n; ++i) {
while (p1 <= p2 && sum[que[p2]] >= sum[i]) --p2;
que[++p2] = i;
while (i - que[p1] + 1 > tn) ++p1;
if (i >= tn) mn[i - tn + 1] = sum[que[p1]] - sum[i - tn];
}
int x = inf, y;
for (int i = 1; i <= tn; ++i) {
mn[i] = mn[i] >= 0 ? 0 : -mn[i];
x = min(x, mn[i]);
}
int p = 0;
y = x + sum[tn];
for (int i = 1; i <= n; ++i) {
if (sais.sa[i] > tn) continue;
if (mn[sais.sa[i]] == x) {
p = sais.sa[i];
break;
}
}
while (x--) putchar('(');
s[p + tn] = 0;
printf("%s", s + p);
while (y--) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[2000100];
int Lb[2000100 << 2], Rb[2000100 << 2];
void build(int x, int L, int R) {
if (L == R) {
if (s[L] == '(')
Rb[x] = 1;
else
Lb[x] = 1;
return;
}
int mid = L + R >> 1;
build((x << 1), L, mid);
build((x << 1 | 1), mid + 1, R);
if (Rb[(x << 1)] > Lb[(x << 1 | 1)]) {
Lb[x] = Lb[(x << 1)];
Rb[x] = Rb[(x << 1 | 1)] + Rb[(x << 1)] - Lb[(x << 1 | 1)];
} else {
Lb[x] = Lb[(x << 1)] + Lb[(x << 1 | 1)] - Rb[(x << 1)];
Rb[x] = Rb[(x << 1 | 1)];
}
}
int lb, rb;
int qury(int x, int L, int R, int l, int r) {
if (l <= L && R <= r) {
lb = lb + max(0, Lb[x] - rb);
rb = Rb[x] + max(0, rb - Lb[x]);
return lb;
}
int mid = L + R >> 1, res;
if (l <= mid) res = qury((x << 1), L, mid, l, r);
if (r > mid) res = qury((x << 1 | 1), mid + 1, R, l, r);
return res;
}
long long sum1[2000100], sum2[2000100];
long long fox1[2000100], fox2[2000100];
long long f_abs(long long a) {
return (a % 1000000009 + 1000000009) % 1000000009;
}
int main() {
scanf("%s", s);
int zer = 0, one = 0, len = strlen(s), _len = len;
int su1 = 0, su2 = 0;
for (int i = 0; i < _len; i++)
if (s[i] == '(')
su1++;
else
su2++;
for (int i = 0; i < _len - 1; i++) s[len++] = s[i];
s[len] = 0;
fox1[0] = 1;
fox2[0] = 1;
for (int i = 0; i < len; i++) {
sum1[i + 1] = sum1[i] * 17 + (s[i] == '(' ? 14 : 29741);
sum1[i + 1] %= 1000000009;
fox1[i + 1] = fox1[i] * 17;
fox1[i + 1] %= 1000000009;
sum2[i + 1] = sum2[i] * 1031 + (s[i] == '(' ? 13 : 247);
sum2[i + 1] %= 1000000009;
fox2[i + 1] = fox2[i] * 1031;
fox2[i + 1] %= 1000000009;
}
build(1, 0, len - 1);
int ans = 20000000, bj;
for (int i = 0; i < _len; i++) {
lb = rb = 0;
int a = qury(1, 0, len - 1, i, i + _len - 1);
if (a < ans) {
ans = a;
bj = i;
} else if (a == ans) {
int l = 0, r = _len, mid, as;
while (l <= r) {
mid = l + r >> 1;
if (f_abs(sum1[bj + mid] - sum1[bj] * fox1[mid]) ==
f_abs(sum1[i + mid] - sum1[i] * fox1[mid])) {
if (f_abs(sum2[bj + mid] - sum2[bj] * fox2[mid]) ==
f_abs(sum2[i + mid] - sum2[i] * fox2[mid])) {
as = mid;
l = mid + 1;
} else
r = mid - 1;
} else
r = mid - 1;
}
if (as == _len || s[bj + as] < s[i + as]) continue;
bj = i;
}
}
string f_ans = "";
for (int i = 0; i < ans; i++) f_ans += '(';
for (int i = bj; i < _len; i++) f_ans += s[i];
for (int i = 0; i < bj; i++) f_ans += s[i];
int lef = su1 + ans - su2;
for (int i = 0; i < lef; i++) f_ans += ')';
cout << f_ans << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
int const N = 2234567;
int const X = 33533;
long long M1;
long long M2;
long long const MASK = (1LL << 32) - 1;
long long POW1[N], POW2[N];
int s[N];
int bal[N];
struct hash {
long long h;
int len;
};
bool operator==(hash const& a, hash const& b) {
return a.len == b.len && a.h == b.h;
}
hash OPEN[N], CLOSE[N], hs[N];
long long add1(long long h1, long long h2, int len2) {
return (h1 * POW1[len2] + h2) % M1;
}
long long add2(long long h1, long long h2, int len2) {
return (h1 * POW2[len2] + h2) % M2;
}
hash operator+(hash const& a, hash const& b) {
return {(add1(a.h >> 32, b.h >> 32, b.len) << 32) |
add2(a.h & MASK, b.h & MASK, b.len),
a.len + b.len};
}
int const TR = 1 << 21;
int const INF = 1 << 30;
int trmin[TR * 2];
void settree(int x, int y) {
x += TR;
trmin[x] = y;
while (x > 1) {
x >>= 1;
if (trmin[x * 2] < trmin[x * 2 + 1])
trmin[x] = trmin[x * 2];
else
trmin[x] = trmin[x * 2 + 1];
}
}
int getmin(int left, int right) {
--right;
left += TR;
right += TR;
int ret = INF;
while (left <= right) {
if (left & 1) {
if (ret > trmin[left]) ret = trmin[left];
++left;
}
if ((right & 1) == 0) {
if (ret > trmin[right]) ret = trmin[right];
--right;
}
left >>= 1;
right >>= 1;
}
return ret;
}
struct answer {
int addOpen;
int pos;
int addClose;
};
int n;
int getChar(answer const& f, int id) {
if (id < f.addOpen) return '(';
id -= f.addOpen;
if (id < n) return s[f.pos + id];
id -= n;
if (id < f.addClose) return ')';
}
hash getHash(int left, int right) {
long long h1 = hs[right - 1].h >> 32;
long long h2 = hs[right - 1].h & MASK;
long long g1 = hs[left - 1].h >> 32;
long long g2 = hs[left - 1].h & MASK;
h1 -= g1 * POW1[right - left] % M1;
h2 -= g2 * POW2[right - left] % M2;
if (h1 < 0) h1 += M1;
if (h2 < 0) h2 += M2;
return {(h1 << 32) | h2, right - left};
}
hash getHash(answer const& f, int len) {
if (len <= f.addOpen) {
return OPEN[len];
}
hash z = OPEN[f.addOpen];
len -= f.addOpen;
if (len <= n) {
return z + getHash(f.pos, f.pos + len);
}
z = z + getHash(f.pos, f.pos + n);
len -= n;
if (len <= f.addClose) {
return z + CLOSE[len];
}
assert(false);
}
bool operator<(answer const& f, answer const& g) {
if (f.addOpen + f.addClose != g.addOpen + g.addClose)
return f.addOpen + f.addClose < g.addOpen + g.addClose;
int left = 0;
int right = f.addOpen + f.addClose + n + 1;
while (left < right - 1) {
int mid = (left + right) >> 1;
if (getHash(f, mid) == getHash(g, mid)) {
left = mid;
} else {
right = mid;
}
}
return getChar(f, left) < getChar(g, left);
}
std::mt19937 rnd(std::chrono::system_clock::now().time_since_epoch().count());
int const HALFBILLION = 500000000;
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
void gen(long long& M) {
M = rnd() % HALFBILLION + HALFBILLION;
while (!prime(M)) {
++M;
}
}
int main() {
gen(M1);
gen(M2);
POW1[0] = POW2[0] = 1;
OPEN[0] = {0, 0};
CLOSE[0] = {0, 0};
for (int i = 1; i < N; i++) {
POW1[i] = POW1[i - 1] * X % M1;
POW2[i] = POW2[i - 1] * X % M2;
if (i == 1) {
OPEN[i] = {(long long)'(', 1};
CLOSE[i] = {(long long)')', 1};
} else {
OPEN[i] = OPEN[i - 1] + OPEN[1];
CLOSE[i] = CLOSE[i - 1] + CLOSE[1];
}
}
int c = getchar();
while (c <= 32) c = getchar();
n = 1;
while (c > 32) {
s[n++] = c;
c = getchar();
}
--n;
for (int i = 1; i <= n; i++) s[i + n] = s[i];
bal[0] = 0;
for (int i = 1; i <= 2 * n; i++) {
bal[i] = bal[i - 1] + (s[i] == '(' ? 1 : -1);
settree(i, bal[i]);
}
hs[0] = {0, 0};
for (int i = 1; i <= 2 * n; i++) {
hash cur = {(long long)s[i], 1};
hs[i] = hs[i - 1] + cur;
}
answer ans = {INF / 2, -1, INF / 2};
for (int start = 1; start <= n; start++) {
int minB = getmin(start - 1, start + n);
int addOpen = bal[start - 1] - minB;
int addClose = bal[start + n - 1] - minB;
answer cur = {addOpen, start, addClose};
if (cur < ans) ans = cur;
}
for (int i = 0; i < ans.addOpen; i++) putchar('(');
for (int i = 0; i < n; i++) putchar(s[ans.pos + i]);
for (int i = 0; i < ans.addClose; i++) putchar(')');
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 5;
char str[N << 1];
int a[N << 1];
bool flag[N << 1];
int len;
int offset, pos;
pair<int, int> que[N << 1];
int p1, p2;
int sa[N << 1], rk[N << 1];
void da(char *s, int n, int m) {
static int t1[N << 1], t2[N << 1], c[N << 1];
int *x = t1, *y = t2, i, j, k, p = 1;
memset(c, 0, sizeof(c[0]) * m);
for (i = 0; i < n; i++) c[x[i] = s[i]]++;
for (i = 1; i < m; i++) c[i] += c[i - 1];
for (i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
for (k = 1; p < n; k <<= 1, m = p) {
for (p = 0, i = n - k; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
memset(c, 0, sizeof(c[0]) * m);
for (i = 0; i < n; i++) c[x[i]]++;
for (i = 1; i < m; i++) c[i] += c[i - 1];
for (i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
for (swap(x, y), x[sa[0]] = 0, p = i = 1; i < n; i++)
x[sa[i]] = y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]
? p - 1
: p++;
}
}
int main() {
scanf("%s", str + 1);
len = strlen(str + 1);
offset = 0;
for (int i = 1; i <= len; ++i) offset += (str[i] == '(' ? 1 : -1);
memcpy(str + len + 1, str + 1, len + 1);
a[0] = 0;
for (int i = 1; i <= len << 1; ++i)
a[i] = a[i - 1] + (str[i] == '(' ? 1 : -1);
p1 = p2 = 0;
for (int i = 1; i <= len << 1; ++i) {
while (p1 != p2 && que[p2 - 1].first > a[i]) --p2;
que[p2++] = pair<int, int>(a[i], i);
while (p1 != p2 && i - que[p1].second >= len) ++p1;
if (i - len >= 0) {
if (que[p1].first - a[i - len] >= offset ||
que[p1].first - a[i - len] >= 0)
flag[i - len + 1] = true;
}
}
da(str + 1, len << 1 | 1, 128);
for (int i = 1; i <= len << 1; ++i) {
if (sa[i] < len && flag[sa[i] + 1]) {
pos = sa[i] + 1;
break;
}
}
while (offset < 0) printf("("), ++offset;
for (int i = pos; i < pos + len; ++i) printf("%c", str[i]);
while (offset > 0) printf(")"), --offset;
puts("");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n;
char s[2000005], t[2000005];
int sa[2000005], rnk[2000005], lcp[2000005], cnt[2000005];
void build(char *s) {
int n = strlen(s) + 1, m = 256;
int *x = rnk, *y = lcp, *z;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i] = s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[y[i]]]] = y[i];
z = x, x = y, y = z;
x[sa[0]] = 0, p = 1;
for (int i = 1; i < n; i++) {
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + j] == y[sa[i - 1] + j])
? p - 1
: p++;
}
}
for (int i = 0; i < n; i++) rnk[sa[i]] = i;
for (int i = 0, k = 0; i < n - 1; lcp[rnk[i++]] = k) {
if (k) k--;
for (int j = sa[rnk[i] - 1]; s[i + k] == s[j + k]; k++)
;
}
}
int sum[2000005], emn[2000005], smn[2000005];
int ans, rot, ff, ss, g1, g2;
void update(int len, int r, int f, int s) {
if (ans > len) {
ans = len;
rot = r;
ff = f, ss = s;
}
return;
}
const int inf = 1e9;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
strcpy(t, s + 1);
strcpy(t + n, s + 1);
build(t);
for (int i = 1; i <= n; i++) {
int d = s[i] == '(' ? 1 : -1;
if (s[i] == '(')
g1++;
else
g2++;
sum[i] = sum[i - 1] + d;
}
for (int i = 1; i <= n; i++) {
smn[i] = sum[i];
if (i > 1) smn[i] = min(smn[i], smn[i - 1]);
}
for (int i = n; i >= 1; i--) {
emn[i] = sum[i];
if (i < n) emn[i] = min(emn[i], emn[i + 1]);
}
ans = inf;
for (int ii = 0; ii <= 2 * n; ii++) {
int i = sa[ii];
if (i > n) continue;
i++;
int d = sum[n] - sum[i - 1];
int mn = min(d + smn[i - 1], emn[i] - sum[i - 1]);
int inc = 0;
if (mn < 0) inc = -mn;
assert(inc + g1 >= g2);
update((inc + g1) * 2, i, inc, inc + g1 - g2);
}
for (int i = 0; i < ff; i++) putchar('(');
for (int i = rot; i <= n; i++) putchar(s[i]);
for (int i = 1; i < rot; i++) putchar(s[i]);
for (int i = 0; i < ss; i++) putchar(')');
return 0;
}
| 7 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.