solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#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;
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;
int Rank[4000011], sa[4000011];
namespace SA {
int Cnt[4000011], *cnt = Cnt + 11, first[4000011], second[4000011],
buf[4000011], v[4000011];
void build(char *s, int n) {
for (int i = 0; i < n; i++) v[i] = s[i];
sort(v, v + n);
int *x = unique(v, v + n);
memset(Rank, -1, sizeof Rank);
for (int i = 0; i < n; i++) Rank[i] = lower_bound(v, x, s[i]) - v;
for (int t = 1; t <= n; t <<= 1) {
for (int i = 0; i < n; i++) first[i] = Rank[i], second[i] = Rank[i + t];
fill(cnt, cnt + n, 0);
for (int i = 0; i < n; i++) cnt[second[i]]++;
for (int i = 0; i < n; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i < n; i++) buf[n - 1 - --cnt[second[i]]] = i;
fill(cnt, cnt + n, 0);
for (int i = 0; i < n; i++) cnt[first[i]]++;
for (int i = 0; i < n; i++) cnt[i] += cnt[i - 1];
for (int j = 0; j < n; j++) sa[--cnt[first[buf[j]]]] = buf[j];
bool end = 1;
for (int j = 0, last = -1; j < n; j++) {
int i = sa[j];
if (last == -1)
Rank[i] = 0;
else if (first[i] == first[last] && second[i] == second[last])
Rank[i] = Rank[last], end = 0;
else
Rank[i] = Rank[last] + 1;
last = i;
}
if (end) break;
}
}
} // namespace SA
struct tree {
int fv[4100001], addv[4100001];
void build(int *a, int o, int l, int r) {
if (l == r) {
fv[o] = a[l];
return;
}
int m = (l + r) / 2;
build(a, o * 2, l, m);
build(a, o * 2 + 1, m + 1, r);
fv[o] = min(fv[o * 2], fv[o * 2 + 1]);
}
void pushdown(int o, int l, int r) {
if (l == r || !addv[o]) return;
addv[o * 2] += addv[o];
addv[o * 2 + 1] += addv[o];
fv[o * 2] += addv[o];
fv[o * 2 + 1] += addv[o];
addv[o] = 0;
}
void set(int x, int d, int o, int l, int r) {
if (l == r) {
fv[o] = d;
return;
}
pushdown(o, l, r);
int m = (l + r) / 2;
if (x <= m)
set(x, d, o * 2, l, m);
else
set(x, d, o * 2 + 1, m + 1, r);
fv[o] = min(fv[o * 2], fv[o * 2 + 1]);
}
void add(int x, int y, int d, int o, int l, int r) {
if (x <= l && r <= y) {
fv[o] += d;
addv[o] += d;
return;
}
pushdown(o, l, r);
int m = (l + r) / 2;
if (x <= m) add(x, y, d, o * 2, l, m);
if (y > m) add(x, y, d, o * 2 + 1, m + 1, r);
fv[o] = min(fv[o * 2], fv[o * 2 + 1]);
}
int query(int x, int y, int o, int l, int r) {
if (x <= l && r <= y) return fv[o];
int m = (l + r) / 2, ans = 1 << 30;
if (x <= m) ans = min(ans, query(x, y, o * 2, l, m));
if (y > m) ans = min(ans, query(x, y, o * 2 + 1, m + 1, r));
return ans;
}
} T;
char s[1100001], t[2200001];
int a[1100001], n;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) t[i - 1] = t[n + i - 1] = s[i];
bool flag = 1;
for (int i = 1; i <= n; i++)
if (s[i] != '(') {
flag = 0;
break;
}
if (flag) {
for (int i = 1; i <= n; i++) putchar('(');
for (int i = 1; i <= n; i++) putchar(')');
puts("");
exit(0);
}
for (int i = 1; i <= n; i++)
if (s[i] == '(')
a[i] = a[i - 1] + 1;
else
a[i] = a[i - 1] - 1;
T.build(a, 1, 1, n);
SA::build(t, 2 * n);
int best = -1, val = -n - 1;
for (int i = 1; i <= n; i++) {
int cval = min(T.fv[1], 0);
if (cval > val)
val = cval, best = i;
else if (cval == val && Rank[best - 1] > Rank[i - 1])
best = i;
T.add(1, n, s[i] == '(' ? -1 : 1, 1, 1, n);
T.set(i, a[n], 1, 1, n);
}
for (int i = 0; i < -val; i++) putchar('(');
for (int i = best; i <= n; i++) putchar(s[i]);
for (int i = 1; i < best; i++) putchar(s[i]);
for (int i = 0; i < -val + a[n]; i++) putchar(')');
puts("");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int z, n;
char s[2000007], t[2000007];
int tab[2000007];
vector<int> suf;
void suf_array(const char* init, vector<int>& suf) {
string s = init;
vector<int> head, color, sub, tmp;
head.assign(max((int)s.size(), 256), 0);
suf.resize(s.size());
color.resize(s.size());
sub.resize(s.size());
tmp.resize(s.size());
for (int i = 0; i < s.size(); i++) ++head[s[i]];
for (int i = 1; i < 256; i++) head[i] += head[i - 1];
for (int i = 255; i >= 0; i--) head[i] = head[i - 1];
head[0] = 0;
for (int i = 0; i < s.size(); i++) {
suf[head[s[i]]] = i;
++head[s[i]];
}
int classes = 1;
head[0] = 0;
for (int i = 1; i < s.size(); i++) {
if (s[suf[i - 1]] != s[suf[i]]) {
++classes;
head[classes - 1] = i;
}
color[suf[i]] = classes - 1;
}
for (int k = 1; k < s.size(); k *= 2) {
for (int i = 0; i < s.size(); i++) {
int first = suf[i] - k;
if (first < 0) first += s.size();
tmp[head[color[first]]] = first;
++head[color[first]];
}
suf = tmp;
int second;
pair<int, int> prv, cur;
cur = make_pair(-1, 0);
classes = 0;
for (int i = 0; i < s.size(); i++) {
prv = cur;
second = suf[i] + k;
if (second >= s.size()) second -= s.size();
cur = make_pair(color[suf[i]], color[second]);
if (cur != prv) {
++classes;
head[classes - 1] = i;
}
sub[suf[i]] = classes - 1;
}
color = sub;
if (classes == s.size()) break;
}
}
int start, ending;
int tree[2000007 * 4];
int ans[2000007 * 4];
void build(int v, int l, int r) {
if (l == r) {
tree[v] = tab[l - 1];
return;
}
int m = (l + r) / 2;
build(2 * v, l, m);
build(2 * v + 1, m + 1, r);
tree[v] = min(tree[2 * v], tree[2 * v + 1]);
}
int query(int v, int l, int r, int p, int q) {
if (p <= l && q >= r) return tree[v];
int ret = 1000000001;
int m = (l + r) / 2;
if (p <= m) ret = min(ret, query(2 * v, l, m, p, q));
if (m + 1 <= q) ret = min(ret, query(2 * v + 1, m + 1, r, p, q));
return ret;
}
bool ok(int i) {
return query(1, 1, n, 1 + suf[i], 1 + suf[i] + n / 2 - 1) +
max(0, ending - start) - tab[suf[i]] >=
0;
}
int main() {
scanf("%s", s);
n = strlen(s);
strcpy(t, s);
strcpy(t + n, s);
n *= 2;
t[n] = 0;
for (int i = 1; i < n; i++) tab[i] = tab[i - 1] + (t[i - 1] == '(' ? 1 : -1);
build(1, 1, n);
suf_array(s, suf);
for (int i = 0; i < n / 2; i++) {
start += (s[i] == '(');
ending += (s[i] != '(');
}
int shiftid = 0;
for (int i = 0; i < n / 2; i++)
if (suf[i] < n / 2 && ok(i)) {
shiftid = suf[i];
break;
}
t[0] = 0;
for (int i = 0; i < ending - start; i++) t[i] = '(';
t[ending - start] = 0;
printf("%s", t);
printf("%s", s + shiftid);
s[shiftid] = 0;
printf("%s", s);
t[0] = 0;
for (int i = 0; i < start - ending; i++) t[i] = ')';
t[start - ending] = 0;
printf("%s\n", t);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long hsh = 13131;
const long long hsh2 = 19260817;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
int n, m;
string s, t;
char c[1001000];
long long pw[2001000], h[2000100], pw2[2001000], h2[2001000];
int sum[1001000], pre[1001000], sur[1001000], le, ri;
inline pair<long long, long long> v(int l, int r) {
return make_pair(
(h[r] - (l ? h[l - 1] : 0) * pw[r - l + 1] % mod + mod) % mod,
(h2[r] - (l ? h2[l - 1] : 0) * pw2[r - l + 1] % mod2 + mod2) % mod2);
}
inline bool ck(int i, int j) {
int l = 0, r = m;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (i + mid - 1 >= m || j + mid - 1 >= m ||
v(i, i + mid - 1) != v(j, j + mid - 1))
r = mid;
else
l = mid;
}
if (i + r - 1 >= m || j + r - 1 >= m) return 1;
return t[i + r - 1] < t[j + r - 1];
}
int main() {
int i, j, k;
scanf("%s", c);
s = c;
t = s + s;
n = s.length();
m = t.length();
pw[0] = 1;
for (i = 1; i <= m; i++) pw[i] = pw[i - 1] * hsh % mod;
h[0] = t[0];
for (i = 1; i < m; i++) h[i] = (h[i - 1] * hsh + t[i]) % mod;
pw2[0] = 1;
for (i = 1; i <= m; i++) pw2[i] = pw2[i - 1] * hsh2 % mod2;
h2[0] = t[0];
for (i = 1; i < m; i++) h2[i] = (h2[i - 1] * hsh2 + t[i]) % mod2;
for (i = 0; i < n; i++)
sum[i] = (i ? sum[i - 1] : 0) + (s[i] == '(' ? 1 : -1);
pre[0] = sum[0], sur[n - 1] = sum[n - 1];
for (i = 1; i < n; i++) pre[i] = min(sum[i], pre[i - 1]);
for (i = n - 2; i >= 0; i--) sur[i] = min(sum[i], sur[i + 1]);
int maxl = 1e9 + 7, pl = -1;
if (sum[n - 1] < 0)
le = -sum[n - 1];
else
ri = sum[n - 1];
for (i = 0; i < n; i++) {
k = (i ? sum[i - 1] : 0);
int w = min(sur[i] - k, sum[n - 1] - k + (i ? pre[i - 1] : 0));
int ll = max(-w, max(0, -sum[n - 1]));
if (ll + ri + n < maxl) {
maxl = ll + ri + n;
le = ll;
pl = i;
} else if (ll + ri + n == maxl && ck(i, pl)) {
pl = i;
}
}
for (i = 1; i <= le; i++) cout << "(";
for (i = pl; i < n; i++) cout << s[i];
for (i = 0; i < pl; i++) cout << s[i];
for (i = 1; i <= ri; i++) cout << ")";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2000020;
char s[Maxn];
bool can[Maxn];
int sa[Maxn], t1[Maxn], t2[Maxn], c[Maxn], dp[Maxn], n, ls;
int sta[Maxn];
bool cmp(int *y, int i, int k) {
return y[sa[i]] == y[sa[i - 1]] &&
y[(sa[i] + k) % (ls)] == y[(sa[i - 1] + k) % (ls)];
}
void getsa() {
int m = 3, n = ls;
int *x = t1, *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[s[i]]] = i;
for (int k = 1; k < n; k <<= 1) {
int p = 0;
for (int i = 0; i < n; i++) y[p++] = (sa[i] - k + n) % n;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[y[i]]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
swap(x, y);
p = 1;
x[sa[0]] = 0;
for (int i = 1; i < n; i++) x[sa[i]] = cmp(y, i, k) ? p - 1 : p++;
if (p == n) break;
m = p;
}
}
int main() {
scanf("%s", s);
ls = strlen(s);
s[ls] = 0;
for (int i = 0; i < ls; i++) s[i] -= '(' - 1;
getsa();
for (int i = ls; i < ls + ls; i++) s[i] = s[i - ls];
s[ls + ls] = 0;
for (int i = 0; i < ls + ls; i++) {
dp[i] = i == 0 ? 0 : dp[i - 1];
if (s[i] == 1)
dp[i]++;
else
dp[i]--;
}
int front = 0, rear = 0;
for (int i = ls + ls - 1; i >= 0; i--) {
while (front < rear && dp[sta[rear - 1]] >= dp[i]) rear--;
sta[rear++] = i;
if (i + ls < ls + ls && front < rear && sta[front] == i + ls) front++;
if (i < ls) {
if (front < rear &&
dp[sta[front]] - (i == 0 ? 0 : dp[i - 1]) + max(-dp[ls - 1], 0) < 0)
can[i] = 0;
else
can[i] = 1;
}
}
int ned = dp[ls - 1], ans;
for (int i = 0; i < ls; i++)
if (can[sa[i]]) {
ans = sa[i];
break;
}
if (ned < 0) {
for (int i = 0; i < -ned; i++) putchar('(');
for (int i = ans; i < ans + ls; i++) putchar(s[i] - 1 + '(');
} else {
for (int i = ans; i < ans + ls; i++) putchar(s[i] - 1 + '(');
for (int i = 0; i < ned; i++) putchar(')');
}
puts("");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct SuffixArray {
int n, csz;
vector<vector<int>> classes;
vector<int> cnt, order, oldc, newc, left;
string str;
SuffixArray(string s, bool cyclic)
: n(s.size() + !cyclic),
csz(max(n, 256)),
cnt(csz),
order(n),
oldc(n),
newc(n),
left(n),
str(s) {
if (!cyclic) str += '\0';
}
vector<int> Build() {
for (int i = 0; i < n; ++i) {
oldc[i] = newc[i] = str[i];
order[i] = left[i] = i;
}
for (int step = 1; step <= 2 * n; step *= 2) {
fill(cnt.begin(), cnt.end(), 0);
for (int i = 0; i < n; ++i) ++cnt[oldc[left[i]]];
for (int i = 1; i < csz; ++i) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; --i) order[--cnt[oldc[left[i]]]] = left[i];
newc[order[0]] = 0;
for (int i = 1; i < n; ++i) {
int now1 = order[i], last1 = order[i - 1], now2 = (now1 + step / 2) % n,
last2 = (last1 + step / 2) % n;
newc[now1] = newc[last1] +
(oldc[now1] != oldc[last1] or oldc[now2] != oldc[last2]);
}
classes.push_back(newc);
swap(oldc, newc);
for (int i = 0; i < n; ++i) {
left[i] = (order[i] + n - step) % n;
}
}
return order;
}
int Compare(int i, int j, int len) {
for (int step = 0; len; ++step, len /= 2) {
if (len % 2 == 0) continue;
int ret = classes[step][i] - classes[step][j];
if (ret != 0) return ret < 0 ? -1 : 1;
i = (i + (1 << step)) % n;
j = (j + (1 << step)) % n;
}
return 0;
}
int GetLCP(int i, int j) {
if (i == j) return str.back() == '\0' ? n - i - 1 : n;
int ans = 0;
for (int step = classes.size() - 1; step >= 0; --step) {
if (classes[step][i] == classes[step][j]) {
i = (i + (1 << step)) % n;
j = (j + (1 << step)) % n;
ans += (1 << step);
}
}
return min(ans, n);
}
};
int main() {
string s;
cin >> s;
int n = s.size();
SuffixArray sa(s, true);
vector<int> order = sa.Build();
vector<int> sp(n, 0);
vector<int> minp(n, 0), mins(n, 0);
for (int i = 0; i < n; ++i) {
if (i > 0) sp[i] = sp[i - 1];
if (s[i] == '(')
sp[i] += 1;
else
sp[i] -= 1;
minp[i] = sp[i];
if (i > 0) minp[i] = min(minp[i], minp[i - 1]);
}
for (int i = n - 1; i >= 0; --i) {
mins[i] = sp[i];
if (i + 1 < n) mins[i] = min(mins[i], mins[i + 1]);
}
int totsp = sp[n - 1];
auto OK = [&](int i) {
int ladd = max(0, -totsp);
int spi = i == 0 ? 0 : sp[i - 1];
if (mins[i] - spi + ladd < 0) return false;
if (i > 0 && minp[i - 1] + (totsp - spi) + ladd < 0) return false;
return true;
};
int choose = -1;
for (auto i : order) {
if (OK(i)) {
choose = i;
break;
}
}
assert(choose != -1);
string ans = "";
for (int i = 0; i < -totsp; ++i) ans += '(';
rotate(s.begin(), s.begin() + choose, s.end());
ans += s;
for (int i = 0; i < totsp; ++i) ans += ')';
cout << ans << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> suffix_array(string s) {
int n = s.size();
vector<int> p(n), c(n), pn(n), cn(n), f(200);
for (char i : s) f[i]++;
for (int i = 1; i < f.size(); i++) f[i] += f[i - 1];
for (int i = 0; i < n; i++) p[--f[s[i]]] = i;
int classes = 1;
c[p[0]] = 0;
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++) {
f.assign(classes, 0);
for (int i = 0; i < n; i++) pn[i] = (n + p[i] - (1 << h)) % n;
for (int i = 0; i < n; i++) f[c[pn[i]]]++;
for (int i = 1; i < classes; i++) f[i] += f[i - 1];
for (int i = n - 1; i >= 0; i--) p[--f[c[pn[i]]]] = pn[i];
classes = 1;
cn[p[0]] = 0;
for (int i = 1; i < n; i++) {
pair<int, int> cur = {c[p[i]], c[(p[i] + (1 << h)) % n]},
now = {c[p[i - 1]], c[(p[i - 1] + (1 << h)) % n]};
if (cur != now) classes++;
cn[p[i]] = classes - 1;
}
c = cn;
}
return p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
vector<int> sf = suffix_array(s);
int op = count(s.begin(), s.end(), '('), cl = count(s.begin(), s.end(), ')');
vector<int> pf(n + 1, 0), pfmin(n + 1, 0), sfmin(n + 1, op - cl);
for (int i = 0; i < n; i++) {
pf[i + 1] = (pf[i] + (s[i] == '(' ? 1 : -1));
pfmin[i + 1] = min(pf[i + 1], pfmin[i]);
}
sfmin[n] = pf[n];
for (int i = n; i > 0; i--) sfmin[i - 1] = min(sfmin[i], pf[i]);
for (int i = 0; i < sf.size(); i++) {
int down = min(sfmin[sf[i] + 1], pf.back() + pfmin[sf[i]]) - pf[sf[i]];
if (down >= min(0, op - cl)) {
for (int j = 0; j < cl - op; j++) cout << '(';
for (int j = 0; j < n; j++) cout << s[(j + sf[i]) % n];
for (int j = 0; j < op - cl; j++) cout << ')';
cout << "\n";
break;
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
char s[N];
int balance[N];
int mnbal1[N], mnbal2[N];
const int alphabet = 123;
int p[N], cnt[N], c[N];
int pn[N], cn[N];
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; ++i)
balance[i + 1] = balance[i] + (s[i] == '(' ? 1 : -1);
memset(cnt, 0, alphabet * sizeof(int));
for (int i = 0; i < len; ++i) ++cnt[static_cast<int>(s[i])];
for (int i = 1; i < alphabet; ++i) cnt[i] += cnt[i - 1];
for (int i = 0; i < len; ++i) p[--cnt[static_cast<int>(s[i])]] = i;
c[p[0]] = 0;
int classes = 1;
for (int i = 1; i < len; ++i) {
if (s[p[i]] != s[p[i - 1]]) ++classes;
c[p[i]] = classes - 1;
}
for (int h = 0; (1 << h) < len; ++h) {
for (int i = 0; i < len; ++i) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += len;
}
memset(cnt, 0, classes * sizeof(int));
for (int i = 0; i < len; ++i) ++cnt[c[pn[i]]];
for (int i = 1; i < classes; ++i) cnt[i] += cnt[i - 1];
for (int i = len - 1; i >= 0; --i) p[--cnt[c[pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (int i = 1; i < len; ++i) {
int mid1 = (p[i] + (1 << h)) % len, mid2 = (p[i - 1] + (1 << h)) % len;
if (c[p[i]] != c[p[i - 1]] || c[mid1] != c[mid2]) ++classes;
cn[p[i]] = classes - 1;
}
memcpy(c, cn, len * sizeof(int));
}
int total = balance[len];
int can = total >= 0 ? 0 : -total;
cerr << "total = " << total << endl;
cerr << "can = " << can << endl;
for (int i = 1; i <= len; ++i) mnbal1[i] = min(balance[i], mnbal1[i - 1]);
mnbal2[len] = balance[len];
for (int i = len - 1; i >= 0; --i) mnbal2[i] = min(balance[i], mnbal2[i + 1]);
int mn = *min_element(balance, balance + len);
cerr << "mn = " << mn << endl;
int start = -1;
for (int i = 0; i < len; ++i) {
int depth =
min(mnbal2[p[i]] - balance[p[i]], mnbal1[p[i]] + total - balance[p[i]]);
if (depth >= 0 || depth >= total) {
start = p[i];
break;
}
}
cerr << "start = " << start << endl;
for (int i = 0; i < -total; ++i) cout << '(';
cout << s + start;
s[start] = 0;
cout << s;
for (int i = 0; i < total; ++i) cout << ')';
cout << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int _P = 257;
const int INF = 1000000000;
const int MAXN = 1000005;
const int SZ = 1 << 21;
int N, A[2 * SZ], C[MAXN], res = -1;
long long H[2 * MAXN], P[2 * MAXN];
string S, SS;
inline int get(int p, int l) {
return (H[p + l] - H[p] * P[l] % MOD + MOD) % MOD;
}
bool comp(int a, int b) {
int lo = 0, hi = N + 1;
while (lo + 1 < hi) {
int mid = (lo + hi) / 2;
if (get(a, mid) == get(b, mid))
lo = mid;
else
hi = mid;
}
if (lo == N) return 0;
return SS[a + lo] < SS[b + lo];
}
int rmq(int l, int r) {
l += SZ, r += SZ + 1;
int res = INF;
for (; l < r; l /= 2, r /= 2) {
if (l & 1) res = min(res, A[l++]);
if (r & 1) res = min(res, A[--r]);
}
return res;
}
void init() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> S;
N = S.size();
SS = S + S;
P[0] = 1;
for (int i = 0; i < 2 * N; i++) {
H[i + 1] = (H[i] * _P + SS[i]) % MOD;
P[i + 1] = P[i] * _P % MOD;
A[i + 1 + SZ] = A[i + SZ] + 2 * (SS[i] == '(') - 1;
}
for (int i = SZ - 1; i >= 0; i--) {
A[i] = min(A[2 * i], A[2 * i + 1]);
}
}
int main() {
init();
for (int i = 0; i < N; i++) {
int k = rmq(i, i + N) - A[i + SZ];
if (k >= min(A[N + SZ], 0) && (res < 0 || comp(i, res))) {
res = i;
}
}
for (int i = 0; i < -A[N + SZ]; i++) cout << "(";
cout << SS.substr(res, N);
for (int i = 0; i < A[N + SZ]; i++) cout << ")";
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
char s[MAXN * 2];
int bl[MAXN * 2];
int dd[MAXN * 2];
int aa[MAXN];
int c[MAXN];
int newc[MAXN];
int p[MAXN];
int newp[MAXN];
int mx = -MAXN;
int cnt[MAXN];
int n;
int nm(int x) { return (x < 0 ? x + n : (x >= n ? x - n : x)); }
int main() {
scanf("%s", s);
n = strlen(s);
memcpy(s + n, s, sizeof(s[0]) * n);
bl[0] = 0;
for (int i = 0; i < 2 * n; ++i) bl[i + 1] = bl[i] + (s[i] == '(' ? 1 : -1);
int l = 0;
int r = 0;
for (int i = 0; i <= n; ++i) {
while (r - l > 0 && dd[r - 1] > bl[i]) --r;
dd[r++] = bl[i];
}
for (int i = 0; i < n; ++i) {
aa[i] = dd[l] - bl[i];
mx = max(mx, aa[i]);
if (dd[l] == bl[i]) ++l;
while (r - l > 0 && dd[r - 1] > bl[i + n + 1]) --r;
dd[r++] = bl[i + n + 1];
}
for (int i = 0; i < n; ++i) c[i] = (s[i] == '(' ? 0 : 1);
for (int i = 0; i < n; ++i) ++cnt[c[i] + 1];
for (int i = 0; i < n; ++i) cnt[i + 1] += cnt[i];
for (int i = 0; i < n; ++i) p[cnt[c[i]]++] = i;
for (int k = 0; (1 << k) < n; ++k) {
int sh = (1 << k);
for (int i = 0; i < n; ++i) p[i] = nm(p[i] - sh);
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; ++i) ++cnt[c[i] + 1];
for (int i = 0; i < n; ++i) cnt[i + 1] += cnt[i];
for (int i = 0; i < n; ++i) newp[cnt[c[p[i]]]++] = p[i];
memcpy(p, newp, sizeof(newp));
newc[p[0]] = 0;
for (int i = 1; i < n; ++i) {
if (c[p[i]] == c[p[i - 1]] && c[nm(p[i] + sh)] == c[nm(p[i - 1] + sh)])
newc[p[i]] = newc[p[i - 1]];
else
newc[p[i]] = newc[p[i - 1]] + 1;
}
memcpy(c, newc, sizeof(newc));
}
int bst = -1;
for (int i = 0; i < n; ++i)
if (aa[i] == mx && (bst == -1 || c[i] < c[bst])) bst = i;
mx = -mx;
mx = max(mx, 0);
for (int i = 0; i < mx; ++i) printf("(");
for (int i = bst; i < bst + n; ++i) printf("%c", s[i]);
int k = bl[n] + mx;
for (int i = 0; i < k; ++i) printf(")");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
char s[2001111];
int rk[2001111];
int r[2001111 * 3], sa[2001111 * 3], wa[2001111 * 3], wb[2001111 * 3],
wv[2001111 * 3], ss[2001111 * 3];
struct DC_3 {
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];
return;
}
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++];
for (int i = 0; i < n; i++) rk[sa[i]] = i;
return;
}
} DC;
multiset<int> S;
int val[2001111], mn[2001111];
char ans[2001111];
int main() {
scanf("%s", s);
int n = strlen(s);
copy(s, s + n, s + n);
for (int i = 0; i < n << 1; i++) r[i] = s[i];
DC.DC3(r, sa, (n << 1) + 1, 50);
int tmp = 0, need = 0;
for (int i = 0; i < n << 1; i++) {
if (i == n) need = tmp;
if (s[i] == '(')
val[i] = ++tmp;
else
val[i] = --tmp;
if (i < n) S.insert(val[i]);
}
mn[0] = *S.begin();
int add = 0;
for (int i = n; i < n << 1; i++) {
S.insert(val[i]);
S.erase(S.find(val[i - n]));
if (s[i - n] == '(')
add--;
else
add++;
mn[i - n + 1] = *S.begin() + add;
}
int pos = 0;
if (need < 0)
tmp = need;
else
tmp = 0;
for (int i = 0; i < n * 2; i++)
if (sa[i] < n) {
if (mn[sa[i]] - tmp >= 0) {
pos = sa[i];
break;
}
}
int nn = 0;
for (int i = 0; i < -need; i++) ans[nn++] = '(';
for (int i = pos; i < pos + n; i++) ans[nn++] = (s[i]);
for (int i = 0; i < need; i++) ans[nn++] = ')';
ans[nn] = 0;
add = 0;
for (int i = 0; i < nn; i++) {
if (ans[i] == '(')
add++;
else
add--;
if (add < 0)
while (1)
;
}
puts(ans);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char s[2000005];
int pre[2000005], qu[2000005], id[2000005];
bool flag[2000005];
struct SA {
public:
const static int MAXN = 2e6 + 5;
int cnt[MAXN], ts[MAXN], sa[MAXN], rk[MAXN], ht[MAXN], len, tr[2][MAXN];
void construct(const char *s, int n, int m = 256) {
int i, j, k, *x = tr[0], *y = tr[1];
this->len = n;
memset(cnt, 0, sizeof(cnt[0]) * m);
for (i = 0; i < n; ++i) cnt[s[i]]++;
partial_sum(cnt, cnt + m, cnt);
for (i = 0; i < n; ++i) rk[i] = cnt[s[i]] - 1;
for (k = 1; k <= n; k <<= 1) {
for (i = 0; i < n; ++i)
x[i] = rk[i], y[i] = i + k < n ? rk[i + k] + 1 : 0;
fill(cnt, cnt + n + 1, 0);
for (i = 0; i < n; ++i) cnt[y[i]]++;
partial_sum(cnt, cnt + n + 1, cnt);
for (i = n - 1; i >= 0; --i) ts[--cnt[y[i]]] = i;
fill(cnt, cnt + n + 1, 0);
for (i = 0; i < n; ++i) cnt[x[i]]++;
partial_sum(cnt, cnt + n + 1, cnt);
for (i = n - 1; i >= 0; --i) sa[--cnt[x[ts[i]]]] = ts[i];
for (i = rk[sa[0]] = 0; i + 1 < n; ++i) {
rk[sa[i + 1]] =
rk[sa[i]] + (x[sa[i]] != x[sa[i + 1]] || y[sa[i]] != y[sa[i + 1]]);
}
}
for (i = 0, k = 0; i < n; ++i) {
if (!rk[i]) continue;
for (j = sa[rk[i] - 1]; i + k < n && j + k < n && s[i + k] == s[j + k];)
k++;
ht[rk[i]] = k;
if (k) k--;
}
}
} sa;
bool ok(int t) {
int st = -1, ed = -1;
for (int i = 0; i <= n - k; i++) {
if (sa.rk[i] > t) continue;
if (ed == -1 || i > ed + 1) {
st = i;
ed = i + k - 1;
} else
ed = i + k - 1;
if (ed - st + 1 >= n / 2) return 1;
}
return 0;
}
int main() {
scanf("%s", s);
n = strlen(s);
int cnt = 0;
for (int i = 0; i < n; i++)
if (s[i] == '(') cnt++;
for (int i = n; i < 2 * n; i++) s[i] = s[i - n];
n <<= 1;
for (int i = 0; i < n; i++)
pre[i] = (i == 0 ? 0 : pre[i - 1]) + (s[i] == '(' ? 1 : -1);
int head = 1, tail = 1;
id[1] = 0;
qu[1] = pre[0];
for (int i = 1; i < n; i++) {
if (id[head] <= i - n / 2) head++;
int tmp = lower_bound(qu + head, qu + tail + 1, pre[i]) - qu;
qu[tail = tmp] = pre[i], id[tail] = i;
if (i >= n / 2 - 1 && qu[head] >= (i == n / 2 - 1 ? 0 : pre[i - n / 2]) -
max(0, n / 2 - 2 * cnt))
flag[i - n / 2 + 1] = 1;
}
sa.construct(s, n);
int i = 0;
for (; i <= n; i++)
if (flag[sa.sa[i]] && sa.sa[i] < n / 2) break;
if (cnt < n / 2 - cnt)
for (int j = 0; j < n / 2 - 2 * cnt; j++) printf("%c", '(');
for (int j = 0; j < n / 2; j++) printf("%c", s[sa.sa[i] + j]);
if (cnt > n / 2 - cnt)
for (int j = 0; j < 2 * cnt - n / 2; j++) printf("%c", ')');
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];
n = n + n;
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]);
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;
}
for (i = n - 1; i > m; i--)
if (s[i] == '(') {
if (sl)
sm++, sl--;
else
sr++;
} else
sl++;
k = n + n;
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>
#pragma GCC optimize(2)
using namespace std;
void qread(int &x) {
int neg = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = 10 * x + c - '0', c = getchar();
x *= neg;
}
const int maxn = 1000005;
const long long mod1 = 1e9 + 7;
const long long H1 = 20160516;
const long long mod2 = 998244353;
const long long H2 = 20000000;
int n, ans, lft, rgt;
int sum[maxn], pre[maxn], suf[maxn];
long long h1[maxn * 2], pw1[maxn * 2], h2[maxn * 2], pw2[maxn * 2];
char c[maxn];
string s, t;
pair<long long, long long> getval(int l, int r) {
long long val1 =
(h1[r] - (!l ? 0 : h1[l - 1]) * pw1[r - l + 1] % mod1 + mod1) % mod1;
long long val2 =
(h2[r] - (!l ? 0 : h2[l - 1]) * pw2[r - l + 1] % mod2 + mod2) % mod2;
return make_pair(val1, val2);
}
bool Cmp(int i, int j) {
int l = 0, r = 2 * n;
while (r - l > 1) {
int mid = l + r >> 1;
if (i + mid - 1 >= 2 * n || j + mid - 1 >= 2 * n ||
getval(i, i + mid - 1) != getval(j, j + mid - 1))
r = mid;
else
l = mid;
}
if (i + r - 1 >= 2 * n || j + r - 1 >= 2 * n) return true;
return t[i + r - 1] < t[j + r - 1];
}
int main() {
scanf("%s", c);
s = c;
n = s.size();
t = s + s;
pw1[0] = pw2[0] = 1;
for (int(i) = 1; (i) <= t.size(); i++)
pw1[i] = pw1[i - 1] * H1 % mod1, pw2[i] = pw2[i - 1] * H2 % mod2;
h1[0] = h2[0] = t[0];
for (int(i) = 1; (i) <= t.size() - 1; i++) {
h1[i] = (h1[i - 1] * H1 + t[i]) % mod1;
h2[i] = (h2[i - 1] * H2 + t[i]) % mod2;
}
for (int(i) = 0; (i) < n; i++)
sum[i] = (!i ? 0 : sum[i - 1]) + (s[i] == '(' ? 1 : -1);
pre[0] = sum[0];
for (int(i) = 1; (i) <= n - 1; 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]);
ans = -1;
int anslen = 1e9;
if (sum[n - 1] < 0)
lft = -sum[n - 1];
else
rgt = sum[n - 1];
for (int(i) = 0; (i) < n; i++) {
int dlt = (!i ? 0 : sum[i - 1]);
int mn = min(suf[i] - dlt, (!i ? 0 : pre[i - 1]) + sum[n - 1] - dlt);
int curl = max(max(-sum[n - 1], 0), -mn);
if (curl + rgt + n < anslen) {
anslen = curl + rgt + n;
lft = curl;
ans = i;
} else if (curl + rgt + n == anslen) {
if (Cmp(i, ans)) ans = i, lft = curl;
}
}
for (int(i) = 0; (i) < lft; i++) putchar('(');
for (int i = ans; i < n; i++) putchar(s[i]);
for (int(i) = 0; (i) < ans; i++) putchar(s[i]);
for (int(i) = 0; (i) < rgt; i++) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 * 1000;
int pos[N];
int new_pos[N];
int c[N];
int new_c[N];
int head[N];
int cnt[N];
string s;
int n;
int low(int i, int step) {
i -= step;
if (i < 0) i += n;
return i;
}
int high(int i, int step) {
i += step;
if (i >= n) i -= n;
return i;
}
bool are_same(int p1, int p2, int step) {
if (c[p1] != c[p2]) return false;
p1 = high(p1, step);
p2 = high(p2, step);
if (c[p1] != c[p2]) return false;
return true;
}
void build_array() {
n = s.length();
fill(head, head + N, 0);
fill(cnt, cnt + N, 0);
for (int i = 0; i < n; ++i) ++cnt[s[i]];
for (int i = 1; i < N; ++i) head[i] = head[i - 1] + cnt[i - 1];
for (int i = 0; i < n; ++i) {
c[i] = s[i];
pos[head[c[i]]++] = i;
}
head[0] = 0;
for (int i = 1; i < N; ++i) head[i] = head[i - 1] + cnt[i - 1];
for (int step = 1; step <= n; step *= 2) {
for (int i = 0; i < n; ++i) {
int cur = low(pos[i], step);
new_pos[head[c[cur]]++] = cur;
}
head[0] = 0;
new_c[new_pos[0]] = 0;
bool all_diff = true;
for (int i = 1; i < n; ++i)
if (are_same(new_pos[i], new_pos[i - 1], step)) {
new_c[new_pos[i]] = new_c[new_pos[i - 1]];
all_diff = false;
} else {
new_c[new_pos[i]] = new_c[new_pos[i - 1]] + 1;
head[new_c[new_pos[i]]] = i;
}
copy(new_c, new_c + n, c);
copy(new_pos, new_pos + n, pos);
if (all_diff) break;
}
}
int main() {
getline(cin, s);
build_array();
vector<int> bal(n);
int sum = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(')
sum++;
else
sum--;
bal[i] = sum;
}
int tot = sum;
vector<int> suffMin(n + 1, N);
for (int i = n - 1; i >= 0; i--) suffMin[i] = min(bal[i], suffMin[i + 1]);
vector<bool> good(n);
int curMin = N;
for (int i = 0; i < n; i++) {
int old = i == 0 ? 0 : bal[i - 1];
bool ok = true;
if (suffMin[i] - old < min(tot, 0)) ok = false;
if (tot - old + curMin < min(tot, 0)) ok = false;
if (ok) good[i] = true;
curMin = min(curMin, bal[i]);
}
int start = 0;
for (int i = 0; i < n; i++)
if (good[pos[i]]) {
start = pos[i];
break;
}
for (int i = 0; i < -sum; i++) cout << "(";
for (int i = 0; i < n; i++) cout << s[(i + start) % n];
for (int i = 0; i < sum; i++) cout << ")";
cout << "\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int w[2000010], wa[2000010], wb[2000010], sa[2000010], s[2000010], f[2000010],
q[2000010];
char st[2000010];
void suffix(char *s, int n) {
int i, j, p, m = 128, *first = wa, *second = wb;
for (i = 0; i < m; i++) w[i] = 0;
for (i = 0; i < n; i++) w[first[i] = s[i]]++;
for (i = 1; i < m; i++) w[i] += w[i - 1];
for (i = n - 1; i >= 0; i--) sa[--w[first[i]]] = i;
for (j = 1, p = 0; p != n && j < n; j <<= 1, m = p) {
for (i = 0, p = 0; i < n; i++) second[p++] = (sa[i] - j + n) % n;
for (i = 0; i < m; i++) w[i] = 0;
for (i = 0; i < n; i++) w[first[i]]++;
for (i = 1; i < m; i++) w[i] += w[i - 1];
for (i = n - 1; i >= 0; i--) sa[--w[first[second[i]]]] = second[i];
swap(first, second);
for (i = 1, first[sa[0]] = 0, p = 1; i < n; i++) {
first[sa[i]] = (second[sa[i - 1]] == second[sa[i]] &&
second[(sa[i - 1] + j) % n] == second[(sa[i] + j) % n])
? p - 1
: p++;
}
}
}
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, n);
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; 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 maxn = 4.1e6;
string str, pstr;
int n, ans, nst[maxn], pos[maxn];
multiset<int> S;
inline int idx(char c) { return c == '(' ? 1 : -1; }
void prepare() {
n = str.size(), str += str;
for (int i = 1; i <= n; ++i) ans += idx(str[i - 1]);
for (int i = 1; i <= (int)str.size(); ++i)
nst[i] = nst[i - 1] + idx(str[i - 1]);
for (int i = 1; i <= n; ++i) S.insert(nst[i]);
for (int i = 1; i <= n; ++i) {
if (*S.begin() - min(ans, 0) - nst[i - 1] >= 0) pos[i - 1] = 1;
S.insert(nst[i + n]), S.erase(S.find(nst[i]));
}
}
void min_iso() {
for (int i = 1; i <= abs(ans); ++i) pstr += ans > 0 ? ')' : '(';
if (ans < 0) cout << pstr;
int i, j, k, l;
for (i = -1, j = 0, k = 0; i < n && j < n && k < n;) {
if (!pos[j]) {
j++;
continue;
}
if (i == -1) {
i = j, j++;
continue;
}
int t = idx(str[i + k]) - idx(str[j + k]);
if (!t)
k++;
else {
if (t > 0)
j += k + 1;
else
l = i + k, i = j, j = max(l, j) + 1;
k = 0;
}
}
cout << str.substr(i, n);
if (ans > 0) cout << pstr;
}
int main() {
cin >> str;
prepare();
min_iso();
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1011111, max_lev = 21, inf = 1111111111;
struct tree {
int a[4 * max_n], f[4 * max_n];
tree() {
memset(a, 0, sizeof(a));
memset(f, 0, sizeof(f));
}
void push(int v, int l, int r) {
if (f[v] != 0) {
a[v] += f[v];
f[2 * v] += f[v];
f[2 * v + 1] += f[v];
f[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r, int value) {
if (tl == l && tr == r) {
f[v] += value;
return;
}
push(v, tl, tr);
int mid = (tl + tr) / 2;
if (r <= mid) {
update(2 * v, tl, mid, l, r, value);
} else if (l > mid) {
update(2 * v + 1, mid + 1, tr, l, r, value);
} else {
update(2 * v, tl, mid, l, mid, value);
update(2 * v + 1, mid + 1, tr, mid + 1, r, value);
}
a[v] = min(a[2 * v] + f[2 * v], a[2 * v + 1] + f[2 * v + 1]);
}
int get_min(int v, int tl, int tr, int l, int r) {
if (tl == l && tr == r) {
return a[v] + f[v];
}
push(v, tl, tr);
int mid = (tl + tr) / 2;
if (r <= mid) {
return get_min(2 * v, tl, mid, l, r);
}
if (l > mid) {
return get_min(2 * v + 1, mid + 1, tr, l, r);
}
return min(get_min(2 * v, tl, mid, l, mid),
get_min(2 * v + 1, mid + 1, tr, mid + 1, r));
}
void write(int v, int l, int r) {
if (l == r) {
cout << l << ' ' << r << " - " << a[v] << " (" << f[v] << ")\n";
return;
}
cout << l << ' ' << r << " - " << a[v] << " (" << f[v] << ")\n";
int mid = (l + r) / 2;
write(2 * v, l, mid);
write(2 * v + 1, mid + 1, r);
}
};
int n, a[2][max_n], cl[2][max_n], num[2][max_n], f[max_n], sum[max_n];
pair<int, pair<int, int> > p[max_n], p2[max_n];
string s;
char S[max_n];
tree t;
bool cmp(int a, int b) { return s[a] < s[b] || s[a] == s[b] && a < b; }
void my_sort() {
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; ++i) {
++sum[p[i].second.first + 1];
}
for (int i = 1; i < n; ++i) {
sum[i] += sum[i - 1];
}
sum[0] = 0;
for (int i = 0; i < n; ++i) {
p2[sum[p[i].second.first]++] = p[i];
}
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; ++i) {
++sum[p2[i].first + 1];
}
for (int i = 1; i < n; ++i) {
sum[i] += sum[i - 1];
}
sum[0] = 0;
for (int i = 0; i < n; ++i) {
p[sum[p2[i].first]++] = p2[i];
}
}
void get_suffix_array() {
for (int i = 0; i < n; ++i) {
a[0][i] = i;
}
sort(a[0], a[0] + n, cmp);
int cnt = 0;
for (int i = 0; i < n; ++i) {
num[0][a[0][i]] = i;
}
for (int i = 0; i < n; ++i) {
while (i + 1 < n && s[a[0][i]] == s[a[0][i + 1]]) {
cl[0][i] = cnt;
++i;
}
cl[0][i] = cnt;
++cnt;
}
int f1 = 0, f2 = 1;
for (int lev = 1, len = 1; len <= n; ++lev, len *= 2) {
for (int i = 0; i < n; ++i) {
p[i] = make_pair(cl[f1][num[f1][i]],
make_pair(cl[f1][num[f1][(i + len) % n]], i));
}
my_sort();
for (int i = 0; i < n; ++i) {
a[f2][i] = p[i].second.second;
num[f2][a[f2][i]] = i;
}
cnt = 0;
for (int i = 0; i < n; ++i) {
while (i + 1 < n && p[i].first == p[i + 1].first &&
p[i].second.first == p[i + 1].second.first) {
cl[f2][i] = cnt;
++i;
}
cl[f2][i] = cnt;
++cnt;
}
swap(f1, f2);
}
}
int main() {
scanf("%s", &S);
s = S;
n = s.length();
get_suffix_array();
int bal = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == '(') {
++bal;
} else {
--bal;
}
t.update(1, 0, n - 1, i, i, bal);
}
for (int i = 0; i < n; ++i) {
int mn = t.get_min(1, 0, n - 1, 0, n - 1);
if (bal > 0) {
if (mn >= 0) {
f[i] = 1;
}
} else {
if (mn - bal >= 0) {
f[i] = 1;
}
}
int x = 1;
if (s[i] == '(') {
x = -1;
}
if (i + 1 < n) {
t.update(1, 0, n - 1, i + 1, n - 1, x);
}
if (i) {
t.update(1, 0, n - 1, 0, i - 1, x);
}
t.update(1, 0, n - 1, i, i, bal - t.get_min(1, 0, n - 1, i, i));
}
if (bal < 0) {
for (int i = 0; i < -bal; ++i) {
printf("(");
}
}
for (int i = 0; i < n; ++i) {
if (f[a[0][i]] == 1) {
int poz = a[0][i];
for (int j = 0; j < n; ++j) {
printf("%c", s[(j + poz) % n]);
}
break;
}
}
if (bal > 0) {
for (int i = 0; i < bal; ++i) {
printf(")");
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
char s[MAXN];
int n;
int classes[MAXN];
int bottom = 0, whereb = 0;
int main() {
gets(s);
n = strlen(s);
int bal = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == '(') {
++bal;
classes[i] = 0;
} else {
classes[i] = 1;
--bal;
}
if (bottom > bal) {
bottom = bal;
}
if (bottom == bal) {
whereb = i;
}
}
for (int j = 1; j <= n * 2; j <<= 1) {
vector<pair<pair<int, int>, int> > tmpa;
for (int i = 0; i < n; ++i) {
tmpa.push_back(make_pair(make_pair(classes[i], classes[(i + j) % n]), i));
}
sort((tmpa).begin(), (tmpa).end());
pair<int, int> prev = tmpa[0].first;
int c = 0;
for (int i = 0; i < n; ++i) {
if (prev != tmpa[i].first) {
++c;
prev = tmpa[i].first;
}
classes[tmpa[i].second] = c;
}
}
if (bal <= 0) {
int tmpbal = 0;
pair<int, int> best = make_pair(1e9 + 9, -1);
int nowmin = 0;
for (int i = 0; i < n; ++i) {
if (tmpbal == bottom || (nowmin >= tmpbal && tmpbal - bottom <= -bal)) {
best = min(best, make_pair(classes[i], i));
}
if (s[i] == '(') {
++tmpbal;
} else {
--tmpbal;
}
nowmin = min(nowmin, tmpbal);
}
for (int i = 0; i < -bal; ++i) {
printf("(");
}
for (int i = 0; i < n; ++i) {
printf("%c", s[(i + best.second) % n]);
}
printf("\n");
return 0;
}
bool can[MAXN];
memset(can, 0, sizeof can);
int nowbal = 0;
int nowmin = 0;
for (int i = n - 1; i >= 0; --i) {
if (nowbal <= nowmin) {
can[i] = true;
}
if (s[i] == ')') {
++nowbal;
} else {
--nowbal;
}
nowmin = min(nowmin, nowbal);
}
int tmpbal = 0;
pair<int, int> best = make_pair(1e9 + 9, -1);
for (int i = 0; i < n; ++i) {
if ((tmpbal - bottom <= bal && can[i]) || tmpbal == bottom) {
best = min(best, make_pair(classes[i], i));
}
if (s[i] == '(') {
++tmpbal;
} else {
--tmpbal;
}
}
for (int i = 0; i < n; ++i) {
printf("%c", s[(i + best.second) % n]);
}
for (int i = 0; i < bal; ++i) {
printf(")");
}
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9;
const long long INFL = (long long)9e18;
const int MAXINT = ((~0) ^ (1 << 31));
const long long MAXLL = ((~0) ^ ((long long)1 << 63));
template <class T>
inline T pow2(T a) {
return a * a;
}
template <class T>
inline bool mineq(T& a, T b) {
return (a > b) ? (a = b, true) : false;
}
template <class T>
inline bool maxeq(T& a, T b) {
return (a < b) ? (a = b, true) : false;
}
const int maxn = (int)2e6 + 10;
;
const int MOD = (int)1e9 + 7;
;
long long hash1[maxn], hash2[maxn], p1[maxn], p2[maxn], rp1[maxn], rp2[maxn],
a[maxn];
bool valid[maxn];
long long n;
string str;
long long powmod(long long a, long long b) {
if (!b) return 1;
long long t = powmod(a, b / 2);
t = (t * t) % MOD;
if (b & 1) t = (t * a) % MOD;
return t;
}
void pre() {
p1[0] = p2[0] = rp1[0] = rp2[0] = 1;
hash1[0] = hash2[0] = str[0];
for (int i = 1; i < (int)(str.size()); i++) {
p1[i] = (p1[i - 1] * 31) % MOD;
rp1[i] = powmod(p1[i], MOD - 2);
p2[i] = (p2[i - 1] * 61) % MOD;
rp2[i] = powmod(p2[i], MOD - 2);
hash1[i] = (hash1[i - 1] + p1[i] * str[i]) % MOD;
hash2[i] = (hash2[i - 1] + p2[i] * str[i]) % MOD;
}
}
inline long long gethash(int l, int r, long long hash[maxn],
long long rp[maxn]) {
long long pr = (l ? hash[l - 1] : 0);
return ((hash[r] - pr + MOD) * rp[l]) % MOD;
}
inline pair<long long, long long> gethash(int l, int r) {
return make_pair(gethash(l, r, hash1, rp1), gethash(l, r, hash2, rp2));
}
inline bool cmp(int a, int b) {
int l = 0, r = n - 1, mid = -1, ans = -1;
if (b == -1) return true;
while (l <= r) {
mid = (l + r) / 2;
if (gethash(a, a + mid) == gethash(b, b + mid)) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
if (a + ans + 1 == (int)str.size() || b + ans + 1 == (int)str.size())
return false;
return str[a + ans + 1] < str[b + ans + 1];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> str;
n = str.size();
str += str;
pre();
int ans = -1, open = 0, close = 0, dif = 0;
multiset<int> st;
for (int i = 0; i < (int)(n); i++) {
if (str[i] == '(')
open++;
else
close++;
a[i] = open - close;
}
for (int i = 0; i < (int)(2 * n); i++) {
if (str[i] == '(')
dif++;
else
dif--;
st.insert(dif);
if (i >= n) st.erase(st.find(a[i - n]));
if (i >= n - 1) {
long long pr = (i == n - 1 ? 0 : a[i - n]);
if (*st.begin() - pr >= 0) valid[i - n + 1] = true;
if (open < close && *st.begin() - pr >= open - close)
valid[i - n + 1] = true;
}
}
for (int i = 0; i < (int)(n); i++) {
if (valid[i] && cmp(i, ans)) ans = i;
}
cerr << "* " << ans << endl;
if (open < close) {
for (int i = 0; i < (int)(close - open); i++) cout << '(';
}
for (int i = ans; i < (int)(ans + n); i++) cout << str[i];
if (open > close) {
for (int i = 0; i < (int)(open - close); i++) cout << ')';
}
cerr << open << " " << close << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class A, class B, class C>
struct Triple {
A first;
B second;
C third;
};
template <class T>
void ResizeVec(T&, vector<long long>) {}
template <class T>
void ResizeVec(vector<T>& vec, vector<long long> sz) {
vec.resize(sz[0]);
sz.erase(sz.begin());
if (sz.empty()) {
return;
}
for (T& v : vec) {
ResizeVec(v, sz);
}
}
inline bool leq(long long a1, long long a2, long long b1, long long b2) {
return (a1 < b1 || a1 == b1 && a2 <= b2);
}
inline bool leq(long long a1, long long a2, long long a3, long long b1,
long long b2, long long b3) {
return (a1 < b1 || a1 == b1 && leq(a2, a3, b2, b3));
}
static void radixPass(long long* a, long long* b, long long* r, long long n,
long long K) {
long long* c = new long long[K + 1];
for (long long i = 0; i <= K; i++) c[i] = 0;
for (long long i = 0; i < n; i++) c[r[a[i]]]++;
for (long long i = 0, sum = 0; i <= K; i++) {
long long t = c[i];
c[i] = sum;
sum += t;
}
for (long long i = 0; i < n; i++) b[c[r[a[i]]]++] = a[i];
delete[] c;
}
void suffixArray(long long* s, long long* SA, long long n, long long K) {
long long n0 = (n + 2) / 3, n1 = (n + 1) / 3, n2 = n / 3, n02 = n0 + n2;
long long* s12 = new long long[n02 + 3];
s12[n02] = s12[n02 + 1] = s12[n02 + 2] = 0;
long long* SA12 = new long long[n02 + 3];
SA12[n02] = SA12[n02 + 1] = SA12[n02 + 2] = 0;
long long* s0 = new long long[n0];
long long* SA0 = new long long[n0];
for (long long 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);
long long name = 0, c0 = -1, c1 = -1, c2 = -1;
for (long long 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) {
suffixArray(s12, SA12, n02, name);
for (long long i = 0; i < n02; i++) s12[SA12[i]] = i + 1;
} else
for (long long i = 0; i < n02; i++) SA12[s12[i] - 1] = i;
for (long long i = 0, j = 0; i < n02; i++)
if (SA12[i] < n0) s0[j++] = 3 * SA12[i];
radixPass(s0, SA0, s, n0, K);
for (long long p = 0, t = n0 - n1, k = 0; k < n; k++) {
long long i = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
long long 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;
}
const long long N = 2e6 + 5;
long long s[N];
long long SA[N];
vector<long long> MinK(vector<long long> vec, long long k) {
vector<long long> res;
long long n = ((long long)(vec).size());
if (n - k + 1 <= 0) {
return vector<long long>();
}
res.resize(n - k + 1);
vector<long long> que;
long long beg;
for (long long i = 0; i < ((long long)(vec).size()); i++) {
while (!que.empty() && vec[que.back()] >= vec[i]) {
que.pop_back();
}
que.push_back(i);
beg = min(beg, ((long long)(que).size()) - 1);
if (que[beg] <= i - k) {
beg++;
}
if (i >= k - 1) {
res[i - k + 1] = vec[que[beg]];
}
}
for (long long i = (1); i <= (k - 1); ++i) {
res.push_back(N);
}
return res;
}
long long SAinv[N];
int main() {
ios_base::sync_with_stdio(0);
string br;
cin >> br;
;
long long n = ((long long)(br).size());
br = ' ' + br;
for (long long i = (1); i <= (n); ++i) {
if (br[i] == '(') {
s[i] = 1;
} else {
s[i] = 2;
}
}
vector<long long> bilv(2 * n + 5);
bilv.push_back(0);
for (long long i = (n + 1); i <= (2 * n); ++i) {
s[i] = s[i - n];
br += br[i - n];
}
long long b = 0;
for (long long i = (1); i <= (2 * n); ++i) {
if (s[i] == 1) {
b++;
} else {
b--;
}
bilv[i] = b;
}
long long bil = bilv[n];
suffixArray(s + 1, SA + 1, 2 * n, 2);
for (long long i = (1); i <= (2 * n); ++i) {
SAinv[SA[i] + 1] = i;
}
vector<long long> mins = MinK(bilv, n);
;
;
;
long long best = 0;
SAinv[0] = N;
for (long long i = (0); i <= (n - 1); ++i) {
if (mins[i + 1] >= bilv[i] + min(0ll, bil)) {
if (SAinv[i + 1] < SAinv[best]) {
;
best = i + 1;
}
}
}
if (bil < 0) {
for (long long i = (1); i <= (-bil); ++i) {
putchar('(');
}
}
for (long long i = (best); i <= (best + n - 1); ++i) {
putchar(br[i]);
}
if (bil >= 0) {
for (long long i = (1); i <= (bil); ++i) {
putchar(')');
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
const int M = 4e6 + 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);
}
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, op, zp, zs, os, 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];
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;
for (j = 0; j < il; ++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; ++j) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[2000005], t[1000005];
int n;
int bal[2000005];
int ord[1000005], c[1000005], nord[1000005], nc[1000005];
int cnt[1000005];
stack<int> st;
bool mt[2000005];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < (int)(2); ++i) cnt[i] = 0;
for (int i = 0; i < (int)(n); ++i) ++cnt[s[i] == '(' ? 0 : 1];
for (int i = 0; i < (int)(1); ++i) cnt[i + 1] += cnt[i];
for (int i = 0; i < (int)(n); ++i) ord[--cnt[s[i] == '(' ? 0 : 1]] = i;
c[ord[0]] = 0;
int cpos = 0;
for (int i = 1; i < n; ++i) {
if (s[ord[i - 1]] != s[ord[i]]) ++cpos;
c[ord[i]] = cpos;
}
for (int sz = 1; sz < n; sz <<= 1) {
for (int i = 0; i < (int)(n); ++i) {
nord[i] = ord[i] - sz;
if (nord[i] < 0) nord[i] += n;
}
for (int i = 0; i < (int)(n); ++i) cnt[i] = 0;
for (int i = 0; i < (int)(n); ++i) ++cnt[c[nord[i]]];
for (int i = 0; i < (int)(n - 1); ++i) cnt[i + 1] += cnt[i];
for (int i = n - 1; i >= 0; --i) ord[--cnt[c[nord[i]]]] = nord[i];
nc[ord[0]] = 0;
cpos = 0;
for (int i = 1; i < n; ++i) {
int mid1 = ord[i - 1] + sz, mid2 = ord[i] + sz;
if (mid1 >= n) mid1 -= n;
if (mid2 >= n) mid2 -= n;
if (c[ord[i - 1]] != c[ord[i]] || c[mid1] != c[mid2]) ++cpos;
nc[ord[i]] = cpos;
}
for (int i = 0; i < (int)(n); ++i) c[i] = nc[i];
}
for (int i = 0; i < (int)(n); ++i) s[n + i] = s[i];
int N = n << 1;
int mx = 0, cbal = 0;
for (int i = 0; i < (int)(N); ++i) {
if (s[i] == '(')
st.push(i);
else if (!st.empty()) {
++cbal;
mt[st.top()] = true;
st.pop();
}
if (i >= n && mt[i - n]) --cbal;
bal[i] = cbal;
mx = max(mx, cbal);
}
int best = -1;
for (int i = 0; i < (int)(n); ++i)
if (bal[ord[i] - 1 + n] == mx) {
best = ord[i];
break;
}
int cur = 0, cnt = 0;
for (int i = best; i < best + n; ++i) {
int pos = i % n;
cur += s[pos] == '(' ? 1 : -1;
if (cur < 0) ++cur, ++cnt;
}
while (cnt > 0) printf("("), --cnt;
for (int i = best; i < best + n; ++i) {
int pos = i % n;
printf("%c", s[pos]);
}
while (cur > 0) printf(")"), --cur;
printf("\n");
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 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];
n = n + n;
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]);
sort(a + 1, a + n + 1);
for (i = j = 1; i <= n; i++) rk[a[i].i] = j, j += a[i + 1] != a[i];
}
for (i = n - 1; i > m; i--)
if (s[i] == '(') {
if (sl)
sm++, sl--;
else
sr++;
} else
sl++;
k = n + n;
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 long double PI = acos(-1.0);
const int MAXN = 2000001;
const int LG = 21;
char s[MAXN];
int n;
int a[MAXN];
int pref[MAXN];
int suf[MAXN];
pair<int, int> pp[MAXN];
int p[MAXN];
int c[MAXN][LG];
int as1[MAXN];
int as2[MAXN];
inline int get_bal(int x) { return min(suf[x] - a[x], a[n] - a[x] + pref[x]); }
int main() {
scanf("%s", s);
n = strlen(s);
if (n == 1) {
cout << "()" << endl;
return 0;
}
a[0] = 0;
int adb = 0;
pref[0] = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(')
a[i + 1] = a[i] + 1, adb++;
else
a[i + 1] = a[i] - 1, adb--;
pref[i + 1] = min(pref[i], a[i + 1]);
}
suf[n] = a[n];
for (int i = n - 1; i >= 0; i--) suf[i] = min(suf[i + 1], a[i]);
int s0 = 0, s1 = n - 1;
for (int i = 0; i < n; i++) {
if (s[i] == '(')
c[i][0] = 0, as1[s0++] = i;
else
c[i][0] = 1, as1[s1--] = i;
}
for (int j = 1; j < LG; j++) {
int pi = (1 << (j - 1));
for (int i = 0; i < n; i++) {
pp[i] = make_pair(c[i][j - 1], c[pi][j - 1]);
as1[i] -= (1 << (j - 1)) % n;
if (as1[i] < 0) as1[i] += n;
pi++;
if (pi == n) pi = 0;
}
for (int i = 0; i < n; i++) p[i] = 0;
for (int i = 0; i < n; i++) {
p[pp[as1[i]].first]++;
}
for (int i = 1; i < n; i++) p[i] += p[i - 1];
for (int i = n - 1; i >= 0; i--) {
as2[--p[pp[as1[i]].first]] = as1[i];
}
for (int i = 0; i < n; i++) as1[i] = as2[i];
int cur = 0;
for (int i = 0; i < n; i++) {
if ((i != 0) && (pp[as1[i]] != pp[as1[i - 1]])) cur++;
c[as1[i]][j] = cur;
}
}
int bb = -n - 1, bc = n * 2, bid = -1;
for (int i = 0; i < n; i++) {
int nb = get_bal(i);
if (make_pair(nb, -c[i][LG - 1]) > make_pair(bb, -bc))
bb = nb, bc = c[i][LG - 1], bid = i;
}
int ad = -get_bal(bid);
for (int i = 0; i < ad; i++) printf("(");
adb += ad;
for (int i = 0; i < n; i++) printf("%c", s[(i + bid) % n]);
for (int i = 0; i < adb; i++) printf(")");
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005, mo[2] = {(int)1e9 + 7, (int)1e9 + 9}, inf = 0x7fffffff;
int n;
char s[N * 2];
int pw[N * 2][2];
int h[N * 2][2];
int sum[N], a[N], b[N];
int calc(const int x, const int len, const int f) {
return (h[x][f] + 1LL * (mo[f] - pw[len][f]) * h[x + len][f]) % mo[f];
}
int lcp(const int x, const int y) {
int l = 0, r = n + 1;
while (r - l > 1) {
int mid = l + r >> 1;
if (calc(x, mid, 0) == calc(y, mid, 0) &&
calc(x, mid, 1) == calc(y, mid, 1))
l = mid;
else
r = mid;
}
return l;
}
bool cmp(const int x, const int y) {
int t = lcp(x, y);
return s[x + t] < s[y + t];
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) sum[i + 1] = sum[i] + (s[i] == '(' ? 1 : -1);
for (int i = 0; i < n; i++) s[i + n] = s[i];
pw[0][0] = pw[0][1] = 1;
for (int i = 1; i <= n * 2; i++)
pw[i][0] = 3LL * pw[i - 1][0] % mo[0],
pw[i][1] = 3LL * pw[i - 1][1] % mo[1];
for (int i = n * 2 - 1; i >= 0; i--)
h[i][0] = ((s[i] == '(' ? 1 : 2) + 3LL * h[i + 1][0]) % mo[0],
h[i][1] = ((s[i] == '(' ? 1 : 2) + 3LL * h[i + 1][1]) % mo[1];
a[n] = inf;
for (int i = n - 1; i >= 0; i--) a[i] = min(sum[i + 1], a[i + 1]);
b[0] = inf;
for (int i = 1; i <= n; i++) b[i] = min(sum[i] + sum[n], b[i - 1]);
int ans = -1;
for (int i = 0; i < n; i++)
if (min(0, min(a[i], b[i]) - sum[i]) == min(0, sum[n])) {
if (ans == -1 || cmp(i, ans)) ans = i;
}
for (int i = sum[n]; i < 0; i++) putchar('(');
for (int i = 0; i < n; i++) putchar(s[ans + i]);
for (int i = 0; i < sum[n]; i++) putchar(')');
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string inp;
cin >> inp;
int n = inp.length();
int lc = 0, rc = 0;
for (int i = 0; i < n; ++i) {
if (inp[i] == ')')
rc++;
else
lc++;
}
if (lc == 0 || rc == 0) {
for (int i = 0; i < n; ++i) cout << '(';
for (int i = 0; i < n; ++i) cout << ')';
cout << endl;
} else {
vector<int> match(n, -1);
deque<int> lopen;
queue<int> ropen;
for (int i = 0; i < n; ++i) {
if (inp[i] == '(')
lopen.push_back(i);
else if (!lopen.empty()) {
int j = lopen.back();
lopen.pop_back();
match[j] = i;
match[i] = j;
} else
ropen.push(i);
}
int um = (int)lopen.size() - (int)ropen.size();
int b = 0, nstp = 1;
for (int i = 1; i < n; ++i) {
int j = i - 1;
if (inp[j] == '(') {
if (match[j] != -1) {
match[match[j]] = -1;
match[j] = -1;
} else
lopen.pop_front();
lopen.push_back(j);
} else {
if (!lopen.empty()) {
int k = lopen.back();
lopen.pop_back();
match[k] = j;
match[j] = k;
}
}
if (inp[j] == ')' && inp[i] == '(' && nstp <= i) {
if ((um >= 0 && (int)lopen.size() == um) ||
(um < 0 && lopen.size() == 0)) {
if (b == 0 && um < 0 && ropen.size() + um > 0)
b = i;
else
for (int k = 0; k < n; ++k) {
if (inp[(i + k) % n] != inp[(b + k) % n]) {
nstp = i + k - 1;
if (inp[(i + k) % n] == '(') {
b = i;
}
break;
}
if (k == n - 1) {
b = i;
nstp = i + k - 1;
}
}
}
}
}
if (um < 0)
for (int i = 0; i < abs(um); ++i) {
cout << '(';
}
for (int i = 0; i < n; ++i) cout << inp[(b + i) % n];
if (um > 0)
for (int i = 0; i < um; ++i) {
cout << ')';
}
cout << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int Mod = (int)1e9 + 7;
const int MX = 2147483647;
const long long MXLL = 9223372036854775807;
const int Sz = 1110111;
using namespace std;
inline void Read_rap() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long a[Sz], n, f[Sz], ans = 1, len = 0;
long long binpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res *= a, res %= Mod;
b--;
}
a *= a;
a %= Mod;
b >>= 1;
}
return res;
}
long long C(long long x, long long y) {
long long res = f[x + y - 1];
res *= binpow(f[x], Mod - 2);
res %= Mod;
res *= binpow(f[y - 1], Mod - 2);
res %= Mod;
return res;
}
int main() {
Read_rap();
f[0] = 1;
for (int i = 1; i < Sz; i++) f[i] = (f[i - 1] * i) % Mod;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ans *= C(len, a[i]);
ans %= Mod;
len += a[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, pair<long long, long long> > > L;
set<pair<long long, long long> > Z;
struct N {
int l;
int d;
};
bool comp(N a, N b) { return a.l < b.l; }
long long combination[1010][1010];
int main() {
long long k, c, i, j;
cin >> k;
combination[0][0] = 1;
for (i = 1; i < 1004; i++) {
combination[i][0] = 1;
for (j = 1; j < i + 1; j++) {
combination[i][j] =
(combination[i - 1][j] + combination[i - 1][j - 1]) % 1000000007;
}
}
long long ans = 1, N = 0, R;
for (i = 0; i < k; i++) {
cin >> c;
N += c;
R = c - 1;
ans = (ans * combination[N - 1][R]) % 1000000007;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
from sys import stdin
c = [[0]*1002 for _ in range(0,1002)]
MOD = int(1e9+7)
for i in range(0,1002):
c[i][0] = c[i][i] = 1
for j in range(0,i):
c[i][j] = (c[i-1][j-1] + c[i-1][j])%MOD
r = map(int,stdin.read().split())
n = next(r)
ans = 1
sum = 0
for _ in range(0,n):
x = next(r)
ans = (ans * c[sum+x-1][sum])%MOD
sum += x
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline void get_int(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
inline void get_long(long long int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
inline void print_int(int X) {
if (X < 0) {
putchar('-');
X = -X;
}
int Len = 0, Data[20];
while (X) {
Data[Len++] = X % 10;
X /= 10;
}
if (!Len) Data[Len++] = 0;
while (Len--) putchar(Data[Len] + 48);
putchar('\n');
}
inline void print_long(long long int X) {
if (X < 0) {
putchar('-');
X = -X;
}
int Len = 0, Data[20];
while (X) {
Data[Len++] = X % 10;
X /= 10;
}
if (!Len) Data[Len++] = 0;
while (Len--) putchar(Data[Len] + 48);
putchar('\n');
}
long long int modPow(long long int a, long long int x, long long int p) {
long long int res = 1;
while (x > 0) {
if (x & 1) {
res = (res * a) % p;
}
a = (a * a) % p;
x /= 2;
}
return res;
}
long long int arr[5005];
long long int pas[5005][5005];
void init() {
for (int i = 0; i < 2222; i++)
for (int j = 0; j < 2222; j++) pas[0][j] = pas[i][j] = 1;
for (int i = 2; i < 2222; i++)
for (int j = 1; j < i; j++) {
pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
pas[i][j] %= 1000000007;
}
}
int main() {
init();
long long int i, k;
long long int s = 0;
get_long(k);
for (i = 0; i <= k - 1; i++) {
get_long(arr[i]);
s += arr[i];
}
s -= 1;
long long int ans = 1;
for (i = k - 1; i >= 0; i--) {
ans *= pas[s][arr[i] - 1];
ans %= 1000000007;
s -= arr[i];
}
print_long(ans);
return 0;
}
| 9 | CPP |
ans,s=1,0
for _ in range(int(input())):
n=int(input())
s+=n
if s==n:continue
k=1
for i in range(1,n):
k=k*(s-i)//i
ans=(ans*k)%(10**9+7)
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, MAXN = 1002;
int C[MAXN][MAXN], A[MAXN];
int main() {
for (int i = 0; i < MAXN; i++)
for (int l = 0; l < MAXN; l++) {
if (!i || !l || i == l)
C[i][l] = 1;
else
C[i][l] = (C[i - 1][l] + C[i - 1][l - 1]) % MOD;
}
int n, sum = 0, tot;
long long ans = 1;
scanf("%d", &n), tot = n;
for (int i = 0; i < n; i++) scanf("%d", &A[i]), sum += A[i];
for (int i = n - 1; i >= 0; i--) {
ans = (ans * C[sum - 1][A[i] - 1]) % MOD;
sum -= A[i];
}
printf("%I64d\n", ans);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
long long c[1005][1005];
long long a[maxn];
void init() {
int i, j;
c[0][0] = 1;
for (i = 1; i <= 1000; i++) {
for (j = 0; j <= 1000; j++) {
if (j == 0)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j] + c[i][j - 1]) % MOD;
}
}
return;
}
int main() {
int i, j, n, m, t, z;
init();
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long sum = 1;
long long ans = 1;
for (i = 1; i <= n; i++) {
ans = ans * c[sum][a[i] - 1] % MOD;
sum = (sum + a[i]) % MOD;
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod_minus(long long a, long long b) {
return (a - b + 1000000007) % 1000000007;
}
int ara[1005];
long long dp[1005], fake_place[1005][1005];
long long func(int seat, int ball) {
if (!ball) return 1;
if (seat == 1) return 1;
if (fake_place[seat][ball] != -1) return fake_place[seat][ball];
int i;
long long ans = 0;
for (i = 0; i <= ball; i++) {
ans += func(seat - 1, i);
ans %= 1000000007;
}
return fake_place[seat][ball] = ans;
}
int main() {
int k, i, j;
for (i = 0; i < 1005; i++)
for (j = 0; j < 1005; j++) fake_place[i][j] = -1;
scanf("%d", &k);
for (i = 0; i < k; i++) scanf("%d", &ara[i]);
dp[0] = 1;
int total = ara[0];
for (i = 1; i < k; i++) {
dp[i] =
dp[i - 1] * (mod_minus(func(total + 1, ara[i]), func(total, ara[i])));
dp[i] %= 1000000007;
total += ara[i];
}
printf("%I64d\n", dp[k - 1]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 1e6 + 5;
const long long mod = 1e9 + 7;
long long fac[maxn], ifac[maxn];
long long modpow(long long, long long);
long long inv(long long);
long long nck(long long, long long);
void build();
void testlib();
int k, c[maxn], acc[maxn];
long long f[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
build();
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> c[i];
acc[i] = c[i] + acc[i - 1];
}
f[1] = 1;
for (int i = 2; i <= k; i++) {
f[i] = nck(acc[i] - 1, c[i] - 1) * f[i - 1];
while (f[i] < 0) f[i] += mod;
f[i] %= mod;
}
f[k] %= mod;
cout << f[k] << endl;
return 0;
}
long long modpow(long long x, long long y) {
x %= mod;
long long res = 1;
while (y > 0) {
if (y % 2 == 1) {
res *= x;
res %= mod;
}
x = x * x;
x %= mod;
y = y / 2;
}
return res;
}
long long inv(long long x) {
assert(x != 0);
return modpow(x, mod - 2);
}
void build() {
fac[0] = ifac[0] = 1;
for (int i = 1; i < maxn; i++) {
fac[i] = fac[i - 1] * i;
fac[i] %= mod;
ifac[i] = inv(fac[i]);
ifac[i] %= mod;
}
}
long long nck(long long n, long long k) {
assert(n >= 0 && k >= 0);
if (k > n) return 0;
long long res = (((fac[n] * ifac[k]) % mod) * ifac[n - k]) % mod;
assert(res > 0);
return res;
}
void testlib() {
assert(modpow(1, 1) == 1);
assert(modpow(4, 2) == 16);
assert(modpow(2, 5) == 32);
assert(fac[3] == 6);
assert(nck(4, 2) == 6);
assert(nck(10, 2) == 45);
}
| 9 | CPP |
#include <bits/stdc++.h>
const int mod = 1000000007;
int k, n, a[1010];
int C[1010][1010];
int main() {
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
n += a[i];
}
C[1][0] = C[1][1] = 1;
for (int i = 2; i <= 1000; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
int res = 1;
for (int i = k; i >= 2; i--) {
res = 1ll * res * C[n - 1][a[i] - 1] % mod;
n -= a[i];
}
printf("%d\n", res);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 1000;
const int mod = 1000000007;
int arr[MAXK + 10];
int acc[MAXK + 10];
int ncr[MAXK + 10][MAXK + 10];
int main() {
int k;
cin >> k;
for (int i = 1; i <= k; i++) cin >> arr[i];
for (int i = 1; i <= k; i++) acc[i] = acc[i - 1] + arr[i];
for (int i = 0; i <= MAXK; i++) ncr[i][0] = 1;
for (int i = 1; i <= MAXK; i++)
for (int j = 1; j <= MAXK; j++)
ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % mod;
long long res = 1;
for (int i = 2; i <= k; i++) res = (res * ncr[acc[i] - 1][arr[i] - 1]) % mod;
cout << res << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long exp(long long a, long long b, long long m) {
if (b == 0) return 1;
if (b == 1) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1) {
return mod(mod(k * k, m) * a, m);
} else
return mod(k * k, m);
}
long long c[1010];
long long f[1010];
long long fat[1010];
long long inv[1010];
long long comb(long long a, long long b) {
long long res = fat[a];
res = mod(res * inv[b], 1000000007);
res = mod(res * inv[a - b], 1000000007);
return res;
}
int32_t main() {
long long k;
cin >> k;
for (long long i = 1; i <= k; i++) cin >> c[i];
fat[1] = fat[0] = 1;
inv[0] = inv[1] = 1;
for (long long i = 1; i <= 1010; i++) {
fat[i] = mod(fat[i - 1] * i, 1000000007);
inv[i] = exp(fat[i], 1000000007 - 2, 1000000007);
}
f[1] = 1;
long long soma = c[1];
for (long long i = 2; i <= k; i++) {
soma = mod(soma + c[i], 1000000007);
f[i] = mod(f[i - 1] * comb(soma - 1, c[i] - 1), 1000000007);
}
cout << f[k] << "\n";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1009, mod = 1e9 + 7;
long long k, c[N], i, j, n, ncr[N][N], ans = 1;
int main() {
for (i = 0; i < N; i++) ncr[i][0] = 1;
for (i = 1; i < N; i++) {
for (j = 0; j <= i; j++)
ncr[i][j] = (ncr[i - 1][j - 1] + ncr[i - 1][j]) % mod;
}
scanf("%lld", &k);
for (i = 0; i < k; i++) {
scanf("%lld", &c[i]);
n += c[i];
ans = (ans * ncr[n - 1][c[i] - 1]) % mod;
}
printf("%lld", ans);
return 0;
}
| 9 | CPP |
from math import factorial
n,ans,s = int(input()),1,0
for i in range(n) :
a = int(input())
ans=(ans*factorial(s+a-1)//factorial(s)//factorial(a-1))%1000000007
s+=a
print(ans)
#copied...
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007L;
int k;
int c[1000];
long long leftSum[1000];
long long nn[1001];
long long coolPow(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long pp = coolPow(x, y / 2);
return (((pp * pp) % mod) * coolPow(x, y % 2)) % mod;
}
long long N(long long k) {
if (k == 1) return 1;
if (nn[k]) return nn[k];
long long sum = N(k - 1);
long long left = 1;
long long s = 1;
for (; left < c[k - 1]; left++) {
s = (s * (leftSum[k - 2] + left - 1)) % mod;
long long leftInv = coolPow(left, mod - 2);
s = (s * leftInv) % mod;
sum = (sum + N(k - 1) * s) % mod;
}
nn[k] = sum;
return sum;
}
int main(int argc, char *argv[]) {
cin >> k;
for (int i = 0; i < k; i++) cin >> c[i];
leftSum[0] = c[0];
for (int i = 1; i < k; i++) leftSum[i] = leftSum[i - 1] + c[i];
cout << N(k) << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long n;
long long a[1005];
long long fac[1000005];
long long ppow(long long a, long long b) {
long long c = 1;
while (b) {
if (b & 1) c = c * a % mod;
b >>= 1;
a = a * a % mod;
}
return c;
}
long long work(long long m, long long i) {
return ((fac[m] % mod) * (ppow((fac[i] * fac[m - i]) % mod, mod - 2) % mod)) %
mod;
}
int main() {
long long i, j, k;
fac[0] = 1;
for (i = 1; i < 1000005; i++) fac[i] = (fac[i - 1] * i) % mod;
long long ans = 1, sum = 0;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
sum += a[i];
}
for (i = n; i >= 1; i--) {
ans *= work(sum - 1, a[i] - 1);
ans %= mod;
sum -= a[i];
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e3 + 5;
long long dp[MAXN + 1][MAXN + 1];
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
long long i, N, j;
cin >> N;
long long K[N + 1];
for (i = 0; i < N; i++) cin >> K[i];
for (i = 0; i < MAXN + 1; i++)
for (j = 0; j < i + 1; j++)
if (j == 0 || i == j)
dp[i][j] = 1LL;
else
dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % 1000000007LL;
long long balls_so_far = 0LL;
long long ways = 1LL;
for (i = 0; i < N; i++) {
if (i) {
long long empty = balls_so_far;
long long prev_ways = ways;
for (j = 1; j < K[i]; j++) {
ways = (ways + prev_ways * dp[empty + j - 1][empty - 1]) % 1000000007LL;
}
}
balls_so_far += K[i];
}
cout << ways;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long binpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= MOD;
}
a *= a;
a %= MOD;
n >>= 1;
}
return res;
}
long long invert(long long num) { return binpow(num, MOD - 2); }
const long long MAXN = 3000;
long long fact[MAXN];
long long cnk(long long n, long long k) {
long long ret = fact[n];
ret *= invert(fact[k]);
ret %= MOD;
ret *= invert(fact[n - k]);
ret %= MOD;
return ret;
}
long long num_comb(long long n, long long r) {
if (r == 0) {
return 1;
}
return cnk(r + n - 1, r);
}
void solve(int k) {
vector<long long> c(k);
for (int i = 0; i < k; ++i) {
cin >> c[i];
}
vector<long long> dp(k + 1, 0);
dp[0] = 1;
long long total_c = 0;
for (long long i = 0; i < k; ++i) {
const long long f = num_comb(total_c + 1, c[i] - 1);
dp[i + 1] = dp[i] * f;
dp[i + 1] %= MOD;
total_c += c[i];
}
cout << dp[k] << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
fact[0] = 1;
for (long long i = 1; i < MAXN; ++i) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
int k;
while (cin >> k) {
solve(k);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);
const double EPS = 1E-6;
const int INF = 2 * (1e+9) + 1;
const int MAXN = 3 * 100000001;
const int MOD = (1e+9) + 7;
long long c[1003][1003];
const int MD = 1000000000 + 7;
int main() {
c[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] >= MD) {
c[i][j] -= MD;
}
}
}
long long ans = 1;
int n;
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sum += x - 1;
ans = (ans * c[sum][x - 1]) % MD;
sum++;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int com[1005][1005];
void cal() {
int i, j;
com[0][0] = 1;
for (i = 1; i < 1005; i++) {
com[i][0] = 1;
for (j = 1; j <= i; j++)
com[i][j] = (com[i - 1][j] + com[i - 1][j - 1]) % 1000000007;
}
}
int main() {
long long int i, k;
cal();
long long int c[1005];
cin >> k;
long long int n = 0, ans = 1;
for (i = 0; i < k; i++) {
cin >> c[i];
ans = (ans * com[n + c[i] - 1][c[i] - 1]) % 1000000007;
n += c[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, l, r;
double a, b, c, d, q;
vector<int> V;
vector<vector<int> > D;
string s, k, z;
long long res = 0;
double eps = 0.000000001;
const int INF = 1000000007;
const int MAXNUM = 1005;
int main() {
long long arr[MAXNUM][MAXNUM] = {0};
arr[0][0] = 1;
for (int i = 1; i < MAXNUM; i++) {
arr[i][0] = 1;
for (int j = 1; j <= i; j++) {
arr[i][j] = (arr[i - 1][j] + arr[i - 1][j - 1]) % INF;
}
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
V.push_back(m);
}
m = 0;
res = 1;
for (int i = 0; i < n; i++) {
res = (res * arr[m + V[i] - 1][V[i] - 1]) % INF;
m += V[i];
}
cout << res % INF << endl;
return 0;
}
| 9 | CPP |
mod = 10 ** 9 + 7
import math
def f(n): return math.factorial(n)
k = int(input())
c = [int(input()) for i in range(k)]
s, cnt = 0, 1
for i in c:
cnt *= f(s + i - 1) // f(i - 1) // f(s)
cnt %= mod
s += i
print(cnt) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000007;
long long quick_mod(long long a, long long b) {
long long ans = 1;
a %= p;
while (b) {
if (b & 1) {
ans = ans * a % p;
b--;
}
b >>= 1;
a = a * a % p;
}
return ans;
}
long long C(long long n, long long m) {
if (m > n) return 0;
long long ans = 1;
for (int i = 1; i <= m; i++) {
long long a = (n + i - m) % p;
long long b = i % p;
ans = ans * (a * quick_mod(b, p - 2) % p) % p;
}
return ans;
}
long long Lucas(long long n, long long m) {
if (m == 0) return 1;
return C(n % p, m % p) * Lucas(n / p, m / p) % p;
}
int main() {
long long ans = 1;
int n, cnt, x;
scanf("%d%d", &n, &cnt);
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
long long t = C(cnt + x - 1, x - 1) % p;
ans = ans * t % p;
cnt += x;
}
printf("%d", ans);
return 0;
}
| 9 | CPP |
import sys
import inspect
import re
import math
from pprint import pprint as pp
mod = 1000000007
MAX = 10**15
def deb(p):
for line in inspect.getframeinfo(inspect.currentframe().f_back)[3]:
m = re.search(r'\bdeb\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)', line)
print('%s %d' % (m.group(1), p))
def vector(size, val=0):
vec = [val for i in range(size)]
return vec
def matrix(rowNum, colNum, val=0):
mat = []
for i in range(rowNum):
collumn = [val for j in range(colNum)]
mat.append(collumn)
return mat
def pascle(lim):
p = matrix(lim, lim)
for i in range(lim):
p[i][i] = p[i][0] = 1
for i in range(1, lim):
for j in range(1, lim):
p[i][j] = (p[i - 1][j - 1] + p[i - 1][j]) % mod
return p
def main():
p = pascle(1005)
n = int(input())
a = [0] + [int(input()) for i in range(n)]
s = 0
ans = 1
for i in range(1, n + 1):
ans = (ans * p[s + a[i] - 1][a[i] - 1]) % mod
s += a[i]
print(ans)
if __name__ == '__main__':
main()
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if ((a == 0) || (b == 0)) return a + b;
return gcd(b, a % b);
}
long long pow_mod(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long arr[1010], fact[1010], ifact[1010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long N, i, j, T, res = 1, total, tt, opop;
string st;
fact[0] = 1;
for (i = 1; i <= 1002; i++) {
fact[i] = ((fact[i - 1] * i) % 1000000007);
}
ifact[1002] = pow_mod(fact[1002], 1000000007 - 2);
for (i = 1001; i >= 0; i--) {
ifact[i] = ((ifact[i + 1] * (i + 1)) % 1000000007);
}
cin >> N;
for (i = 0; i <= N - 1; i++) {
cin >> arr[i];
}
total = arr[0];
tt = arr[0];
for (i = 1; i <= N - 1; i++) {
tt += arr[i];
total += arr[i];
total--;
opop = ((fact[total] *
((ifact[arr[i] - 1] * ifact[total - arr[i] + 1]) % 1000000007)) %
1000000007);
res = ((res * opop) % 1000000007);
total = tt;
}
cout << res;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, sol = 1, acc, t;
int C[1003][1003];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie();
C[0][0] = 1;
for (int i = 1; i <= 1000; i++)
for (int j = 0; j <= i; j++)
C[i][j] =
(j == 0 ? 1LL : 1LL * C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
cin >> n;
while (n-- && cin >> t) {
acc += t;
sol = 1LL * sol * C[acc - 1][t - 1] % 1000000007;
}
cout << sol % 1000000007;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int p[2010][2010], k;
int input[1010];
struct H {
int value;
H(int x, int y) { value = p[x + y - 1][y]; }
};
inline void createPascal() {
for (int i = 0; i <= 2000; i++) p[i][0] = 1, p[i][i] = 1;
for (int i = 2; i <= 2000; i++) {
for (int j = 1; j < i; j++) {
p[i][j] = (p[i - 1][j - 1] % mod + p[i - 1][j] % mod) % mod;
}
}
}
int main() {
createPascal();
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", &input[i]);
int present = input[0];
long long ans = 1;
for (int i = 1; i < k; i++) {
if (input[i] == 1) {
present += 1;
continue;
} else {
ans = (H(present + 1, input[i] - 1).value * ans) % mod;
}
present += input[i];
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[1001][1001];
int M = 1e9 + 7;
void init() {
for (int i = 1; i < 1001; i++) {
dp[1][i] = 1;
dp[i][1] = i;
}
for (int i = 2; i < 1001; i++)
for (int j = 2; j < 1001; j++) dp[i][j] = (dp[i][j - 1] + dp[i - 1][j]) % M;
}
int main() {
init();
vector<int> c(1001);
int k;
cin >> k;
for (int i = 0; i < k; i++) cin >> c[i];
int x = c[0];
unsigned long long res = 1;
for (int i = 1; i < k; i++) {
if (c[i] != 1) res = (res * dp[x + 1][c[i] - 1]) % M;
x += (c[i]);
}
cout << res;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long c[1010][1010], a[1010];
void init() {
for (int i = 0; i <= 1000; i++) c[i][0] = 1;
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= 1000; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
}
}
int main() {
init();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
a[i]--;
}
long long ans = 1;
long long anss = 0;
for (int i = 1; i <= n; i++) {
anss += a[i];
ans = (ans * c[anss][a[i]]) % 1000000007;
anss++;
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
k = int(input())
fact = [1] * 1000000
for j in range(2, 1001):
fact[j] = fact[j - 1] * j
cnt = 1
l = 0
for i in range(k):
cur = int(input())
cnt *= (fact[l + cur - 1] // fact[cur - 1] // fact[l]) % 1000000007
l += cur
print(int(cnt) % 1000000007)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long fac[5005], invFac[5005];
long long inverseMod(long long x) {
long long t = 0, newt = 1, r = MOD, newr = x;
while (newr) {
long long quot = r / newr;
long long tmp = newt;
newt = t - quot * newt;
t = tmp;
tmp = newr;
newr = r - quot * newr;
r = tmp;
}
if (t < 0) t += MOD;
return t;
}
long long ncr(long long n, long long c) {
return ((fac[n] * invFac[c]) % MOD * invFac[n - c]) % MOD;
}
int main() {
for (int i = 0; i < 5005; i++) {
if (!i) {
fac[i] = invFac[i] = 1;
} else {
fac[i] = (fac[i - 1] * i) % MOD;
invFac[i] = inverseMod(fac[i]);
}
}
int N;
cin >> N;
long long prod = 1;
long long cursum = 0;
for (int i = 0; i < N; i++) {
long long x;
cin >> x;
if (i) {
prod = (prod * ncr(cursum + x - 1, cursum)) % MOD;
}
cursum += x;
}
cout << prod << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace stuff {
const int MOD = int(1e9) + 7;
long long dp[1111][1111];
long long comb[1111][1111];
void solve(int test_num) {
int K;
cin >> K;
vector<int> col(K + 1, 0);
for (int i = 1; i <= K; i++) cin >> col[i];
const int N = accumulate(col.begin(), col.end(), 0);
memset(comb, 0, sizeof(comb));
comb[0][0] = 1;
for (int i = 1; i <= 1000; i++)
for (int j = 0; j <= 1000; j++)
if (j == 0)
comb[i][j] = 1;
else
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % MOD;
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
int sum = 0;
for (int c = 1; c <= K; c++) {
sum += col[c];
long long pr = 0;
for (int i = 0; i < sum; i++) pr = (pr + dp[c - 1][i]) % MOD;
for (int i = sum; i <= N; i++) {
dp[c][i] =
(dp[c][i] + pr * comb[i - 1 - (sum - col[c])][col[c] - 1]) % MOD;
pr = (pr + dp[c - 1][i]) % MOD;
}
}
cout << dp[K][N] << endl;
}
void solve() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
for (int t = 1; t <= T; t++) solve(t);
}
} // namespace stuff
int main() {
stuff::solve();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
long long m[1001][1001];
long long md = 1000000007;
long long ans = 1;
int cnt = 0;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
m[0][0] = 1;
for (int i = 1; i <= 1000; ++i) {
m[i][0] = 1;
for (int j = 1; j <= 1000; ++j) {
m[i][j] = (m[i - 1][j] + m[i - 1][j - 1]) % md;
}
}
for (int i = 1; i <= n; ++i) {
ans = (ans * (m[a[i] + cnt - 1][a[i] - 1])) % md;
cnt += a[i];
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mn = 1e3 + 10;
const int mod = 1e9 + 7;
long long par[mn];
long long ent[1001][1001];
int main() {
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || i == j) {
ent[i][j] = 1;
} else {
ent[i][j] = (ent[i - 1][j - 1] + ent[i - 1][j]) % mod;
}
}
}
int k;
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> par[i];
par[i] += par[i - 1];
}
long long ans = 1;
for (int i = 1; i <= k; i++) {
ans = (ent[par[i] - 1][par[i - 1]] * ans) % mod;
}
cout << ans;
return 0;
}
| 9 | CPP |
def f(a,b):
p = 1
while a!=b:
p = (p*a)%z
a -= 1
return p
def modinv(a,m):
p = 1
while m!=0:
if m%2:
p = (p*a)%z
m -= 1
else:
a = (a*a)%z
m //= 2
return p
k = int(input())
s = 0
ans = 1
z = 1000000007
for i in range(k):
c = int(input())
if i>0:
ans = (ans*f(s+c-1,c-1)*modinv(f(s,0),z-2))%z
s += c
print(ans) | 9 | PYTHON3 |
mod = 1000000007
def pow1(a,b):
ans = 1
c=a
while(b):
#print('estoy en el while')
if(b & 1):
ans=ans*c%mod
b>>=1
c=c*c%mod
return ans
def factorial(a,b):
factor =fact[a]*pow1(fact[b]*fact[a-b]%mod,mod-2)%mod
return factor
fact = []
for i in range(1000010):
fact.append(0)
a = []
for i in range(1010):
a.append(0)
#================MAIN===============
fact[0] = 1
for i in range(1,1000000):
fact[i]=fact[i-1]*i%mod
n = int(input())
#print(n)
sum = 0
for i in range(0,n):
a[i] = int(input())
sum+=a[i]
#print (a)
#print(sum)
ans = 1
i = n-1
while(i>-1):
ans=ans*factorial(sum-1,a[i]-1)%mod
#print(ans)
sum-=a[i]
i-=1
#print(f"suma:{sum}")
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[1005];
long long D[1005];
long long C[1005][1005];
long long n;
long long sum[1005];
const long long MOD = 1e9 + 7;
void init() {
C[0][0] = 1;
for (long long i = 1; i <= 1000; i++) {
C[i][0] = C[i][i] = 1;
for (long long j = 1; j <= i - 1; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
init();
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sum[1] = a[1];
for (long long i = 2; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
D[1] = 1;
for (long long i = 2; i <= n; i++) {
D[i] = (D[i - 1] * C[sum[i - 1] + a[i] - 1][a[i] - 1]) % MOD;
}
cout << D[n];
return 0;
}
| 9 | CPP |
if __name__ == '__main__':
data = [int(input()) for i in range(int(input()))]
total = 1
prev = data[0]
for i, x in enumerate(data[1:]):
prev += 1
f = 1
c = 1
for j in range(x - 1):
total *= prev
prev += 1
f *= c
c += 1
total //= f
if total > 1000000007:
total %= 1000000007
print(total) | 9 | PYTHON3 |
import math
def coloredBalls():
k = int(input())
if(k==1 or k==1000):
print("1")
return
n = 0
resultado = 1
for i in range(0,k):
balls = int(input())
resultado = resultado * math.factorial(n+balls-1) // math.factorial(n) // math.factorial(balls - 1) % 1000000007
n += balls
print(resultado)
coloredBalls() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int k;
int c[1005];
long long fact[1005];
long long th[1005][1005];
int s[1005];
long long res;
void init() {
fact[0] = 1;
for (int i = 1; i <= 1000; ++i) fact[i] = (fact[i - 1] * i) % 1000000007;
th[0][0] = 1;
for (int i = 1; i <= 1000; ++i) {
th[i][0] = 1;
for (int j = 1; j <= i; ++j) {
th[i][j] = (th[i - 1][j - 1] + th[i - 1][j]) % 1000000007;
}
}
}
int main() {
init();
scanf("%d", &k);
for (int i = 0; i < k; ++i) {
scanf("%d", &c[i]);
if (i == 0)
s[i] = c[i];
else
s[i] = s[i - 1] + c[i];
}
res = 1;
for (int i = 1; i < k; ++i) {
res = (res * th[s[i - 1] + c[i] - 1][c[i] - 1]) % 1000000007;
}
printf("%lld\n", res);
}
| 9 | CPP |
"""
Author - Satwik Tiwari .
4th Oct , 2020 - Sunday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil
from copy import deepcopy
from collections import deque
# from collections import Counter as counter # Counter(list) return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
mod = 10**9+7
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for pp in range(t):
solve(pp)
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
def nCr_mod(n,r,max_n=2 * 10**5, mod=10**9 + 7):
max_n = min(max_n, mod - 1)
fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)
fact[0] = 1
for i in range(max_n):
fact[i + 1] = fact[i] * (i + 1) % mod
inv_fact[-1] = pow(fact[-1], mod - 2, mod)
for i in reversed(range(max_n)):
inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod
def do_nCr_mod(n, r):
res = 1
while n or r:
a, b = n % mod, r % mod
if a < b:
return 0
res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod
n //= mod
r //= mod
return res
return do_nCr_mod(n,r)
"""
print nCr(4,3)
"""
def solve(case):
n = int(inp())
ans = 1
total = 0
for i in range(n):
x = int(inp())
total+= x
ans*=ncr(total-1,x-1)%mod
print(ans%mod)
testcase(1)
# testcase(int(inp()))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int countFact(long long int n, long long int p) {
long long int k = 0;
while (n >= p) {
k += n / p;
n /= p;
}
return k;
}
long long pow(long long int a, long long int b, long long int MOD) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD) x %= MOD;
}
y = (y * y);
if (y > MOD) y %= MOD;
b /= 2;
}
return x;
}
long long InverseEuler(long long int n, long long int MOD) {
return pow(n, MOD - 2, MOD);
}
long long factMOD(long long int n, long long int MOD) {
long long res = 1;
while (n > 0) {
for (long long int i = 2, m = n % MOD; i <= m; i++) res = (res * i) % MOD;
if ((n /= MOD) % 2 > 0) res = MOD - res;
}
return res;
}
long long C(long long int n, long long int r, long long int MOD) {
if (countFact(n, MOD) > countFact(r, MOD) + countFact(n - r, MOD)) return 0;
return (factMOD(n, MOD) * ((InverseEuler(factMOD(r, MOD), MOD) *
InverseEuler(factMOD(n - r, MOD), MOD)) %
MOD)) %
MOD;
}
int main() {
long long int n;
cin >> n;
long long int a[n], i, j, sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sum -= 1;
long long int ans = 1;
for (i = n - 1; i >= 0; i--) {
ans = ans * C(sum, a[i] - 1, 1000000007) % 1000000007;
sum -= a[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2100;
long long c[MAX][MAX];
const int mod = (int)1e9 + 7;
inline void load(int n) {
c[0][0] = 1;
for (int i = 1; i < n; i++) {
c[i][0] = 1;
c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
int main() {
ios::sync_with_stdio(false);
load(MAX);
long long ans = 1;
int n, k, C = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
ans = (ans * c[k + C - 1][C]) % mod;
C += k;
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:2000000")
long long k, a[1024][1024], dp[1024], b[1024];
void f() {
for (long long i = 0; i < (long long)1024; i++) a[i][0] = a[i][i] = 1;
for (long long i = (long long)2; i < (long long)1024; i++)
for (long long j = (long long)1; j < (long long)i; j++)
a[i][j] = ((a[i - 1][j - 1] + a[i - 1][j]) % (1000 * 1000 * 1000 + 7));
}
int main() {
cin >> k;
for (long long i = (long long)1; i < (long long)k + 1; i++) cin >> b[i];
f();
memset(dp, 0, sizeof dp);
dp[1] = 1;
long long t = b[1];
for (long long i = (long long)2; i < (long long)k + 1; i++) {
dp[i] = (dp[i - 1] * a[t + b[i] - 1][t]) % (1000 * 1000 * 1000 + 7);
t += b[i];
}
cout << dp[k] % (1000 * 1000 * 1000 + 7) << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const char NL = '\n';
void read(vector<long long> &a);
class Combinatorics {
public:
vector<vector<long long>> ncr(long long n, long long r, long long p) {
vector<vector<long long>> dp(n + 1, vector<long long>(r + 1, 0));
dp[0][0] = 1;
for (long long i = 1; i <= n; i++) {
dp[i][0] = 1;
for (long long j = 1; j <= i; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % p;
}
return dp;
}
vector<long long> derangements(long long n) {
vector<long long> der(n + 1, 0);
der[1] = 0;
der[2] = 1;
for (long long i = 3; i <= n; ++i)
der[i] = (i - 1) * (der[i - 1] + der[i - 2]);
return der;
}
};
inline void solve() {
const long long MAX = 1010;
const long long mod = 1e9 + 7;
long long n;
cin >> n;
vector<long long> col(n);
read(col);
class Combinatorics st;
vector<vector<long long>> ncr = st.ncr(MAX, MAX, mod);
long long res = 1;
long long total = 0;
for (long long i = 0; i < n; i++) {
res = (res * ncr[total + col[i] - 1][col[i] - 1]) % mod;
total += col[i];
}
cout << res << NL;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
fflush(stdin);
fflush(stdout);
return 0;
}
void read(vector<long long> &a) {
for (auto &it : a) cin >> it;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long pow_mod(long long a, long long n, long long p) {
long long ans = 1, t = a;
while (n) {
if (n & 1) {
ans = ans * t % p;
}
t = t * t % p;
n >>= 1;
}
return ans;
}
long long cal(long long n, long long m, long long p) {
if (m > n - m) m = n - m;
long long ans = 1;
for (int i = 1; i <= m; i++) {
ans = ans * (n - i + 1) % p;
int a = pow_mod(i, p - 2, p);
ans = ans * a % p;
}
return ans;
}
long long com_mod(long long n, long long m, long long p) {
if (n < m) return 0;
return cal(n, m, p);
}
long long lucas(long long n, long long m, long long p) {
long long r = 1;
while (n && m && r) {
r = r * com_mod(n % p, m % p, p) % p;
n /= p;
m /= p;
}
return r;
}
int main() {
int k;
long long a[1099];
scanf("%d", &k);
for (int i = 0; i < k; i++) {
scanf("%I64d", &a[i]);
}
long long sum = a[0];
long long ansl = 1;
for (int i = 1; i < k; i++) {
if (a[i] == 1) {
sum++;
continue;
}
sum = sum + a[i] - 1;
ansl *= lucas(sum, a[i] - 1, 1000000007);
ansl %= 1000000007;
sum++;
}
printf("%I64d\n", ansl);
}
| 9 | CPP |
n = int(input())
ar = [int(input()) for _ in range(n)]
for i in range(1,n):
ar[i] += ar[i-1]
M = 1000000007
f = [1]
for i in range(1,1000000):
f.append(f[-1]*i%M)
def C(n,k):
return (f[n]*pow(f[k],M-2,M)%M)*pow(f[n-k],M-2,M)%M
dp = [1]*(n+4)
for i in range(1,n):
dp[i] = C(ar[i]-1,ar[i-1])*dp[i-1]%M
print(dp[n-1])
# C:\Users\Usuario\HOME2\Programacion\ACM | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long ncr[1001][1001] = {0};
long long c[1001], sum[1001];
long long precompute(long long n, long long r) {
if (ncr[n][r]) return ncr[n][r];
if (n == r) return ncr[n][r] = ncr[n][n - r] = 1;
if (r == 0) return ncr[n][r] = ncr[n][n - r] = 1;
if (r == 1) return ncr[n][r] = ncr[n][n - r] = (n % 1000000007);
return ncr[n][r] = ncr[n][n - r] = (precompute(n - 1, r) % 1000000007 +
precompute(n - 1, r - 1) % 1000000007) %
1000000007;
}
int main() {
long long k, i, ans = 1;
cin >> k;
for (i = 0; i < k; i++) {
cin >> c[i];
}
sum[0] = c[0];
for (i = 1; i < k; i++) {
sum[i] = sum[i - 1] + c[i];
}
for (i = 0; i < k; i++) {
ans = (ans * precompute(sum[i] - 1, c[i] - 1)) % 1000000007;
}
cout << ans % 1000000007 << endl;
return 0;
}
| 9 | CPP |
k=int(input())
sol=1
prije=0
for i in range (k):
color=int(input())
br1=1
for y in range (prije+1, prije+color):
br1*=y
br2=1
for y in range (color-1, 1, -1):
br2*=y
#print(sol, color, br1, br2, prije)
prije+=color
sol*=(br1//br2)
sol%=(10**9+7)
print(sol)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int NCR[1005][1005];
int mod_mul(long long a, long long b) { return (a * b) % 1000000007; }
int mod_plus(int a, int b) { return (a + b) % 1000000007; }
int nCr(int n, int r) {
if (n == r || r == 0) return 1;
int &ret = NCR[n][r];
if (ret != -1) return ret;
return ret = mod_plus(nCr(n - 1, r), nCr(n - 1, r - 1));
}
int main() {
memset(NCR, -1, sizeof(NCR));
int i, n, x, tot = 0, ans = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &x);
tot += x;
ans = mod_mul(ans, nCr(tot - 1, x - 1));
}
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
def comb(x, y):
num = 1
for i in range(x-y+1, x+1):
num *= i
den = 1
for i in range(1, y+1):
den *= i
return num//den
if __name__ == "__main__":
n_colors = int(input())
balls = []
for _ in range(n_colors):
balls.append(int(input()))
total = 1
for i in range(len(balls)-1, 0, -1):
total *= comb(sum(balls[:i+1])-1, balls[i]-1)%1000000007
total %= 1000000007
print(total)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int k;
int a[2000];
long long f[2000];
long long pre[2000];
long long c[1010][1010];
int main() {
ios::sync_with_stdio(false);
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> a[i];
pre[i] += pre[i - 1] + a[i];
}
for (int i = 0; i <= 1000; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
f[1] = 1;
for (int i = 2; i <= k; i++) {
f[i] = f[i - 1] * c[pre[i] - 1][a[i] - 1] % mod;
}
cout << f[k] << endl;
return 0;
}
| 9 | CPP |
#!/usr/bin/python3
import sys
from functools import lru_cache
MOD = 1000000007
cnk = [[1 for i in range(1001)] for j in range(1001)]
for i in range(1, 1001):
for j in range(1, i):
cnk[i][j] = cnk[i - 1][j - 1] + cnk[i - 1][j]
k = int(input())
cs = [int(input()) for i in range(k)]
ans = 1
sm = 0
for c in cs:
sm += c
ans = (ans * cnk[sm - 1][c - 1]) % MOD
print(ans)
| 9 | PYTHON3 |
from math import factorial
mod = 10 ** 9 + 7
k = int(input())
ans = 1
n = 0
for i in range(k):
a = int(input())
ans = ((ans * (factorial(n + a - 1))) // (factorial(a - 1) * factorial(n))) % mod
n += a
print(ans) | 9 | PYTHON3 |
fact = [1]
mod = 1000000007
for j in range(1, 1001):
fact.append(fact[-1] * j)
a = int(input())
s = []
for i in range(a):
s.append(int(input()))
summ = 1
l = s[0]
for i in range(1, a):
summ *= ((fact[l + s[i] - 1] // fact[l] // fact[s[i] - 1]) % mod)
l += s[i]
print(summ % mod) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int def = 1000000007;
long long int c[1005][1005];
long long int C_(long long int a, long long int b) {
if (a < 0 || b < 0 || a < b) return 0;
if (a == 0) {
if (b == 0)
return 1;
else
return 0;
}
return c[a][b] ? c[a][b] : c[a][b] = (C_(a - 1, b) + C_(a - 1, b - 1)) % def;
}
int N;
int main() {
long long int cur, total = 0, sum = 1;
cin >> N;
while (N--) {
cin >> cur;
long long int t = C_(total + cur - 1, cur - 1) % def;
sum = sum * t % def;
total += cur;
}
cout << sum << endl;
return 0;
}
| 9 | CPP |
from math import factorial
k=int(input())
ans,s=1,0
for i in range(k):
ci=int(input())
ans=(ans*factorial(s+ci-1)//(factorial(ci-1)*factorial(s)))%1000000007
s+=ci
print(ans) | 9 | PYTHON3 |
from math import factorial
k = int(input())
ans = 1
mod = 10 ** 9 + 7
n = 0
for i in range(k):
x = int(input())
ans = (ans * (factorial(n + x - 1)) // (factorial(x - 1) * factorial(n))) % mod
n += x
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int n = 1000;
const long mod = 1000000007;
int main() {
int k, newk, newn;
int* balls;
long** cnk;
long long rez;
cin >> k;
balls = new int[k];
for (int i = 0; i < k; i++) cin >> balls[i];
cnk = new long*[n + 1];
for (int i = 0; i < n + 1; i++) cnk[i] = new long[n + 1];
for (int i = 0; i < n + 1; i++) cnk[0][i] = 0;
for (int i = 0; i < n + 1; i++) cnk[i][0] = 1;
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < n + 1; j++)
cnk[i][j] = (cnk[i - 1][j] + cnk[i - 1][j - 1]) % mod;
newn = balls[0];
newk = 0;
rez = 1;
for (int i = 1; i < k; i++) {
newk = balls[i] - 1;
newn += balls[i];
rez = (rez * cnk[newn - 1][newk]) % mod;
}
cout << rez;
for (int i = 0; i < n + 1; i++) delete[] cnk[i];
delete[] cnk;
delete[] balls;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
double Fib(double x, double z);
string BinDec(unsigned long long x);
string StringInt(long long x);
unsigned long long StringInt(string x);
unsigned long long BinDec(string x);
unsigned long long POWMOD(unsigned long long x, unsigned long long y,
unsigned long long mod);
unsigned long long POWE(long long, long long);
long long fast_pow(long long a, long long b, long long mod) {
if (b == 0) return 1ll;
long long ans = 1;
if (b % 2) return ans = (fast_pow(a, b - 1, mod) * a) % mod;
ans = (fast_pow(a, b / 2, mod) % mod);
return ((ans * ans) % mod);
}
long long arr[1020] = {};
long long nCp(long long a, long long b) {
long long ans2 = 1, mod = 1000000007;
if (b > a)
return 0;
else if (b == a)
return 1;
else {
ans2 = arr[a];
ans2 *= fast_pow(arr[a - b], mod - 2, mod);
ans2 %= mod;
ans2 *= fast_pow(arr[b], mod - 2, mod);
ans2 %= mod;
return ans2;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, i;
arr[0] = 1;
long long mod = 1000000007, ans = 1;
for (i = 1; i < 1003; i++) {
ans *= i;
ans %= mod;
arr[i] = ans;
}
long long s = 0, p = 1, a;
cin >> n;
cin >> a;
s = a;
for (i = 1; i < n; i++) {
cin >> a;
p *= nCp(s + a - 1, a - 1);
p %= mod;
s += a;
}
cout << p;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long comb[1005][1005];
int main() {
ios::sync_with_stdio(false);
for (int i = 0; i < 1004; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || i == j)
comb[i][j] = 1;
else
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % 1000000007;
}
}
long long k, temp = 0, tempp = 0, ans = 1;
cin >> k;
for (int i = 0; i < k; i++) {
long long a;
cin >> a;
ans = (ans * comb[temp + a - 1][a - 1]) % 1000000007;
temp += a;
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long MOD = 1000000007;
int n;
long long c[1010], num[1010];
long long tab[1010][1010];
long long power(long long a, long long b) {
long long ans = 1;
a %= MOD;
while (b) {
if (b & 1) {
ans = ans * a % MOD;
b--;
}
b >>= 1;
a = a * a % MOD;
}
return ans;
}
void init() {
long long tmp = 1;
for (long long i = 1; i <= (long long)1000; i++) {
tmp = tmp * i % MOD;
num[i] = power(tmp, MOD - 2);
}
tab[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
tab[i][0] = tab[i][i] = 1;
for (int j = 1; j < i; j++) {
tab[i][j] = (tab[i - 1][j] + tab[i - 1][j - 1]) % MOD;
}
}
}
int main() {
init();
scanf("%d", &n);
long long ans = 1, tmp = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &c[i]);
c[i] -= 1;
}
for (int i = 1; i <= n; i++) {
tmp += c[i] + 1;
ans = (ans * tab[tmp - 1][c[i]]) % MOD;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
import sys
def choose(n, k):
if 0 <= k <= n:
ntok = 1
ktok = 1
for t in range(1, min(k, n - k) + 1):
ntok *= n
ktok *= t
n -= 1
return ntok // ktok
else:
return 0
R = 1000000007
def main():
k = int(sys.stdin.readline())
data = list(map(int,sys.stdin.readlines()))
s = sum(data)
ans=1
free = s
for i in range(k-1,0,-1):
t = choose(free-1, data[i]-1)
ans= (((t%R)*ans)%R)
free-=data[i]
print(ans)
main()
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long C[1003][1003];
long long mod = 1000000000 + 7;
int main() {
time_t t1, t2;
t1 = clock();
C[0][0] = 1;
for (int i = 1; i < 1003; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
long long k;
cin >> k;
long long c[k];
for (long long i = (0); i < (k); i++) cin >> c[i];
long long ans[k + 1];
ans[1] = 1;
long long sm = c[0];
for (long long i = (2); i < (k + 1); i++) {
sm += c[i - 1];
ans[i] = (ans[i - 1] * C[sm - 1][c[i - 1] - 1]) % mod;
}
cout << ans[k] % mod;
t2 = clock();
cerr << "time taken: " << t2 - t1;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
inline void read(int &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
const int maxn = 1005;
const double PI = 3.141592653589793238462643383279;
long long a[maxn], e = 1000000007;
long long power(long long a, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) {
ans *= a;
ans %= e;
}
a *= a;
a %= e;
n /= 2;
}
return ans;
}
long long fac[1000010];
int main() {
int n;
cin >> n;
fac[0] = 1;
for (int i = 1; i < 1000005; i++) fac[i] = (fac[i - 1] * i) % e;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
long long ans = 1;
long long tot = a[1];
for (int i = 2; i <= n; i++) {
ans = ans * (fac[tot + a[i] - 1] * power(fac[tot], e - 2) % e) % e *
power(fac[a[i] - 1], e - 2);
ans %= e;
tot += a[i];
}
printf("%I64d\n", ans);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
int k, c[1001][1001], a[100001];
long long ans = 1;
void init() {
c[0][0] = c[1][0] = c[1][1] = 1;
for (int i = 2; i <= 1000; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
c[i][j] %= Mod;
}
}
}
int main() {
init();
int sum = 0;
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = k; i >= 1; i--) {
ans *= (long long)c[sum - 1][a[i] - 1];
ans %= Mod;
sum -= a[i];
}
printf("%lld", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, l, k;
const int mx = 1e5 + 9;
const long long mod = 1e9 + 7;
long long w[mx], x[mx], d[mx];
long long sum;
long long ncr[2005][2005];
long long a[mx];
int main() {
for (int i = 0; i < 2005; i++) {
ncr[i][0] = 1;
for (int x = 1; x <= i; x++)
ncr[i][x] = (ncr[i - 1][x] + ncr[i - 1][x - 1]) % mod;
}
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> a[i];
sum += a[i];
}
long long ans = 1;
for (int i = k; i >= 1; i--) {
ans = (ans * ncr[sum - 1][a[i] - 1]) % mod;
sum -= a[i];
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1ll * 1000 * 1000 * 1000ll + 7;
long long dp[1000 + 10][1000 + 10];
int mark[1000 + 10][1000 + 10];
void dpis(int n, int k) {
mark[n][k] = 1;
if (k > n) {
dp[n][k] = 0;
return;
}
if (k == n) {
dp[n][k] = 1;
return;
}
if (k == 1) {
dp[n][k] = n;
return;
}
if (k == 0) {
dp[n][k] = 1;
return;
}
if (n == 1) {
dp[n][k] = 0;
return;
}
if (n == 0) {
dp[n][k] == 0;
return;
}
if (mark[n - 1][k] == 0) dpis(n - 1, k);
if (mark[n - 1][k - 1] == 0) dpis(n - 1, k - 1);
dp[n][k] = (dp[n - 1][k - 1] + dp[n - 1][k]) % mod;
}
int main() {
for (int i = 0; i <= 1002; i++)
for (int j = 0; j <= 1002; j++)
if (mark[i][j] == 0) dpis(i, j);
int n;
cin >> n;
long long ted = 0, ans = 0;
int a;
cin >> a;
ted = a;
ans = 1;
for (int i = 0; i < n - 1; i++) {
cin >> a;
ans = (ans * (dp[ted + a - 1][a - 1])) % mod;
ted += a;
}
cout << ans;
}
| 9 | CPP |
MOD = 10**9 + 7
N = 1010
f = [1 for _ in range(N)]
for i in range(1, N): f[i] = (f[i - 1] * i) % MOD
inv = [pow(f[i], MOD - 2, MOD) for i in range(N)]
def C(n, k):
if n == 0 or k > n: return 0
return (f[n] * ((inv[k] * inv[n - k]) % MOD)) % MOD
n = int(input())
tot = int(input())
ret = 1
for i in range(1, n):
x = int(input())
tmp = C(tot + x - 1, x - 1)
ret = (ret * tmp) % MOD
tot += x
print(ret)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 10;
int n;
int b[maxn];
long long int dp[maxn];
int pes;
long long int fac[maxn];
long long int inv[maxn];
long long int pw(long long int a, long long int c) {
long long int res = 1;
while (c) {
if (c % 2) {
res = (1ll * res * a) % mod;
}
a = (1ll * a * a) % mod;
c /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
fac[0] = 1;
inv[0] = 1;
for (int i = 1; i <= (int)1e6 + 5; i++) {
fac[i] = (1ll * fac[i - 1] * i) % mod;
inv[i] = pw(fac[i], mod - 2);
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
if (i == 0) {
dp[i] = 1;
} else {
int fes = 0;
for (int j = 0; j < i; j++) {
fes += b[j];
}
dp[i] = (1ll * ((1ll * fac[fes + b[i] - 1] * inv[b[i] - 1]) % mod) *
inv[fes]) %
mod;
dp[i] *= dp[i - 1];
dp[i] %= mod;
}
}
cout << dp[n - 1];
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1100;
const int MOD = 1e9 + 7;
long long power(long long a, long long b) {
long long ret = 1;
for (; b > 0; b >>= 1) {
if (b & 1) ret = (ret * a) % MOD;
a = (a * a) % MOD;
}
return ret;
}
int N, A[MAXN];
long long ncr(int a, int b) {
long long ret = 1;
for (int i = a; i > a - b; --i) ret = (ret * i) % MOD;
for (int i = 1; i <= b; ++i) ret = (ret * power(i, MOD - 2)) % MOD;
return ret;
}
int main(void) {
scanf("%d", &N);
int sum = 0;
for (int i = 0; i < N; ++i) {
scanf("%d", &A[i]);
sum += A[i];
}
long long ans = 1;
for (int i = N - 1; i >= 0; --i) {
int n = sum - 1;
int r = A[i] - 1;
sum -= A[i];
ans *= ncr(n, r);
ans %= MOD;
}
printf("%d\n", (int)ans);
return 0;
}
| 9 | 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.