solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
import sys,os,io
import math,bisect,operator
inf,mod = float('inf'),10**9+7
# sys.setrecursionlimit(10 ** 6)
from itertools import groupby,accumulate
from heapq import heapify,heappop,heappush
from collections import deque,Counter,defaultdict
I = lambda : int(sys.stdin.buffer.readline())
Neo = lambda : list(map(int, sys.stdin.buffer.readline().split()))
n,m = Neo()
Color = defaultdict(set)
G = defaultdict(set)
C = set()
def addEdge(a,b):
G[a].add(b)
G[b].add(a)
def addColor(a,b,c):
Color[(a,b)].add(c)
Color[(b,a)].add(c)
C.add(c)
for i in range(m):
a,b,c = Neo()
addColor(a,b,c)
addEdge(a,b)
vis = [False]*(n+1)
Ans = []
def fun(node,dest,vis,grp):
if not grp:
return
if node == dest:
for i in grp:
Ans.append(i)
return
vis[node] = True
for i in G.get(node,[]):
if not vis[i]:
newvis = vis.copy()
z = grp.intersection(Color[node,i])
fun(i,dest,newvis,z)
for i in range(I()):
a,b = Neo()
vis = [False]*(n+1)
grp = C.copy()
fun(a,b,vis,grp)
print(len(set(Ans)))
Ans =[] | 8 | PYTHON3 |
class Graph(object):
def __init__(self, num_nodes):
self.num_nodes = num_nodes
self.adj_list = {}
def __add_directional_edge(self, a, b, c):
if a in self.adj_list:
if b in self.adj_list[a]:
if c not in self.adj_list[a][b]:
self.adj_list[a][b].append(c)
else:
self.adj_list[a][b] = []
self.adj_list[a][b].append(c)
else:
self.adj_list[a] = {}
self.adj_list[a][b] = []
self.adj_list[a][b].append(c)
def add_edge(self, a, b, c):
self.__add_directional_edge(a, b, c)
self.__add_directional_edge(b, a, c)
def print_graph(self):
print(self.adj_list)
def tc():
g = readGraph()
# g.print_graph()
for k in range(1, g.num_nodes + 1):
for i in range(1, g.num_nodes + 1):
for j in range(1, g.num_nodes + 1):
l1 = g.adj_list.get(i, {}).get(k, [])
l2 = g.adj_list.get(k, {}).get(j, [])
for color in l1:
if color in l2:
g.add_edge(i,j,color)
# g.print_graph()
return g
def readGraph():
n, m = map(int, input().split())
g = Graph(n)
for _ in range(m):
a, b, c = map(int, input().split())
g.add_edge(a,b,c)
return g
def read_query():
q = int(input())
q_list = []
for _ in range(q):
u,v = map(int, input().split())
q_list.append((u,v))
return q_list
def solve_query(g, q_list):
for u,v in q_list:
if u in g.adj_list:
if v in g.adj_list[u]:
print(len(g.adj_list[u][v]))
else:
print("0")
else:
print("0")
def main():
g = tc()
q_list = read_query()
solve_query(g, q_list)
if __name__ == "__main__":
main() | 8 | PYTHON3 |
"""
Since neither the graph nor the number of queries is too large, for each
query you can simply count the number of the "good" colors
(the colors that satisfies the condition) by checking if each color is
"good". To do that, you can perform Depth First Search (or Breadth First Search)
and verify whether you can reach vi from ui traversing only the edges of that
color. If you prefer using Union-Find, it will also do the job.
"""
from collections import defaultdict
def dfs(graph, start, end, visited, color):
q = [start]
while q:
node = q.pop()
visited[node] = True
if node == end:
break
for v in graph[color][node]:
if not visited[v]:
q.append(v)
def has_path(graph, start, end, visited, color):
for i in range(len(visited)):
visited[i] = False
dfs(graph, start, end, visited, color)
return visited[end]
n, m = map(int, input().split())
graph = defaultdict(lambda: defaultdict(list))
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
graph[c][a].append(b)
graph[c][b].append(a)
visited = [False] * n
q = int(input())
for _ in range(q):
u, v = map(int,input().split())
u -= 1
v -= 1
ans = 0
for c in graph.keys():
if has_path(graph, u, v, visited, c):
ans += 1
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void FJ() {}
vector<pair<int, int> > V[107];
bool visit[107];
bool bfs(int u, int v, int c) {
list<int> Q;
Q.push_back(u);
memset(visit, false, sizeof(visit));
visit[u] = true;
while (!Q.empty()) {
int s = Q.front();
Q.pop_front();
for (typeof((V[s]).begin()) it = (V[s].begin()); it != V[s].end(); it++) {
if (it->first == v && it->second == c) return true;
if (!visit[it->first] && it->second == c) {
visit[it->first] = true;
Q.push_back(it->first);
}
}
}
return false;
}
int main() {
FJ();
int n;
scanf("%d", &n);
int m;
scanf("%d", &m);
vector<int> cnt;
map<int, int> mp;
for (int i = 0; i < m; i++) {
int u;
scanf("%d", &u);
int v;
scanf("%d", &v);
int c;
scanf("%d", &c);
V[u].push_back(make_pair(v, c));
V[v].push_back(make_pair(u, c));
if (mp[c] == 0) cnt.push_back(c);
mp[c]++;
}
int Q;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int u;
scanf("%d", &u);
int v;
scanf("%d", &v);
int R = 0;
for (typeof((cnt).begin()) it = (cnt.begin()); it != cnt.end(); it++)
if (bfs(u, v, *it)) R++;
printf("%d\n", R);
}
return 0;
}
| 8 | CPP |
class ufds:
def __init__(self):
self.rank = dict()
self.value = dict()
def union(self,a,b):
x,y = self.findSet(a),self.findSet(b)
if self.rank[x] > self.rank[y]:
self.value[y] = x
else:
self.value[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def findSet(self,x):#Path Compression
if x != self.value[x]:
self.value[x] = self.findSet(self.value[x])
return self.value[x]
def sameSet(self,a,b):
return self.findSet(a) == self.findSet(b)
def createKey(self,x):
self.rank.update({x:0})
self.value.update({x:x})
a = list(map(int,input().split()))
size = a[0]
graph = dict()
for i in range(a[1]):
b = list(map(int,input().split()))
color = b[2]
if color not in graph.keys():
graph.update({color:ufds()})
for i in range(size):
graph[color].createKey(i+1)
graph[color].union(b[0],b[1])
for i in range(int(input())):
b = list(map(int,input().split()))
counter = 0
for j in graph.keys():
if graph[j].sameSet(b[0],b[1]):
counter+=1
print(counter) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int>> adj[101];
long long int color[101];
bool visited[101];
bool bfs(long long int s, long long int e, long long int c) {
queue<long long int> q;
q.push(s);
while (!q.empty()) {
long long int d = q.front();
q.pop();
if (d == e) {
return true;
}
for (auto x : adj[d]) {
if (!visited[x.first] && x.second == c) {
q.push(x.first);
visited[x.first] = true;
}
}
}
return false;
}
void reset() {
for (long long int i = 1; i <= 100; i++) visited[i] = false;
}
void runcases(long long int T) {
long long int n, m;
cin >> n >> m;
long long int x, y, c;
for (long long int i = 0; i < m; i++) {
cin >> x >> y >> c;
color[c] = 1;
adj[x].push_back({y, c});
adj[y].push_back({x, c});
}
long long int q;
cin >> q;
for (long long int i = 0; i < q; i++) {
cin >> x >> y;
long long int ans = 0;
for (long long int j = 1; j <= m; j++) {
reset();
if (color[j]) {
if (bfs(x, y, j)) {
ans++;
}
}
}
cout << ans << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int T = 1;
for (long long int t = 1; t <= T; t++) {
runcases(t);
}
return 0;
}
| 8 | CPP |
n, m = map(int, input().split())
graph = [[[-1] for x in range(n + 1)] for i in range(n + 1)]
for _ in range(m):
a, b, c = map(int, input().split())
if graph[a][b] != [-1]:
graph[a][b].append(c)
else:
graph[a][b] = [c]
def bfs(start, end, color):
neighbors, visited = [start], set()
while neighbors:
current, neighbors = neighbors, []
for each in current:
for i in range(1, n + 1):
if (color in graph[i][each] or color in graph[each][i]) and i not in visited:
visited.add(i)
if i == end:
return True
neighbors.append(i)
return False
q = int(input())
for _ in range(q):
u, v = map(int, input().split())
starting_colors, colors = set(), 0
for i in range(1, n + 1):
if graph[i][u] != [-1]:
starting_colors.update(graph[i][u])
elif graph[u][i] != [-1]:
starting_colors.update(graph[u][i])
for each_color in starting_colors:
if bfs(u, v, each_color):
colors += 1
print(colors)
| 8 | PYTHON3 |
n,m = map(int,input().split())
adj = [[] for _ in range(n)]
for i in range(m):
a,b,c = map(int,input().split())
a-=1
b-=1
adj[a].append([b,c])
adj[b].append([a,c])
def dfs(v,c,u,vis):
ans = []
vis[v] = True
if v==u:
return [c]
for i in adj[v]:
if vis[i[0]] or i[1]!=c:
continue
ans += dfs(i[0],c,u,vis)
return ans
q = int(input())
while q>0:
q-=1
a,b = map(int,input().split())
a-=1
b-=1
ans = []
for i in adj[a]:
vis = [False]*n
vis[a] = True
ans += dfs(i[0],i[1],b,vis)
print(len(set(ans)))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
vector<pair<ll, ll>> adj[100];
vector<bool> vis(100, 0);
bool dfs(ll u, ll v, ll col) {
vis[u] = 1;
if (u == v) return 1;
for (auto edge : adj[u]) {
if (edge.second == col && !vis[edge.first]) {
if (dfs(edge.first, v, col)) return 1;
}
}
return 0;
}
void solveCP311() {
ll n, m;
cin >> n >> m;
for (ll i = 0; i < m; i++) {
ll u, v, c;
cin >> u >> v >> c;
u--, v--, c--;
adj[u].push_back({v, c});
adj[v].push_back({u, c});
}
ll q;
cin >> q;
while (q--) {
ll u, v;
cin >> u >> v;
u--, v--;
ll ans = 0;
for (ll col = 0; col < 100; col++) {
for (ll i = 0; i < 100; i++) vis[i] = 0;
if (dfs(u, v, col)) ans++;
}
cout << ans << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
while (t--) {
solveCP311();
}
return 0;
}
| 8 | CPP |
def dfs(u1,v1,c):
ret = False
used[u1-1] = True
for i,edge in enumerate(e):
if edge[2] != c:
continue
t = None
if u1 == edge[0]:
t = edge[1]
elif u1 == edge[1]:
t = edge[0]
if t and not used[t-1]:
if t == v1:
return True
else:
ret |= dfs(t,v1,c)
return ret
n,m = map(int,input().split())
e = [list(map(int,input().split())) for i in range(m)]
used = [False for i in range(n)]
q = int(input())
a = []
for i in range(q):
u,v = map(int,input().split())
ans = 0
for c in range(1,m+1):
if dfs(u,v,c):
ans += 1
used = [False for i in range(n)]
a += [ans]
for i in a:
print(i) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int color[105][105];
vector<int> G[105][105];
int id[105];
bool vis[105];
void dfs(int x, int c) {
vis[x] = true;
id[x] = c;
for (int i = 0; i < G[c][x].size(); i++) {
int nuevo = G[c][x][i];
if (!vis[nuevo]) {
dfs(nuevo, c);
}
}
}
int main() {
int n, m, a, b, c, q;
memset(vis, false, sizeof vis);
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
--c;
G[c][a].push_back(b);
G[c][b].push_back(a);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &a, &b);
--a;
--b;
int cnt = 0;
for (int j = 0; j < m; j++) {
memset(vis, false, sizeof vis);
dfs(a, j);
if (vis[b]) ++cnt;
}
printf("%d\n", cnt);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int f[110];
int d[110][110];
bool used[110];
vector<pair<int, int> > v[110];
int getf(int x) {
if (x == f[x])
return x;
else
return f[x] = getf(f[x]);
}
void comb(int x, int y) {
int xroot = getf(x), yroot = getf(y);
f[xroot] = yroot;
}
int main() {
scanf("%d %d", &n, &m);
memset(used, false, sizeof(used));
for (int i = 0, x, y, z; i < m; i++) {
scanf("%d %d %d", &x, &y, &z);
v[x].push_back(make_pair(y, z));
used[z] = true;
}
memset(d, 0, sizeof(d));
for (int c = 0; c <= m; c++)
if (used[c]) {
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++)
for (int j = 0; j < v[i].size(); j++)
if (v[i][j].second == c) comb(i, v[i][j].first);
for (int i = 1; i <= n; i++) getf(i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (f[i] == f[j]) d[i][j]++, d[j][i]++;
}
scanf("%d", &q);
for (int i = 0, u, v; i < q; i++) {
scanf("%d %d", &u, &v);
printf("%d\n", d[u][v] / 2);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool imam[105][105][105];
vector<pair<int, int> > graf[105];
int rjesenje = 0;
bool vis[105];
void dfs(int p, int k, int boja) {
vis[p] = true;
if (p == k) return;
for (int i = 0; i < graf[p].size(); i++)
if (graf[p][i].second == boja && !vis[graf[p][i].first])
dfs(graf[p][i].first, k, boja);
return;
}
void solve(int a, int b) {
rjesenje = 0;
for (int i = 1; i <= m; i++) {
memset(vis, false, sizeof vis);
dfs(a, b, i);
if (vis[b]) rjesenje++;
}
}
int main() {
int q;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (imam[a][b][c]) continue;
graf[a].push_back(make_pair(b, c));
graf[b].push_back(make_pair(a, c));
imam[a][b][c] = imam[b][a][c] = true;
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d %d", &a, &b);
rjesenje = 0;
solve(a, b);
printf("%d\n", rjesenje);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int i, j, k, n, m, s, t, x, y, a[110][110];
int aaaa(int p, int c) { return a[p][c] == p ? p : a[p][c] = aaaa(a[p][c], c); }
void q(int p1, int p2, int c) {
int x, y;
x = aaaa(p1, c);
y = aaaa(p2, c);
if (x != y) {
a[x < y ? a[p2][c] : a[p1][c]][c] = x < y ? x : y;
}
}
int main() {
s = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
a[i][j] = i;
}
}
for (i = 0; i < m; i++) {
scanf("%d%d%d", &x, &y, &t);
q(x, y, t);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
a[i][j] = aaaa(a[i][j], j);
}
}
scanf("%d", &t);
while (t--) {
s = 0;
scanf("%d%d", &x, &y);
for (i = 1; i <= m; i++) {
if (a[x][i] == a[y][i]) s++;
}
printf("%d\n", s);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
vector<int> a[N][N];
bool mark[N][N] = {false};
int rang[N][N] = {0};
void dfs(int c, int v, int model) {
mark[c][v] = true;
rang[c][v] = model;
for (int i = 0; i < a[c][v].size(); i++) {
if (!mark[c][a[c][v][i]]) dfs(c, a[c][v][i], model);
}
}
vector<int> ra;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, temp, m;
cin >> n >> m;
int u, v, c;
for (int i = 0; i < m; i++) {
cin >> u >> v >> c;
ra.push_back(c);
a[c][u].push_back(v);
a[c][v].push_back(u);
}
sort(ra.begin(), ra.end());
ra.resize(unique(ra.begin(), ra.end()) - ra.begin());
int ans = 0;
for (int i = 0; i < ra.size(); i++) {
int k = 1;
for (int j = 1; j <= n; j++) {
if (!mark[ra[i]][j]) {
dfs(ra[i], j, k++);
}
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> u >> v;
int ans = 0;
for (int j = 0; j < ra.size(); j++) {
if (rang[ra[j]][u] == rang[ra[j]][v]) ans++;
}
cout << ans << "\n";
}
return 0;
}
| 8 | CPP |
import math,sys
#from itertools import permutations, combinations;import heapq,random;
from collections import defaultdict,deque
import bisect as bi
def yes():print('YES')
def no():print('NO')
def I():return (int(sys.stdin.readline()))
def In():return(map(int,sys.stdin.readline().split()))
def Sn():return sys.stdin.readline().strip()
#sys.setrecursionlimit(1500)
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
def find_gt(a, x):
'Find leftmost value greater than x'
i = bi.bisect_left(a, x)
if i != len(a):
return i
else:
return -1
def dfs(gp,st,end,v,x):
q=deque([st])
while q:
node=q.pop()
v[node]=1
for i in gp[node]:
if (not v[i[0]]) and (i[1]==x):
q.appendleft(i[0])
return v[end]
def main():
try:
n,m=In()
gp=defaultdict(list)
d=defaultdict(set)
for x in range(m):
a,b,c=In()
gp[a].append((b,c))
gp[b].append((a,c))
d[a].add(c)
d[b].add(c)
for i in range(I()):
st,end=In()
cnt=0
for x in d[st]:
v=[0]*(n+1)
if dfs(gp,st,end,v,x):
cnt+=1
print(cnt)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
# for _ in range(I()):main()
for _ in range(1):main()
# ******************* All The Best ******************* # | 8 | PYTHON3 |
def dfs(p, f, gr, used):
if p == f:
return 1
if used[p]:
return 0
used[p] = 1
for v in gr[p]:
if dfs(v, f, gr, used):
return 1
return 0
def check(gr, u, v):
used = [0] * len(gr)
return dfs(u, v, gr, used)
n, m = (int(x) for x in input().split())
cgr = [[[] for j in range(n)] for _ in range(m)]
for i in range(m):
a, b, c = (int(x) for x in input().split())
c -= 1
a -= 1
b -= 1
cgr[c][a].append(b)
cgr[c][b].append(a)
q = int(input())
for i in range(q):
u, v = (int(x) for x in input().split())
ans = 0
for gr in cgr:
ans += check(gr, u - 1, v - 1)
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
const long long N = 1e6 + 5;
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long isPrime(long long n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (long long i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
long long C(long long n, long long r) {
if (r > n - r) r = n - r;
long long ans = 1;
for (long long i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
long long mod = 1e9 + 7;
long long modexpo(long long x, long long p) {
long long res = 1;
x = x % mod;
while (p) {
if (p % 2) res = res * x;
p >>= 1;
x = x * x % mod;
res %= mod;
}
return res;
}
long long n, m, x, y, c, vis[105][105], cnt, q, ans;
vector<long long> v[105][105];
void dfs(long long x, long long y) {
vis[x][y] = cnt;
for (auto &i : v[x][y])
if (!vis[i][y]) dfs(i, y);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long i = 1; i <= m; i++)
cin >> x >> y >> c, v[x][c].push_back(y), v[y][c].push_back(x);
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++)
if (!vis[i][j]) cnt++, dfs(i, j);
cin >> q;
while (q--) {
cin >> x >> y, ans = 0;
for (long long i = 1; i <= m; i++) ans += (vis[x][i] == vis[y][i]);
cout << ans << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
class DisjointSet {
public:
vector<long long> rank, p;
DisjointSet() {}
DisjointSet(long long size) {
rank.resize(size, 0);
p.resize(size, 0);
for (long long i = 0; i < size; i++) makeSet(i);
}
void makeSet(long long x) {
p[x] = x;
rank[x] = 0;
}
bool same(long long x, long long y) { return findSet(x) == findSet(y); }
void unite(long long x, long long y) { link(findSet(x), findSet(y)); }
void link(long long x, long long y) {
if (rank[x] > rank[y]) {
p[y] = x;
} else {
p[x] = y;
if (rank[x] == rank[y]) {
rank[y]++;
}
}
}
long long findSet(long long x) {
if (x != p[x]) {
p[x] = findSet(p[x]);
}
return p[x];
}
};
signed main() {
long long n, m;
cin >> n >> m;
DisjointSet ds[m];
for (long long i = 0; i < m; i++) ds[i] = DisjointSet(n);
for (long long i = 0; i < m; i++) {
long long u, v, c;
cin >> u >> v >> c;
u--;
v--;
c--;
if (ds[c].same(u, v)) continue;
ds[c].unite(u, v);
}
long long q;
cin >> q;
for (long long i = 0; i < q; i++) {
long long u, v;
cin >> u >> v;
u--;
v--;
long long ans = 0;
for (long long j = 0; j < m; j++) {
if (ds[j].same(u, v)) ans++;
}
cout << ans << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 110;
int n, m;
vector<pair<int, int> > adj[MAX_N];
bool vis[MAX_N];
void dfs(int u, int c) {
vis[u] = 1;
for (pair<int, int> v : adj[u])
if (!vis[v.first] && v.second == c) {
dfs(v.first, c);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
int c;
cin >> c;
c--;
u--;
v--;
adj[u].push_back(make_pair(v, c));
adj[v].push_back(make_pair(u, c));
}
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
u--;
v--;
int cnt = 0;
for (int i = 0; i < m; i++) {
for (int i = 0; i < n; i++) vis[i] = 0;
dfs(u, i);
if (vis[v]) cnt++;
}
cout << cnt << "\n";
}
}
| 8 | CPP |
import sys
import math
import heapq
import bisect
from collections import Counter
from collections import defaultdict
from io import BytesIO, IOBase
import string
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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
self.BUFSIZE = 8192
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.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 = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.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:
self.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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def get_int():
return int(input())
def get_ints():
return list(map(int, input().split(' ')))
def get_int_grid(n):
return [get_ints() for _ in range(n)]
def get_str():
return input().split(' ')
def yes_no(b):
if b:
return "YES"
else:
return "NO"
def binary_search(good, left, right, delta=1, right_true=False):
"""
Performs binary search
----------
Parameters
----------
:param good: Function used to perform the binary search
:param left: Starting value of left limit
:param right: Starting value of the right limit
:param delta: Margin of error, defaults value of 1 for integer binary search
:param right_true: Boolean, for whether the right limit is the true invariant
:return: Returns the most extremal value interval [left, right] which is good function evaluates to True,
alternatively returns False if no such value found
"""
limits = [left, right]
while limits[1] - limits[0] > delta:
if delta == 1:
mid = sum(limits) // 2
else:
mid = sum(limits) / 2
if good(mid):
limits[int(right_true)] = mid
else:
limits[int(~right_true)] = mid
if good(limits[int(right_true)]):
return limits[int(right_true)]
else:
return False
def prefix_sums(a, drop_zero=False):
p = [0]
for x in a:
p.append(p[-1] + x)
if drop_zero:
return p[1:]
else:
return p
def prefix_mins(a, drop_zero=False):
p = [float('inf')]
for x in a:
p.append(min(p[-1], x))
if drop_zero:
return p[1:]
else:
return p
class DSU:
# Disjoint Set Union (Union-Find) Data Structure
def __init__(self, nodes):
# Parents
self.p = [i for i in range(nodes)]
# Ranks
self.r = [0 for i in range(nodes)]
# Sizes
self.s = [1 for i in range(nodes)]
def get(self, u):
# Recursive Returns the identifier of the set that contains u, includes path compression
if u != self.p[u]:
self.p[u] = self.get(self.p[u])
return self.p[u]
def union(self, u, v):
# Unites the sets with identifiers u and v
u = self.get(u)
v = self.get(v)
if u != v:
if self.r[u] > self.r[v]:
u, v = v, u
self.p[u] = v
if self.r[u] == self.r[v]:
self.r[v] += 1
self.s[v] += self.s[u]
def solve_b():
n, m = get_ints()
dsus = [DSU(n) for _ in range(m)]
for e in range(m):
a, b, c = get_ints()
dsus[c - 1].union(a - 1, b - 1)
def respond(u, v):
S = 0
for color in range(m):
if dsus[color].get(u - 1) == dsus[color].get(v - 1):
S += 1
return S
q = get_int()
for query in range(q):
u, v = get_ints()
print(respond(u, v))
return
solve_b()
| 8 | PYTHON3 |
n, m = map(int, input().split())
graph = [[] for _ in range(105)]
for _ in range(m):
a, b, c = map(int, input().split())
graph[a].append([b,c])
graph[b].append([a,c])
def dfs(source, destination, colour):
if source == destination:
return True
visited[source] = True
for node in graph[source]:
if node[1] == colour and visited[node[0]] is False:
if dfs(node[0], destination, colour):
return True
return False
for i in range(int(input())):
ans = 0
f, y = map(int ,input().split())
for colour in range(1, 101):
visited = [False]*(n+1)
if dfs(f, y, colour):
ans += 1
print(ans) | 8 | PYTHON3 |
from collections import defaultdict
from sys import stdin, stdout
par = defaultdict(list)
def build(n):
global par, size
for c in range(101):
par[c] = []
for i in range(n):
par[c].append(i)
return par
def find(c, i):
global par
if par[c][i] == i:
return i
par[c][i] = find(c, par[c][i])
return par[c][i]
def union(a, b, c):
global par, scc, size
p = find(c, a)
q = find(c, b)
if p == q:
return
par[c][q] = par[c][p]
def main():
(n, m) = map(int, stdin.readline().strip().split(' '))
par = build(n)
max_c = 0
for i in range(m):
(a, b, c) = map(lambda i: int(i) - 1, stdin.readline().strip().split(' '))
union(a, b, c)
max_c = max(max_c, c)
q = int(stdin.readline().strip())
for i in range(q):
(a, b) = map(lambda i: int(i) - 1, stdin.readline().strip().split(' '))
count = 0
for c in range(max_c + 1):
p = find(c, a)
q = find(c, b)
if p == q:
count += 1
stdout.write('{}\n'.format(count))
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> v[105];
vector<bool> vis(105, false);
void dfs(int src, int des, int clr, int &aa, int &cc) {
if (src == des && cc == 0) {
aa++;
cc++;
return;
}
if (vis[src]) return;
vis[src] = true;
for (auto x : v[src]) {
if (x.second == clr && vis[x.first] == false) {
dfs(x.first, des, clr, aa, cc);
}
}
}
int main() {
int n, m;
cin >> n >> m;
int mx = 0;
for (int i = 0; i < m; i++) {
int a, b, clr;
cin >> a >> b >> clr;
v[a].push_back({b, clr});
v[b].push_back({a, clr});
if (clr > mx) mx = clr;
}
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
int ans = 0;
for (int i = 1; i <= mx; i++) {
int aa = 0;
int cc = 0;
dfs(a, b, i, aa, cc);
ans += aa;
for (int i = 0; i <= n; i++) vis[i] = false;
}
cout << ans << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, us[101], f = 0, t = 0;
vector<int> v[101][101], ans;
void dfs(int x, int y, int zvet) {
if (x == y) f = 1;
int i, j;
us[x] = 1;
for (i = 0; i < v[x][zvet].size(); i++) {
int to = v[x][zvet][i];
if (us[to] == 0) dfs(to, y, zvet);
}
}
int main() {
int q, x, y, g, z, i, j;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> x >> y >> z;
v[x][z].push_back(y);
v[y][z].push_back(x);
}
cin >> q;
for (i = 1; i <= q; i++) {
int kol = 0;
cin >> x >> y;
t = 0;
for (j = 0; j < 101; j++) {
for (g = 0; g < 101; g++) us[g] = 0;
f = 0;
dfs(x, y, j);
kol += f;
}
ans.push_back(kol);
}
for (i = 0; i < ans.size(); i++) cout << ans[i] << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool cust1(pair<int64_t, pair<int64_t, int64_t> > a,
pair<int64_t, pair<int64_t, int64_t> > b) {
if (a.first == b.first) {
if (a.second.first == b.second.first) {
return a.second.second < b.second.second;
}
return a.second.first < b.second.first;
}
return a.first < b.first;
}
bool cust2(pair<int64_t, int64_t> a, pair<int64_t, int64_t> b) {
return a.first < b.first;
}
class CompareDist {
public:
bool operator()(pair<int64_t, int64_t> a, pair<int64_t, int64_t> b) {
return a.first > b.first;
}
};
int64_t gcd(int64_t a, int64_t b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<vector<vector<int> > > nodes(101);
vector<vector<int> > visited(101);
bool DFS(int start, int color, int dest) {
if (start == dest) return true;
visited[color][start] = 1;
bool temp = false;
for (int i = 0; i < nodes[color][start].size(); i++) {
if (visited[color][nodes[color][start][i]] == 0) {
temp |= DFS(nodes[color][start][i], color, dest);
}
}
return temp;
}
int main() {
int n, m, i, j;
cin >> n >> m;
vector<map<int, int> > colors(101);
for (i = 0; i < 101; i++) {
vector<vector<int> > temp(101);
vector<int> temp_2(101, 0);
nodes[i] = temp;
visited[i] = temp_2;
}
for (i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
colors[c][a] = 1;
colors[c][b] = 1;
nodes[c][a].push_back(b);
nodes[c][b].push_back(a);
}
int q;
cin >> q;
for (i = 0; i < q; i++) {
int a, b, ctr = 0;
cin >> a >> b;
for (j = 1; j < colors.size(); j++) {
if (colors[j].find(a) != colors[j].end() &&
colors[j].find(a) != colors[j].end()) {
bool temp = DFS(a, j, b);
if (temp) ctr++;
fill(visited[j].begin(), visited[j].end(), 0);
}
}
cout << ctr << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[105];
int n, m;
int flag = 0;
bool visited[101];
void dfs(int x, int y, int p, int j) {
int i;
if (visited[x]) {
return;
}
if (x == y) {
flag = 1;
return;
}
visited[x] = 1;
for (i = 0; i < v[x].size(); i++) {
if (v[x][i].first != p && v[x][i].second == j) {
dfs(v[x][i].first, y, x, j);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j, k;
cin >> n >> m;
int color[105];
for (i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
v[x].push_back(make_pair(y, z));
v[y].push_back(make_pair(x, z));
}
int q;
cin >> q;
for (i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
int cnt = 0;
for (j = 1; j <= m; j++) {
memset(visited, 0, sizeof(visited));
flag = 0;
dfs(x, y, -1, j);
if (flag == 1) cnt++;
}
cout << cnt << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const long long mod = 1000000007;
int g[110][110][110];
int n, m;
void dfs(int r, int c, vector<int>& mark) {
if (mark[r]) return;
mark[r] = 1;
for (int u = 1; u <= n; u++) {
if (g[c][r][u]) dfs(u, c, mark);
}
}
int calc(int a, int b) {
int ret = 0;
for (int c = 1; c <= m; c++) {
vector<int> mark(n + 1);
dfs(a, c, mark);
ret += mark[b];
}
return ret;
}
void solve(int ncase) {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
g[c][a][b] = 1;
g[c][b][a] = 1;
}
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
cout << calc(u, v) << endl;
}
}
int main() {
int T = 1;
int ncase = 0;
while (T--) {
solve(++ncase);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int id[101][101];
int sz[101][101];
int root(int i, int c) {
while (id[c][i] != i) {
id[c][i] = id[c][id[c][i]];
i = id[c][i];
}
return i;
}
bool connected(int p, int q, int c) { return root(p, c) == root(q, c); }
void qunion(int p, int q, int c) {
int rp = root(p, c);
int rq = root(q, c);
if (rp == rq) return;
if (sz[c][rp] < sz[c][rq]) {
id[c][rp] = rq;
sz[c][rq] += sz[c][rp];
} else {
id[c][rq] = rp;
sz[c][rp] += sz[c][rq];
}
}
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
for (int j = 1; j <= 100; j++) {
for (int i = 1; i <= 100; i++) {
id[j][i] = i;
sz[j][i] = 1;
}
}
for (int i = 0; i < m; i++) {
int x, y, c;
cin >> x >> y >> c;
qunion(x, y, c);
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int x;
int y;
cin >> x >> y;
int ans = 0;
for (int j = 1; j <= 100; j++) {
if (connected(x, y, j)) ans++;
}
cout << ans << "\n";
}
}
| 8 | CPP |
def dfs_paths(graph, start, goal, path=list()):
if not path:
path.append(start)
if start == goal:
yield path
for vertex in graph[start] - set(path):
yield from dfs_paths(graph, vertex, goal, path=path + [vertex])
n, m = map(int, input().split())
graph = {}
for _ in range(m):
a, b, c = map(int, input().split())
if c not in graph:
graph[c] = {}
if a not in graph[c]:
graph[c][a] = set()
if b not in graph[c]:
graph[c][b] = set()
graph[c][a].add(b)
graph[c][b].add(a)
q = int(input())
for _ in range(q):
u, v = map(int, input().split())
count = 0
for k in graph:
if u not in graph[k] or v not in graph[k]:
continue
if len(list(dfs_paths(graph[k], u, v, []))) > 0:
count += 1
print(count) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int num, pre;
Node(int _num = 0, int _pre = 0) {
num = _num;
pre = _pre;
}
};
int flag = 0;
int cnt = 0;
vector<bool> vi;
void dfs(vector<vector<vector<int> > > &arc, int n, int u, int v, int c,
int pre) {
vi[u] = true;
int ii = 0, jj = 0;
if (u == v) {
cnt++;
flag = 1;
return;
}
for (jj = 1; jj <= n; jj++) {
if (flag == 1) break;
if (vi[jj] == false &&
find(arc[u][jj].begin(), arc[u][jj].end(), c) != arc[u][jj].end()) {
dfs(arc, n, jj, v, c, u);
}
}
}
int main() {
int n = 0, m = 0;
while (cin >> n >> m) {
vector<int> v_tmp;
vector<vector<vector<int> > > arc(n + 1,
vector<vector<int> >(n + 1, v_tmp));
int i = 0, j = 0;
for (i = 1; i <= m; i++) {
int a = 0, b = 0, c = 0;
cin >> a >> b >> c;
arc[a][b].push_back(c);
arc[b][a].push_back(c);
}
int q = 0;
cin >> q;
int ii = 0, jj = 0, kk = 0;
for (i = 0; i < q; i++) {
int u = 0, v = 0;
cin >> u >> v;
if (u > v) {
int tmp = u;
u = v;
v = tmp;
}
cnt = 0;
for (ii = 1; ii <= m; ii++) {
flag = 0;
vi = vector<bool>(n + 1, false);
dfs(arc, n, u, v, ii, -1);
}
cout << cnt << endl;
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a, b, c, s, t;
bool v[105];
vector<int> adj[105][105];
int dp[105][105][105];
int dfs(int par, int cur, int t, int cg) {
v[cur] = true;
if (cur == t) return 1;
int ret = 0;
for (int x : adj[cur][cg]) {
if (v[x]) continue;
ret += dfs(cur, x, t, cg);
}
dp[cur][t][cg] = ret;
return dp[cur][t][cg];
}
int main() {
memset(dp, 0, sizeof dp);
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
adj[a][c].push_back(b);
adj[b][c].push_back(a);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &s, &t);
int ans = 0;
for (int j = 1; j <= m; j++) {
memset(v, 0, sizeof v);
ans += dfs(0, s, t, j);
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
#sys.setrecursionlimit(111111)
INF=99999999999999999999999999999999
def outIn(x):
print(x, flush=True)
return input()
def main():
mod=1000000007
# InverseofNumber(mod)
# InverseofFactorial(mod)
# factorial(mod)
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
###CODE
tc = 1
for _ in range(tc):
n,m=ria()
d={}
for i in range(m):
a,b,c=ria()
if c not in d:
d[c]=[[a,b]]
else:
d[c].append([a,b])
def dfs(graph, start,visited):
n = len(graph)
comp=[]
stack = [start]
t=0
while stack:
start = stack[-1]
# push unvisited children into stack
if not visited[start]:
comp.append(start)
visited[start] = True
for child in graph[start]:
if not visited[child]:
stack.append(child)
else:
stack.pop()
return comp,visited
fd={}
for i in range(1,m+1):
if i in d:
visited=[False]*(n+1)
graph=[[] for i in range(n+1)]
vert={}
for u,v in d[i]:
vert[u]=1
vert[v]=1
graph[u].append(v)
graph[v].append(u)
for j in vert:
if not visited[j]:
comp,visited=dfs(graph,j,visited)
if i in fd:
fd[i].append(comp)
else:
fd[i]=[comp]
q=ri()
for i in range(q):
u,v=ria()
count=0
for j in range(1,m+1):
f=0
if j in fd:
for t in fd[j]:
if u in t and v in t:
f=1
break
count+=f
print(count)
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
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, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
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()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
| 8 | PYTHON3 |
from sys import stdin,stdout
input = stdin.readline
def main():
n, m = map(int,input().split())
sets = [list(range(n+1)) for i in range(m)]
sizes = [[1]*(n+1) for i in range(m)]
def get(a,ind):
if sets[ind][a] != a:
sets[ind][a] = get(sets[ind][a],ind)
return sets[ind][a]
def union(a, b,ind):
a = get(a,ind)
b = get(b,ind)
if a == b:return
if sizes[ind][a] > sizes[ind][b]:
a,b = b,a
sets[ind][a] = b
sizes[ind][b] += sizes[ind][a]
for i in range(m):
a, b, c = map(int,input().split())
a -= 1
b -= 1
c -= 1
union(a,b,c)
q = int(input())
for i in range(q):
ans = 0
u,v = map(int,input().split())
u-=1
v-=1
for j in range(m):
ans += int(get(u,j) == get(v,j))
print(ans)
main()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > adj[101];
queue<pair<int, int> > qu;
map<pair<int, int>, int> ans;
set<pair<int, int> > chk[101];
set<int> stk;
int bfs(int st, int en) {
int x, cnt, i, y, co, pr;
cnt = 0;
while (!qu.empty()) {
x = qu.front().first;
pr = qu.front().second;
qu.pop();
for (i = 0; i < adj[x].size(); i++) {
y = adj[x][i].first;
co = adj[x][i].second;
if ((chk[co].find({x, y}) != chk[co].end()) || (co != pr && pr != -1))
continue;
chk[co].insert({x, y});
chk[co].insert({y, x});
if (y == en && stk.find(co) == stk.end()) {
stk.insert(co);
cnt++;
} else
qu.push({y, co});
}
}
return cnt;
}
int main() {
int n, m, i, q, a, b, c;
cin >> n >> m;
for (i = 0; i < m; i++) {
scanf("%d %d %d", &a, &b, &c);
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
cin >> q;
while (q--) {
scanf("%d %d", &a, &b);
if (ans.find({a, b}) == ans.end()) {
qu.push({a, -1});
c = bfs(a, b);
if (c == 0) c = -1;
ans[{a, b}] = c;
ans[{b, a}] = c;
stk.clear();
for (i = 0; i < 101; i++) chk[i].clear();
} else {
c = ans[{a, b}];
}
if (c == -1) c = 0;
printf("%d\n", c);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> adj[101];
int vis[101][101];
int id;
bool dfs(const int &idx, int cur, int to) {
if (cur == to) return true;
bool ret = false;
for (int i = 0; i < (int)adj[idx][cur].size(); i++) {
if (vis[idx][adj[idx][cur][i]] == id) continue;
vis[idx][adj[idx][cur][i]] = id;
ret |= dfs(idx, adj[idx][cur][i], to);
}
return ret;
}
int main() {
int n, m, q;
scanf("%d%d", &n, &m);
for (int i = 0; i < 101; i++) adj[i].resize(n);
for (int i = 0, u, v, c; i < m; i++) {
scanf("%d%d%d", &u, &v, &c);
adj[c - 1][u - 1].push_back(v - 1);
adj[c - 1][v - 1].push_back(u - 1);
}
int u, v;
scanf("%d", &q);
while (q--) {
id++;
scanf("%d%d", &u, &v);
int ans = 0;
for (int i = 0; i < m; i++) ans += dfs(i, u - 1, v - 1);
printf("%d\n", ans);
}
}
| 8 | CPP |
from collections import defaultdict
class DisjSet:
def __init__(self, n):
# Constructor to create and
# initialize sets of n items
self.rank = [1] * n
self.parent = [i for i in range(n)]
# Finds set of given item x
def find(self, x):
# Finds the representative of the set
# that x is an element of
if (self.parent[x] != x):
# if x is not the parent of itself
# Then x is not the representative of
# its set,
self.parent[x] = self.find(self.parent[x])
# so we recursively call Find on its parent
# and move i's node directly under the
# representative of this set
return self.parent[x]
# Do union of two sets represented
# by x and y.
def Union(self, x, y):
# Find current sets of x and y
xset = self.find(x)
yset = self.find(y)
# If they are already in same set
if xset == yset:
return
# Put smaller ranked item under
# bigger ranked item if ranks are
# different
if self.rank[xset] < self.rank[yset]:
self.parent[xset] = yset
elif self.rank[xset] > self.rank[yset]:
self.parent[yset] = xset
# If ranks are same, then move y under
# x (doesn't matter which one goes where)
# and increment rank of x's tree
else:
self.parent[yset] = xset
self.rank[xset] = self.rank[xset] + 1
L = []
n,m = map(int,input().split())
edges = []
for k in range(m):
a,b,c = map(int,input().split())
edges.append([a,b,c])
q = int(input())
queries = []
for l in range(q):
x,y = map(int,input().split())
queries.append([x,y])
count = [0 for i in range(q)]
for i in range(1,101):
g = DisjSet(101)
for [u,v,c] in edges:
if c == i:
g.Union(u,v)
for z in range(q):
if g.find(queries[z][0]) == g.find(queries[z][1]):
count[z] += 1
for m in range(q):
print(count[m]) | 8 | PYTHON3 |
def arr_inp(n):
if n == 1:
return [int(x) for x in stdin.readline().split()]
elif n == 2:
return [float(x) for x in stdin.readline().split()]
else:
return [str(x) for x in stdin.readline().split()]
class disjointset:
def __init__(self, n):
self.rank, self.parent, self.n, self.nsets, self.edges = defaultdict(int), defaultdict(int), n, defaultdict(
int), defaultdict(int)
for i in range(1, n + 1):
self.parent[i], self.nsets[i] = i, 1
def find(self, x):
if self.parent[x] == x:
return x
result = self.find(self.parent[x])
self.parent[x] = result
return result
def union(self, x, y):
xpar, ypar = self.find(x), self.find(y)
# already union
if xpar == ypar:
self.edges[xpar] += 1
return
# perform union by rank
if self.rank[xpar] < self.rank[ypar]:
self.parent[xpar] = ypar
self.edges[ypar] += self.edges[xpar] + 1
self.nsets[ypar] += self.nsets[xpar]
elif self.rank[xpar] > self.rank[ypar]:
self.parent[ypar] = xpar
self.edges[xpar] += self.edges[ypar] + 1
self.nsets[xpar] += self.nsets[ypar]
else:
self.parent[ypar] = xpar
self.rank[xpar] += 1
self.edges[xpar] += self.edges[ypar] + 1
self.nsets[xpar] += self.nsets[ypar]
from sys import stdin
from collections import defaultdict
n, m = arr_inp(1)
color = [disjointset(n) for i in range(m)]
for i in range(m):
a, b, c = arr_inp(1)
color[c - 1].union(a, b)
for i in range(int(input())):
u, v = arr_inp(1)
ans = 0
for j in range(m):
if color[j].find(u) == color[j].find(v):
ans += 1
print(ans)
| 8 | PYTHON3 |
def main():
def dfs(index, color):
visited[index] = True
for p in adj[index]:
if not visited[p[0]] and p[1] == color:
dfs(p[0], color)
n, m = map(int, input().split())
adj = [[] for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
adj[a - 1].append((b - 1, c))
adj[b - 1].append((a - 1, c))
q = int(input())
for _ in range(q):
a, b = map(int, input().split())
ans = 0
for i in range(1, m + 1):
visited = [False] * n
dfs(a - 1, i)
if visited[b - 1]:
ans += 1
print(ans)
if __name__ == "__main__":
main() | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int X[] = {1, -1, 0, 0};
int Y[] = {0, 0, 1, -1};
const int N = 2e5 + 5;
int n, m, q;
vector<vector<int> > graph(101);
map<pair<int, int>, vector<int> > clr;
vector<vector<int> > ans(101, vector<int>(101, 0));
void bfs(int pos) {
queue<int> q;
q.push(pos);
vector<vector<int> > color(n + 1, vector<int>(m + 1));
for (int i = 1; i <= m; i++) color[pos][i] = 1;
vector<int> vis(n + 1, 0);
vis[pos] = 1000;
int now = 101;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int to : graph[u]) {
int cnt = 0;
vector<int> tmp = clr[make_pair(min(to, u), max(to, u))];
for (auto it : tmp) (color[u][it] == 1) ? color[to][it] = 1 : 1;
for (int i = 1; i <= m; i++) {
if (color[to][i]) cnt++;
}
if (vis[to] < cnt) {
vis[to] = cnt;
q.push(to);
}
}
}
for (int i = 1; i <= n; i++) ans[i][pos] = ans[pos][i] = vis[i];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
int a, b, c;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
graph[a].push_back(b);
graph[b].push_back(a);
if (a > b) swap(a, b);
clr[make_pair(a, b)].push_back(c);
}
for (int i = 1; i <= n; i++) bfs(i);
cin >> q;
while (q--) {
cin >> a >> b;
cout << ans[a][b] << endl;
}
}
| 8 | CPP |
from sys import setrecursionlimit as setrec
setrec(10010)
def dfs(i, s, cnt):
if colored[i][s] > 0: return
colored[i][s] = cnt
for t in g[i][s]:
dfs(i, t, cnt)
ver_n, edge_n = map(int, input().split())
g = [[[] for _ in range(ver_n)] for _ in range(edge_n)]
for _ in range(edge_n):
a, b, c = map(lambda x: int(x)-1, input().split())
g[c][a].append(b)
g[c][b].append(a)
colored = [[0] * ver_n for _ in range(edge_n)]
for i in range(edge_n):
cnt = 1
for j in range(ver_n):
dfs(i, j, cnt)
cnt += 1
q = int(input())
for i in range(q):
cnt = 0
u, v = map(lambda x: int(x)-1, input().split())
for j in range(edge_n):
if colored[j][u] == colored[j][v]:
cnt += 1
print(cnt)
| 8 | PYTHON3 |
import copy
info= list(map(int, input().split()))
n=info[0]
m=info[1]
mat=[[[] for i in range(n)] for j in range(n)]
for i in range(m):
info= list(map(int, input().split()))
a=info[0]
b=info[1]
c=info[2]
mat[a-1][b-1].append(c)
mat[b-1][a-1].append(c)
q=int(input())
for i in range(q):
info= list(map(int, input().split()))
u=info[0]-1
v=info[1]-1
l=[]
for j in range(n):
p=len(mat[u][j])
for h in range(p):
l.append(mat[u][j][h])
l=list(set(l))
p=len(l)
c=0
for j in range(p):
co=l[j]
lis=[False]*n
stk=[]
curr=u
while(True):
found=False
for h in range(n):
if(not(lis[h]) and co in mat[curr][h]):
stk.append(curr)
lis[h]=True
curr=h
found=True
break
if(curr==v):
c+=1
break
if(not(found)):
if(len(stk)==0):
break
curr=stk[-1]
stk.pop(-1)
print(c) | 8 | PYTHON3 |
#make a table
n,m = map(int,input().split())
arr = [[] for i in range(n+1)]
for i in range(1,m+1):
l = list(map(int,input().split()))
arr[l[0]].append((l[1],l[2]))
arr[l[1]].append((l[0],l[2]))
#dfs
def dfs(a,b,k):
if a == b:
return True
seen.append(a)
for i in arr[a]:
x,c = i
if c == k and x not in seen:
if dfs(x,b,k):
return True
return False
query = int(input())
count = 0
score = [0]*(query)
seen = []
#get destination inputs
for i in range(query):
a,b = map(int,input().split())
for k in range(1,101):
seen = []
if dfs(a,b,k):
count += 1
score[i] = count
count = 0
print("\n".join(list(map(str,score)))) | 8 | PYTHON3 |
from collections import defaultdict
def dfs(adjlist, start, visited, nodes, color):
if start in visited:
return
visited.add(start)
for (v,c) in adjlist[start]:
if c == color:
nodes[v-1] = nodes[start-1]
dfs(adjlist, v, visited, nodes, color)
if __name__ =='__main__':
n,m = map(int, input().split())
adjlist = defaultdict(list)
all_color = set()
for i in range(0,m):
tmp = list(map(int, input().split()))
adjlist[tmp[0]].append((tmp[1],tmp[2]))
adjlist[tmp[1]].append((tmp[0],tmp[2]))
all_color.add(tmp[2])
num_queries = int(input())
queries = []
for i in range(0,num_queries):
queries.append(list(map(int, input().split())))
color_map = {}
for c in all_color:
nodes = [i for i in range(1,n+1)]
for src in range(1,n+1):
visited = set()
dfs(adjlist, src, visited, nodes, c)
if len(visited) == n:
break
color_map[c] = nodes
#print(color_map)
for q in queries:
count = 0
for c in color_map.keys():
if color_map[c][q[0]-1] == color_map[c][q[1]-1]:
count += 1
print(count) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<long long, long long>>> adj;
vector<bool> visited;
long long ans;
long long u, v;
bool dfs(long long node, long long color) {
visited[node] = true;
if (node == v) {
return 1;
}
long long sum = 0;
for (auto x : adj[node]) {
if (x.second == color && !visited[x.first]) {
sum += dfs(x.first, x.second);
}
}
return sum > 0 ? true : false;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
adj.resize(n + 1);
for (long long i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
long long q;
cin >> q;
while (q--) {
cin >> u >> v;
ans = 0;
set<long long> s;
for (auto x : adj[u]) {
visited.clear();
visited.resize(n + 1, false);
visited[u] = true;
if (dfs(x.first, x.second)) {
s.insert(x.second);
}
}
cout << s.size() << "\n";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 105;
vector<pair<long long int, long long int>> adj[N];
vector<bool> vis(N);
bool dfs(long long int u, long long int v, long long int col) {
vis[u] = true;
if (u == v) {
return true;
}
for (auto i : adj[u]) {
long long int vert = i.first;
long long int color = i.second;
if (color == col && !vis[vert]) {
if (dfs(vert, v, col)) {
return true;
}
}
}
return false;
}
void assignFalse() {
for (long long int i = 0; i < N; i++) {
vis[i] = false;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
for (long long int i = 1; i <= m; i++) {
long long int u, v, c;
cin >> u >> v >> c;
adj[u].push_back({v, c});
adj[v].push_back({u, c});
}
long long int Q;
cin >> Q;
while (Q--) {
long long int cnt = 0;
long long int u, v;
cin >> u >> v;
for (long long int i = 1; i <= 100; i++) {
assignFalse();
if (dfs(u, v, i)) {
cnt++;
}
}
cout << cnt << endl;
}
return 0;
}
| 8 | CPP |
scanf = lambda:map(int,input().split())
n,m = scanf()
f = [list(range(n+1)) for _ in range(m+2)]
def fd(a,c):
if f[c][a]!=a:f[c][a] = fd(f[c][a],c)
return f[c][a]
def un(a,b,c):
ra,rb = fd(a,c),fd(b,c)
if ra==rb:return
f[c][ra] = rb
def swap(a,b):
tmp = a
a = b
b = tmp
for a,b,c in [map(int,input().split()) for _ in range(m)]:
un(a,b,c)
q = int(input())
for x,y in [map(int,input().split()) for _ in range(q)]:
print(sum(1 for i in range(1,m+1) if fd(x,i) == fd(y,i))) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a, b, c, s, t;
bool v[105];
vector<int> adj[105][105];
int dp[105][105][105];
int dfs(int par, int cur, int t, int cg) {
v[cur] = true;
if (cur == t) return 1;
int ret = 0;
for (int x : adj[cur][cg]) {
if (v[x]) continue;
ret += dfs(cur, x, t, cg);
}
dp[cur][t][cg] = ret;
return dp[cur][t][cg];
}
int main() {
memset(dp, 0, sizeof dp);
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
adj[a][c].push_back(b);
adj[b][c].push_back(a);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &s, &t);
int ans = 0;
for (int j = 1; j <= m; j++) {
memset(v, 0, sizeof v);
ans += dfs(0, s, t, j);
}
printf("%d\n", ans);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[101];
vector<pair<long long int, long long int>> con[101];
bool f;
bool b[101];
void dfs(long long int u, long long int u1) {
if (b[u] == true || f) return;
if (u == u1) {
f = true;
return;
}
b[u] = true;
for (auto ad : v[u]) dfs(ad, u1);
}
int main() {
long long int t = 1;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
while (t--) {
long long int i, j, k, m, n, u, v1, c, q;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v1 >> c;
con[c].push_back({u, v1});
}
cin >> q;
long long int ans[101];
for (int i = 0; i < 101; i++) ans[i] = 0;
long long int qu[101][2];
for (int i = 0; i < q; i++) cin >> qu[i][0] >> qu[i][1];
for (i = 1; i <= m; i++) {
for (int j = 0; j < 101; j++) v[j].clear();
for (int j = 0; j < 101; j++) b[j] = false;
for (j = 0; j < con[i].size(); j++) {
v[con[i][j].first].push_back(con[i][j].second);
v[con[i][j].second].push_back(con[i][j].first);
}
for (j = 0; j < q; j++) {
f = false;
for (int k = 0; k < 101; k++) b[k] = false;
dfs(qu[j][0], qu[j][1]);
if (f) ans[j + 1]++;
}
}
for (int i = 1; i < q + 1; i++) cout << ans[i] << "\n";
}
return 0;
}
| 8 | CPP |
def find(c, x):
p = dsu[c]
if x == p[x]:
return x
return find(c, p[x])
def union(c, x, y):
x = find(c, x)
y = find(c, y)
if x == y:
return
p = dsu[c]
p[x] = y
n, m = map(int, input().split())
dsu = [[i for i in range(n + 1)] for _ in range(m + 1)]
for _ in range(m):
a, b, c = map(int, input().split())
union(c, a, b)
q = int(input())
for _ in range(q):
a, b = map(int, input().split())
count = 0
for c in range(1, m + 1):
if find(c, a) == find(c, b):
count += 1
print(count)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int mxn = 233;
const int mod = 1e9 + 7;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) f = c == '-' ? -1 : 1, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return x * f;
}
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
long long ksm(long long a, long long b, long long mod) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long inv2(long long a, long long mod) { return ksm(a, mod - 2, mod); }
void exgcd(long long a, long long b, long long &x, long long &y, long long &d) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, y, x, d);
y -= x * (a / b);
}
}
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int n, m, f[mxn][mxn];
void init() {
for (int i = 1; i < mxn; ++i)
for (int j = 1; j < mxn; ++j) f[i][j] = j;
}
int find(int u, int c) {
int rt = u;
while (f[c][rt] != rt) rt = f[c][rt];
int y = u;
while (y != rt) {
int t = f[c][y];
f[c][y] = rt;
y = t;
}
return rt;
}
void join(int u, int v, int c) {
int fu = find(u, c), fv = find(v, c);
if (fu != fv) f[c][fu] = fv;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
;
cin >> n >> m;
init();
int u, v, c;
for (int i = 1; i <= m; ++i) {
cin >> u >> v >> c;
join(u, v, c);
}
int q;
cin >> q;
while (q--) {
cin >> u >> v;
int res = 0;
for (int i = 1; i <= m; ++i)
if (find(u, i) == find(v, i)) res++;
cout << res << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int mxn = 233;
const int mod = 1e9 + 7;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) f = c == '-' ? -1 : 1, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return x * f;
}
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
long long ksm(long long a, long long b, long long mod) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long inv2(long long a, long long mod) { return ksm(a, mod - 2, mod); }
void exgcd(long long a, long long b, long long &x, long long &y, long long &d) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, y, x, d);
y -= x * (a / b);
}
}
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int n, m, f[mxn][mxn];
void init() {
for (int i = 1; i < mxn; ++i)
for (int j = 1; j < mxn; ++j) f[i][j] = j;
}
int find(int u, int c) {
int i;
for (i = u; i != f[c][i]; i = f[c][i]) f[c][i] = f[c][f[c][i]];
return i;
}
void join(int u, int v, int c) {
int fu = find(u, c), fv = find(v, c);
if (fu != fv) f[c][fu] = fv;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
;
cin >> n >> m;
init();
int u, v, c;
for (int i = 1; i <= m; ++i) {
cin >> u >> v >> c;
join(u, v, c);
}
int q;
cin >> q;
while (q--) {
cin >> u >> v;
int res = 0;
for (int i = 1; i <= m; ++i)
if (find(u, i) == find(v, i)) res++;
cout << res << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000047;
char s[maxn];
int n;
vector<int> utried() {
vector<int> lepsich(n);
vector<int> por;
int otv = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
por.push_back(i);
lepsich[i] = 0;
otv++;
}
}
for (int i = 0; i < n; i++) {
if (s[i] == ')') {
por.push_back(i);
lepsich[i] = otv;
}
}
for (int sl = 1; sl < n; sl *= 2) {
vector<int> npor(n), off(n, 0);
for (int i = 0; i < n; i++) {
int ind = (por[i] - sl + n) % n;
npor[lepsich[ind] + off[lepsich[ind]]] = ind;
off[lepsich[ind]]++;
}
por = npor;
vector<int> nlepsich(n);
nlepsich[por[0]] = 0;
for (int i = 1; i < n; i++) {
if (lepsich[por[i]] == lepsich[por[i - 1]] &&
lepsich[(por[i] + sl) % n] == lepsich[(por[i - 1] + sl) % n]) {
nlepsich[por[i]] = nlepsich[por[i - 1]];
} else
nlepsich[por[i]] = i;
}
lepsich = nlepsich;
}
return por;
}
int main() {
scanf("%s", s);
for (n = 0; s[n] != 0; n++)
;
vector<int> depth(n + 1, 0);
for (int i = 1; i <= n; i++) {
if (s[i - 1] == '(')
depth[i] = depth[i - 1] + 1;
else
depth[i] = depth[i - 1] - 1;
}
vector<int> minpred(n + 1, 0);
for (int i = 1; i <= n; i++) {
minpred[i] = min(depth[i], minpred[i - 1]);
}
vector<int> minpo(n + 1, 1023456789);
for (int i = n - 1; i >= 0; i--) {
minpo[i] = min(depth[i + 1], minpo[i + 1]);
}
vector<bool> can_be(n, 0);
for (int i = 0; i < n; i++) {
if (depth[n] < 0) {
can_be[i] = (minpo[i] - depth[i] >= depth[n] && minpred[i] >= depth[i]);
} else {
can_be[i] = (minpo[i] >= depth[i] && minpred[i] + depth[n] >= depth[i]);
}
}
vector<int> por = utried();
int st = -1;
for (int i = 0; i < n; i++) {
if (can_be[por[i]]) {
st = por[i];
break;
}
}
if (depth[n] < 0) {
for (int i = 0; i < (0 - depth[n]); i++) {
printf("(");
}
}
for (int i = 0; i < n; i++) {
printf("%c", s[(i + st) % n]);
}
if (depth[n] > 0) {
for (int i = 0; i < depth[n]; i++) printf(")");
}
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e9 + 70;
const long long mod = 1e9 + 7;
const int maxn = 2e6 + 1000;
struct SuffixArray {
int n;
string s;
int SA[maxn], tempSA[maxn], RA[maxn], tempRA[maxn];
void countingsort(int k) {
int maxi = max(n, 300);
vector<int> c(maxi);
for (int i = (0); i < (n); i++) {
int v = (i + k < n ? RA[i + k] : 0);
c[v]++;
}
int s = 0;
for (int i = (0); i < (maxi); i++) {
int t = c[i];
c[i] = s;
s += t;
}
for (int j = (0); j < (n); j++) {
int i = SA[j];
int v = (i + k < n ? RA[i + k] : 0);
tempSA[c[v]] = i;
c[v]++;
}
for (int i = (0); i < (n); i++) SA[i] = tempSA[i];
}
void init(string e) {
e = e + "$";
s = e;
n = s.length();
for (int i = (0); i < (n); i++) {
SA[i] = i;
RA[i] = s[i];
}
for (int k = 1; k <= n; k *= 2) {
countingsort(k);
countingsort(0);
for (int j = (0); j < (n); j++) {
int i = SA[j];
if (j == 0) {
tempRA[i] = 0;
continue;
}
int p = SA[j - 1];
if (RA[i] == RA[p] && RA[i + k] == RA[p + k]) {
tempRA[i] = tempRA[p];
} else {
tempRA[i] = tempRA[p] + 1;
}
}
for (int i = (0); i < (n); i++) RA[i] = tempRA[i];
vector<bool> seen(n);
bool done = true;
for (int i = (0); i < (n / 2); i++) {
if (seen[RA[i]]) {
done = false;
break;
}
seen[RA[i]] = true;
}
if (done) {
break;
}
}
}
} Z;
int delta[maxn];
int pre[maxn];
int suf[maxn];
int main() {
if (fopen("i.txt", "r")) freopen("i.txt", "r", stdin);
string s;
cin >> s;
int n = s.length();
delta[0] = 0;
for (int i = (1); i < (n + 1); i++) {
delta[i] = delta[i - 1] + (s[i - 1] == '(' ? 1 : -1);
}
for (int i = (0); i < (n + 3); i++) {
pre[i] = inf;
suf[i] = inf;
}
for (int i = (1); i < (n); i++) {
pre[i] = min(pre[i - 1], delta[i - 1]);
}
for (int i = n - 1; i >= 0; i--) {
suf[i] = min(suf[i + 1], delta[i]);
}
Z.init(s + s);
if (delta[n] >= 0) {
vector<int> options;
for (int i = (0); i < (n); i++) {
int mn = min(pre[i] + delta[n] - delta[i], suf[i] - delta[i]);
if (mn >= 0) {
options.push_back(i);
}
}
int best = options[0];
for (int e : options) {
if (Z.RA[e] < Z.RA[best]) {
best = e;
}
}
cout << s.substr(best) << s.substr(0, best);
for (int i = (0); i < (delta[n]); i++) {
cout << ')';
}
cout << "\n";
} else {
int k = -delta[n];
for (int i = (0); i < (k); i++) {
cout << '(';
}
vector<int> options;
for (int i = (0); i < (n); i++) {
int mn = min(pre[i] + delta[n] - delta[i], suf[i] - delta[i]);
if (mn >= -k) {
options.push_back(i);
}
}
int best = options[0];
for (int e : options) {
if (Z.RA[e] < Z.RA[best]) {
best = e;
}
}
cout << s.substr(best) << s.substr(0, best);
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int maxn = 1000010;
char s[maxn];
int cnt, tran[256], len, x[maxn], y[maxn], c[maxn], sa[maxn], sum[maxn],
l[maxn], r[maxn];
int min(int x, int y) { return x < y ? x : y; }
int main() {
scanf("%s", s);
len = strlen(s);
for (int i = 0; i < len; ++i) {
if (!tran[s[i]]) {
++cnt;
tran[s[i]] = 1;
}
}
for (int i = 0, j = 0; i < 256; ++i)
if (tran[i]) tran[i] = j++;
for (int i = 0; i < len; ++i) ++c[x[i] = tran[s[i]]];
for (int i = 1; i < cnt; ++i) c[i] += c[i - 1];
for (int i = len - 1; i >= 0; --i) sa[--c[x[i]]] = i;
for (int k = 1; k <= len; k <<= 1) {
int tmp = 0;
for (int i = 0; i < len; ++i) y[tmp++] = (sa[i] + len - k) % len;
memset(c, 0, sizeof c);
for (int i = 0; i < len; ++i) ++c[x[y[i]]];
for (int i = 1; i < cnt; ++i) c[i] += c[i - 1];
for (int i = len - 1; i >= 0; --i) sa[--c[x[y[i]]]] = y[i];
memcpy(y, x, sizeof x);
cnt = 1;
x[sa[0]] = 0;
for (int i = 1; i < len; ++i)
if (y[sa[i - 1]] == y[sa[i]] &&
y[(sa[i - 1] + k) % len] == y[(sa[i] + k) % len])
x[sa[i]] = cnt - 1;
else
x[sa[i]] = cnt++;
if (cnt >= len) break;
}
for (int i = 0; i < len; ++i) sum[i + 1] = sum[i] + (s[i] == '(' ? 1 : -1);
l[0] = sum[0];
for (int i = 1; i <= len; ++i) l[i] = min(l[i - 1], sum[i - 1]);
r[len] = sum[len];
for (int i = len - 1; i >= 0; --i) r[i] = min(r[i + 1], sum[i]);
for (int i = 0; i < len; ++i) {
int pos = sa[i];
int now = min(r[pos] - sum[pos], sum[len] - sum[pos] + l[pos]);
if (sum[len] > 0 && now >= 0) {
for (int j = pos; j < len; ++j) putchar(s[j]);
for (int j = 0; j < pos; ++j) putchar(s[j]);
for (int j = 0; j < sum[len]; ++j) putchar(')');
putchar('\n');
break;
} else if (sum[len] <= 0 && now - sum[len] >= 0) {
for (int j = 0; j < -sum[len]; ++j) putchar('(');
for (int j = pos; j < len; ++j) putchar(s[j]);
for (int j = 0; j < pos; ++j) putchar(s[j]);
putchar('\n');
break;
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-6;
struct SuffixArray {
int n;
int ranks[2][2000005], SA[2000005];
string str;
SuffixArray() {}
void Initialize(string s) {
this->str = s;
n = ((int)(s).size());
ComputeRank();
}
void ComputeRank() {
int p = 0;
for (int i = 0; i <= n; i++) {
SA[i] = i;
ranks[p][i] = str[i];
}
for (int k = 1; k <= n; k <<= 1) {
auto compareByKey = [p, k, this](const int &lhs, const int &rhs) -> bool {
int LHS = lhs + k < n ? ranks[p][lhs + k] : -1;
int RHS = rhs + k < n ? ranks[p][rhs + k] : -1;
return LHS < RHS;
};
auto compareByRank = [compareByKey, p, k, this](const int &lhs,
const int &rhs) -> bool {
if (ranks[p][lhs] != ranks[p][rhs])
return ranks[p][lhs] < ranks[p][rhs];
return compareByKey(lhs, rhs);
};
int prev = 0;
if (k > 1) {
for (int i = 1; i <= n; i++)
if (ranks[p][SA[i]] != ranks[p][SA[prev]]) {
sort(SA + prev, SA + i, compareByKey);
prev = i;
}
}
sort(SA + prev, SA + n, compareByRank);
for (int i = 1; i <= n; i++)
ranks[p ^ 1][SA[i]] =
ranks[p ^ 1][SA[i - 1]] + compareByRank(SA[i - 1], SA[i]);
p ^= 1;
}
}
} sa;
int presum[2000005];
int lsum[2000005], rsum[2000005];
int cnt[2000005 << 1];
int main() {
{ ; };
string s;
cin >> s;
int len = ((int)(s).size());
s.append(s);
sa.Initialize(s);
int minn = 2000005;
for (int i = 0; i < len; i++)
presum[i + 1] = presum[i] + (s[i] == '(' ? 1 : -1);
lsum[0] = presum[len];
for (int i = 1; i <= len; i++)
lsum[i] = min(lsum[i - 1], presum[i] + presum[len]);
rsum[len] = presum[len];
for (int i = len - 1; i >= 0; i--) rsum[i] = min(rsum[i + 1], presum[i]);
int score = min(0, presum[len]);
int res = -1;
for (int i = 0; i < len; i++)
if (min(lsum[i], rsum[i]) == score + presum[i])
if (res == -1 || sa.ranks[0][i] <= sa.ranks[0][res]) res = i;
;
for (int j = 0; j < -presum[len]; j++) putchar('(');
printf("%s", s.substr(res, len).c_str());
for (int j = 0; j < presum[len]; j++) putchar(')');
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, N, a[2000005], s[2000005], q[2000005], ql, qr, rec[1000005], ans;
int f[2000005][22];
string in;
int main() {
ios::sync_with_stdio(0);
cin >> in;
n = in.size();
for (int i = 1; i <= n; ++i) {
if (in[i - 1] == '(')
a[i] = a[i + n] = 0;
else
a[i] = a[i + n] = 1;
}
N = n * 2;
for (int i = 1; i <= N; ++i) {
if (a[i] == 0)
s[i] = s[i - 1] + 1;
else
s[i] = s[i - 1] - 1;
}
ql = 1;
for (int i = N; i > n; --i) {
while (qr >= ql && s[q[qr]] >= s[i]) --qr;
q[++qr] = i;
}
for (int i = n; i; --i) {
while (qr >= ql && s[q[qr]] >= s[i]) --qr;
q[++qr] = i;
if (q[ql] == i + n) ++ql;
rec[i] = s[q[ql]] - s[i - 1];
if (s[n] < 0) rec[i] -= s[n];
}
long long o = 2;
for (int i = 1; i <= N; ++i) f[i][0] = a[i];
for (int k = 0; k < 20; ++k) {
for (int i = 1; i <= N - (2 << k) + 1; ++i)
f[i][k + 1] = (f[i][k] * o + f[i + (1 << k)][k]) % 1000000007ll;
o = o * o % 1000000007ll;
}
ans = 0;
for (int i = 1; i <= n; ++i) {
if (rec[i] < 0) continue;
if (!ans) {
ans = i;
continue;
}
int x = ans, y = i, o = 0;
for (int k = 20; k >= 0; --k) {
if (o + (1 << k) > n) continue;
if (f[x][k] == f[y][k]) x += (1 << k), y += (1 << k), o += (1 << k);
}
if (o < n && a[y] < a[x]) ans = i;
}
string out = "";
in += in;
for (int i = ans; i <= ans + n - 1; ++i) out += in[i - 1];
int O = s[n];
if (O > 0) {
cout << out;
while (O > 0) cout << ")", --O;
} else {
while (O < 0) cout << "(", ++O;
cout << out;
}
cout << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char buf[2000002];
struct st {
int open;
int close;
st() { open = close = 0; }
void add_front(char c) {
if (c == '(') {
if (close) {
close--;
} else {
open++;
}
} else {
close++;
}
}
void add_back(char c) {
if (c == '(') {
open++;
} else {
if (open) {
open--;
} else {
close++;
}
}
}
};
st pref[2000002];
st suf[2000002];
st merge(st a, st b) {
int par = min(a.open, b.close);
a.open -= par;
b.close -= par;
st r;
r.open = a.open + b.open;
r.close = a.close + b.close;
return r;
}
string S;
long long int h[2000002][2];
long long int base[] = {1000000007, 1000000009};
long long int up[] = {1231413, 7324125};
long long int mul[2000002][2];
void hash_init() {
mul[0][0] = mul[0][1] = 1;
for (int i = 1; i < 2000002; i++) {
for (int j = 0; j < 2; j++) {
mul[i][j] = mul[i - 1][j];
mul[i][j] *= up[j];
mul[i][j] %= base[j];
}
}
long long int cur[] = {0, 0};
for (int i = 0; i < S.size(); i++) {
for (int j = 0; j < 2; j++) {
cur[j] *= up[j];
cur[j] += S[i];
cur[j] %= base[j];
h[i][j] = cur[j];
}
}
}
pair<long long int, long long int> gett(int a, int b) {
long long int val[] = {h[b][0], h[b][1]};
if (a) {
val[0] -= (h[a - 1][0] * mul[b - a + 1][0]) % base[0];
val[1] -= (h[a - 1][1] * mul[b - a + 1][1]) % base[1];
if (val[0] < 0) val[0] += base[0];
if (val[1] < 0) val[1] += base[1];
}
return make_pair(val[0], val[1]);
}
bool eq(int a, int b, int len) {
if (a > b) swap(a, b);
pair<long long int, long long int> val1 = gett(a, a + len - 1);
pair<long long int, long long int> val2 = gett(b, b + len - 1);
return val1 == val2;
}
bool lexicographically_small(int a, int b) {
if (S[a] != S[b]) return S[a] < S[b];
int mint = 1;
int maxt = S.size() / 2;
while (mint + 1 < maxt) {
int mid = (mint + maxt) >> 1;
if (eq(a, b, mid)) {
mint = mid;
} else {
maxt = mid;
}
}
if (eq(a, b, maxt)) {
mint = maxt;
} else {
maxt = mint;
}
return S[a + mint] < S[b + mint];
}
string ans;
string s;
int main() {
scanf("%s", buf);
s = buf;
S = s + s;
hash_init();
{
st cur;
for (int i = 0; i < s.size(); i++) {
cur.add_back(s[i]);
pref[i] = cur;
}
}
{
st cur;
for (int i = s.size() - 1; i >= 0; i--) {
cur.add_front(s[i]);
suf[i] = cur;
}
}
int MIN_LEN = INT_MAX;
for (int i = 0; i < s.size(); i++) {
st nex = suf[i];
if (i) {
nex = merge(nex, pref[i - 1]);
}
MIN_LEN = min(MIN_LEN, (int)(s.size() + nex.open + nex.close));
}
int max_open = 0;
for (int i = 0; i < s.size(); i++) {
st nex = suf[i];
if (i) {
nex = merge(nex, pref[i - 1]);
}
int len = s.size() + nex.open + nex.close;
if (len == MIN_LEN) {
max_open = max(max_open, nex.close);
}
}
int id = -1;
for (int i = 0; i < s.size(); i++) {
st nex = suf[i];
if (i) {
nex = merge(nex, pref[i - 1]);
}
int len = s.size() + nex.open + nex.close;
if (len != MIN_LEN) {
continue;
}
if (max_open != nex.close) {
continue;
}
if (id == -1) {
id = i;
continue;
}
if (!lexicographically_small(id, i)) {
id = i;
}
}
for (int i = 0; i < max_open; i++) {
ans.push_back('(');
}
ans += s.substr(id, s.size() - id);
if (id) {
ans += s.substr(0, id);
}
while (ans.size() < MIN_LEN) {
ans.push_back(')');
}
printf("%s\n", ans.c_str());
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 4, sz = 1 << 20, inf = 1e9;
struct node {
int c1, c2, id;
node() { c1 = c2 = id = 0; }
node(const int &cc1, const int &cc2, const int &cid) {
c1 = cc1;
c2 = cc2;
id = cid;
}
};
inline bool operator<(const node &lhs, const node &rhs) {
if (lhs.c1 == rhs.c1) return lhs.c2 < rhs.c2;
return lhs.c1 < rhs.c1;
}
inline bool operator==(const node &lhs, const node &rhs) {
return lhs.c1 == rhs.c1 && lhs.c2 == rhs.c2;
}
string s;
vector<node> v;
int c[N];
int t[sz + sz];
int moment[N];
int best = -1;
inline void upd(int x, const int &delta) {
t[x += sz] = delta;
while (x >>= 1) t[x] = min(t[x << 1], t[(x << 1) | 1]);
}
inline int get(int l, int r) {
int res = inf;
for (l += sz, r += sz; l <= r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (!(r & 1)) res = min(res, t[r--]);
}
return res;
}
int main() {
ios_base ::sync_with_stdio(0);
cin >> s;
int n = s.size();
v.resize(n);
for (int i = 0; i < n; ++i) v[i] = node(s[i], s[i], i);
sort(v.begin(), v.end());
int cnt = 0;
c[v[0].id] = ++cnt;
for (int i = 1; i < n; ++i)
if (v[i] == v[i - 1])
c[v[i].id] = c[v[i - 1].id];
else
c[v[i].id] = ++cnt;
for (int k = 0; (1 << k) <= n; ++k) {
for (int i = 0; i < n; ++i) v[i] = node(c[i], c[(i + (1 << k)) % n], i);
sort(v.begin(), v.end());
cnt = 0;
c[v[0].id] = ++cnt;
for (int i = 1; i < n; ++i)
if (v[i] == v[i - 1])
c[v[i].id] = c[v[i - 1].id];
else
c[v[i].id] = ++cnt;
}
int balance = 0;
for (int i = 0; i < n; ++i) {
balance += (s[i] == ')' ? -1 : +1);
moment[i] = balance;
upd(i, balance);
}
for (int i = 0; i < n; ++i) {
if (i == 0 && (max(0, -balance) + get(0, n - 1) < 0))
continue;
else if (((-moment[i - 1] + get(i, n - 1) + max(0, -balance) < 0) ||
(-moment[i - 1] + moment[n - 1] + get(0, i - 1) +
max(0, -balance) <
0)))
continue;
if (best == -1 || c[best] > c[i]) best = i;
}
while (balance < 0) {
cout << "(";
++balance;
}
for (int j = best; j < n; ++j) cout << s[j];
for (int j = 0; j < best; ++j) cout << s[j];
while (balance > 0) {
cout << ")";
--balance;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};
using namespace std;
char s[2234567];
char ans[2234567 * 2];
int n;
long long hs[2234567], base[2234567];
void makehash() {
hs[0] = 0;
base[0] = 1;
for (int i = 1; i <= int(n * 2); ++i)
base[i] = base[i - 1] * 2 % 1000000007ll,
hs[i] = (hs[i - 1] * 2 + (s[i] == '(' ? 0 : 1)) % 1000000007ll;
}
inline long long geths(int i, int len) {
return (hs[i + len - 1] - hs[i - 1] * base[len] % 1000000007ll +
1000000007ll) %
1000000007ll;
}
inline int lp(int u, int v) {
int l = 0, r = n;
while (l < r) {
int m = (l + r + 1) >> 1;
if (geths(u, m) == geths(v, m))
l = m;
else
r = m - 1;
}
return l;
}
inline bool cmp(const int &x, const int &y) {
int l = lp(x, y);
return s[x + l] < s[y + l];
}
int a[2234567];
int Main() {
ios_base::sync_with_stdio(0);
scanf("%s", s + 1);
n = strlen(s + 1);
int cnt = 0;
for (int i = 1; i <= int(n); ++i) {
if (s[i] == '(')
cnt++;
else
cnt--;
s[i + n] = s[i];
}
int need = cnt >= 0 ? 0 : -cnt;
makehash();
set<pair<int, int> > st;
int now = 0;
int pre = 0;
int can = 0;
for (int i = 1; i <= int(n * 2 - 1); ++i) {
if (s[i] == '(')
now++;
else
now--;
a[i] = now;
st.insert({a[i], i});
if (i > n) {
if (s[i - n] == '(')
pre++;
else
pre--;
st.erase({a[i - n], i - n});
}
if (i >= n && st.begin()->first - pre + need >= 0) {
if (can == 0 || cmp(i - n + 1, can)) can = i - n + 1;
}
}
int u = 0;
if (cnt > 0) {
for (int i = 0; i < int(n); ++i) ans[u++] = s[can + i];
for (int i = 0; i < int(cnt); ++i) ans[u++] = ')';
} else {
for (int i = 0; i < int(-cnt); ++i) ans[u++] = '(';
for (int i = 0; i < int(n); ++i) ans[u++] = s[can + i];
}
ans[u] = '\0';
puts(ans);
return 0;
}
int main() { return Main(); }
| 7 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
clock_t __stt;
inline void TStart() { __stt = clock(); }
inline void TReport() {
printf("\nTaken Time : %.3lf sec\n",
(double)(clock() - __stt) / CLOCKS_PER_SEC);
}
template <typename T>
T MIN(T a, T b) {
return a < b ? a : b;
}
template <typename T>
T MAX(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T ABS(T a) {
return a > 0 ? a : (-a);
}
template <typename T>
void UMIN(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void UMAX(T &a, T b) {
if (b > a) a = b;
}
char s[1000005];
bool a[1000005];
int n, sum, pr[1000005], sf[1000005];
int mnpr[1000005], mxsf[1000005];
bool ok[1000005];
namespace SA {
int n, cnt[1000005], rk[2000005], vy[1000005], ls[1000005], tmp[1000005];
void bsort() {
int i;
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < n; ++i) ++cnt[vy[i]];
for (i = 1; i <= n + 3 || i <= 30; ++i) cnt[i] += cnt[i - 1];
for (i = n - 1; i >= 0; --i) tmp[--cnt[vy[i]]] = i;
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < n; ++i) ++cnt[rk[tmp[i]]];
for (i = 1; i <= n + 3 || i <= 30; ++i) cnt[i] += cnt[i - 1];
for (i = n - 1; i >= 0; --i) ls[--cnt[rk[tmp[i]]]] = tmp[i];
memset(tmp, 0, sizeof(tmp));
}
void getsa() {
int i, j, cv;
memset(rk, 0, sizeof(rk));
memset(vy, 0, sizeof(vy));
for (i = 0; i < n; ++i) {
rk[i] = !a[i];
}
for (i = 2; i <= n * 2; i <<= 1) {
for (j = 0; j < n; ++j) {
vy[j] = rk[(j + (i >> 1)) % n];
}
bsort();
cv = 1;
for (j = 0; j < n; ++j) {
if (j && (rk[ls[j - 1]] != rk[ls[j]] || vy[ls[j - 1]] != vy[ls[j]])) ++cv;
tmp[ls[j]] = cv;
}
memcpy(rk, tmp, sizeof(tmp));
}
}
} // namespace SA
int main() {
int i, j, k;
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; ++i) {
a[i] = (s[i] == '(');
pr[i] = sf[i] = (a[i] ? 1 : -1);
sum += pr[i];
}
for (i = 1; i < n; ++i) pr[i] += pr[i - 1];
for (i = n - 2; i >= 0; --i) sf[i] += sf[i + 1];
for (i = 0; i < n; ++i) mnpr[i] = MIN((i ? mnpr[i - 1] : 2000000000), pr[i]);
for (i = n - 1; i >= 0; --i)
mxsf[i] = MAX((i == n - 1 ? -2000000000 : mxsf[i + 1]), sf[i]);
SA::n = n;
SA::getsa();
if (sum <= 0) {
for (i = 1; i < n; ++i) {
if (mxsf[i] + pr[i - 1] <= 0 && pr[i - 1] - mnpr[i - 1] <= 0) {
ok[i] = 1;
}
}
if (mxsf[0] <= 0) ok[0] = 1;
for (i = 0; i < n; ++i) {
if (ok[SA::ls[i]]) {
for (j = 0; j < -sum; ++j) {
printf("(");
}
for (j = 0; j < n; ++j) {
printf("%c", s[(SA::ls[i] + j) % n]);
}
printf("\n");
return 0;
}
}
} else {
for (i = 1; i < n; ++i) {
if (mnpr[i - 1] + sf[i] >= 0 && sf[i] - mxsf[i] >= 0) {
ok[i] = 1;
}
}
if (mnpr[n - 1] >= 0) ok[0] = 1;
for (i = 0; i < n; ++i) {
if (ok[SA::ls[i]]) {
for (j = 0; j < n; ++j) {
printf("%c", s[(SA::ls[i] + j) % n]);
}
for (j = 0; j < sum; ++j) {
printf(")");
}
printf("\n");
return 0;
}
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s[1111111];
int t[2222222], sa[2222222], lcp[2222222], buc[2222222], arr[2222222], k,
rnk[2222222], n, cur, tmp[2222222], res, x, y, dp[2222222];
const int ct = 2;
int pre[2222222], suf[2222222], mpre[2222222], msuf[2222222];
bool cmp(int i, int j) {
int ri = i + k < n ? rnk[i + k] : -1;
int rj = j + k < n ? rnk[j + k] : -1;
return (rnk[i] == rnk[j] && ri == rj);
}
void make_sa() {
for (int i = 0; i < ct; i++) buc[i] = 0;
for (int i = 0; i < n; i++) buc[t[i]]++;
for (int i = 1; i < ct; i++) buc[i] += buc[i - 1];
for (int i = 0; i < n; i++) sa[--buc[t[i]]] = i;
for (int i = 0; i < n; i++) rnk[i] = t[i];
for (k = 1; k <= n; k *= 2) {
cur = 0;
for (int i = n - k; i < n; i++) arr[cur++] = i;
for (int i = 0; i < n; i++) {
if (sa[i] >= k) arr[cur++] = sa[i] - k;
}
for (int i = 0; i < n; i++) buc[i] = 0;
for (int i = 0; i < n; i++) buc[rnk[i]]++;
for (int i = 1; i < n; i++) buc[i] += buc[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--buc[rnk[arr[i]]]] = arr[i];
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
if (cmp(sa[i - 1], sa[i]))
tmp[sa[i]] = tmp[sa[i - 1]];
else
tmp[sa[i]] = tmp[sa[i - 1]] + 1;
}
for (int i = 0; i < n; i++) rnk[i] = tmp[i];
}
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < 2 * n; i++) {
if (i >= n) {
if (s[i - n] == '(')
t[i] = 0;
else
t[i] = 1;
} else {
if (s[i] == '(')
t[i] = 0;
else
t[i] = 1;
}
}
for (int i = 0; i < n; i++) pre[i] = pre[i - 1] + (t[i] ? -1 : 1);
for (int i = n - 1; i >= 0; i--) suf[i] = suf[i + 1] + (t[i] ? -1 : 1);
for (int i = 0; i < n; i++) {
mpre[i] = min(mpre[i - 1], pre[i]);
}
for (int i = n - 1; i >= 0; i--) {
msuf[i] = min(msuf[i + 1] + (t[i] ? -1 : 1), (t[i] ? -1 : 1));
}
for (int i = 0; i < n; i++) {
dp[i] = min(msuf[i], suf[i] + mpre[i - 1]);
}
n *= 2;
make_sa();
n /= 2;
for (int i = 0; i < n; i++) {
if (s[i] == '(')
x++;
else
y++;
}
if (x < y) {
for (int i = 0; i < n; i++) dp[i] += (y - x);
}
for (int i = 0; i < 2 * n; i++) {
if (sa[i] < n && dp[sa[i]] >= 0) {
res = sa[i];
break;
}
}
for (int i = x; i < y; i++) putchar('(');
for (int i = res; i < res + n; i++) {
if (!t[i])
putchar('(');
else
putchar(')');
}
for (int i = y; i < x; i++) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2111111;
char buf[maxn];
int sum[maxn];
bool ok[maxn];
int order[maxn];
template <typename T>
void debug(T a[], int n) {
for (int i = 1; i <= n; ++i) {
cout << setw(3) << a[i];
}
puts("");
}
void fix(int& i, int n) {
while (!ok[i] && i <= n) {
++i;
}
}
int run(char s[], int m) {
int n = m >> 1;
int i = 1, j = 2, k = 0;
fix(i, n);
j = i + 1;
fix(j, n);
while (j <= n) {
for (k = 0; k < n; ++k) {
if (s[i + k] ^ s[j + k]) {
break;
}
}
if (s[i + k] > s[j + k]) {
i += k + 1;
fix(i, n);
} else {
j += k + 1;
fix(j, n);
}
if (j == i) {
++j;
fix(j, n);
}
}
return std::min(i, j);
}
int main() {
for (int i = 1; i < 100; ++i) {
order[i] = i;
}
scanf("%s", buf + 1);
int n = std::strlen(buf + 1);
int A, B;
A = B = 0;
for (int i = 1; i <= n; ++i) {
buf[i + n] = buf[i];
if (buf[i] == '(') {
++A;
} else {
++B;
}
}
int m = n << 1;
for (int i = 1; i <= m; ++i) {
if (buf[i] == '(') {
sum[i] = 1;
} else {
sum[i] = -1;
}
sum[i] += sum[i - 1];
}
static int q[maxn];
int front, rear;
front = rear = 0;
static int min[maxn];
int add = 0;
if (A < B) {
add = B - A;
}
for (int i = 1; i <= m; ++i) {
if (front < rear && q[front] + n <= i) {
++front;
}
while (front < rear && sum[q[rear - 1]] >= sum[i]) {
--rear;
}
q[rear++] = i;
min[i] = sum[q[front]];
}
for (int i = 1; i <= n; ++i) {
if (add + min[i + n - 1] >= sum[i - 1]) {
ok[i] = true;
}
}
int index = run(buf, m);
auto print = [](char ch, int n) {
while (n--) {
putchar(ch);
}
};
if (A < B) {
print('(', B - A);
}
for (int i = index; i < index + n; ++i) {
putchar(buf[i]);
}
if (B < A) {
print(')', A - B);
}
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T Dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
long long Bigmod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
long long ModInverse(long long number, long long MOD) {
return Bigmod(number, MOD - 2, MOD);
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Chkbit(int N, int pos) { return (bool)(N & (1 << pos)); }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
long long int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
const int N = int(2e6) + 15;
int cmp(int *r, int a, int b, int l) {
return (r[a] == r[b]) && (r[a + l] == r[b + l]);
}
int wa[N], wb[N], wws[N], wv[N];
int rnk[N], height[N];
void DA(int *r, int *sa, int n, int m) {
int i, j, p, *x = wa, *y = wb, *t;
for (i = 0; i < m; i++) wws[i] = 0;
for (i = 0; i < n; i++) wws[x[i] = r[i]]++;
for (i = 1; i < m; i++) wws[i] += wws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--wws[x[i]]] = i;
for (j = 1, p = 1; p < n; j *= 2, m = p) {
for (p = 0, i = n - j; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) wv[i] = x[y[i]];
for (i = 0; i < m; i++) wws[i] = 0;
for (i = 0; i < n; i++) wws[wv[i]]++;
for (i = 1; i < m; i++) wws[i] += wws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--wws[wv[i]]] = y[i];
for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
void calheight(int *r, int *sa, int n) {
int i, j, k = 0;
for (i = 1; i <= n; i++) rnk[sa[i]] = i;
for (i = 0; i < n; height[rnk[i++]] = k)
for (k ? k-- : 0, j = sa[rnk[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
int sa[N], data[N], n;
void Deal() {
DA(data, sa, n + 1, 128);
calheight(data, sa, n);
}
char s[2000002];
int Len;
struct z {
int opn, cls;
};
z Tree[2000002 * 4];
void Update(int id, int l, int r, int pos) {
if (l == r) {
if (s[pos] == '(') {
Tree[id].opn = 1;
} else
Tree[id].cls = 1;
return;
}
int mid = (l + r) / 2;
int lft = 2 * id;
int rgt = lft + 1;
if (pos <= mid) {
Update(lft, l, mid, pos);
} else {
Update(rgt, mid + 1, r, pos);
}
int mn = min(Tree[lft].opn, Tree[rgt].cls);
Tree[id].cls = Tree[lft].cls + Tree[rgt].cls - mn;
Tree[id].opn = Tree[rgt].opn + Tree[lft].opn - mn;
return;
}
z Query(int id, int l, int r, int st, int ed) {
if (st <= l && ed >= r) {
return Tree[id];
}
int mid = (l + r) / 2;
int lft = 2 * id;
int rgt = lft + 1;
if (ed <= mid) {
return Query(lft, l, mid, st, ed);
} else if (st > mid) {
return Query(rgt, mid + 1, r, st, ed);
} else {
z a, b, c;
a = Query(lft, l, mid, st, ed);
b = Query(rgt, mid + 1, r, st, ed);
int mn = min(a.opn, b.cls);
c.cls = a.cls + b.cls - mn;
c.opn = b.opn + a.opn - mn;
return c;
}
}
int dp[2000002], Close[2000002], len, dp1[2000002];
void Solve() {
int Last = -1, Last1 = -1;
for (int i = Len + 1 - 1; i >= 1; i--) {
if (s[i] == ')')
Last = -1;
else if (Last == -1) {
Last = i;
}
dp[i] = (Last == -1 ? 0 : (Last - i + 1));
if (s[i] == '(')
Last1 = -1;
else if (Last1 == -1) {
Last1 = i;
}
dp1[i] = (Last1 == -1 ? 0 : (Last1 - i + 1));
}
}
int A[4 * 2000002];
void Update(int id, int l, int r, int pos, int val) {
if (l == r) {
A[id] = height[pos];
return;
}
int mid = (l + r) / 2;
int lft = 2 * id;
int rgt = lft + 1;
if (pos <= mid) {
Update(lft, l, mid, pos, val);
} else {
Update(rgt, mid + 1, r, pos, val);
}
A[id] = min(A[lft], A[rgt]);
return;
}
int Lcp(int id, int l, int r, int st, int ed) {
if (st <= l && ed >= r) {
return A[id];
}
int mid = (l + r) / 2;
int lft = 2 * id;
int rgt = lft + 1;
if (ed <= mid) {
return Lcp(lft, l, mid, st, ed);
} else if (st > mid) {
return Lcp(rgt, mid + 1, r, st, ed);
} else {
int a, b;
a = Lcp(lft, l, mid, st, ed);
b = Lcp(rgt, mid + 1, r, st, ed);
return min(a, b);
}
}
int HandleJhamela(int id, int id1, int Opn, int mx) {
int Suru = id + min(len, dp[id]), Suru1 = id1 + min(len, dp[id1]);
int Rnk = rnk[Suru - 1], Rnk1 = rnk[Suru1 - 1];
int L1 = len + mx - Opn - Close[id], L2 = len + mx - Opn - Close[id1];
int f = 0;
if (Rnk > Rnk1) swap(Rnk, Rnk1), f = 1;
int lcp = Lcp(1, 1, n, Rnk + 1, Rnk1);
if (f) swap(Rnk, Rnk1);
if (lcp >= min(L1, L2)) {
int diff = abs(L2 - L1);
if (L1 < L2) {
if (dp1[id1 + min(len, dp[id1]) + lcp] < diff)
return id1;
else
return id;
} else {
if (dp1[id + min(len, dp[id]) + lcp] < diff)
return id;
else
return id1;
}
} else {
if (Rnk < Rnk1)
return id;
else
return id1;
}
}
int main() {
n = 0;
scanf("%s", &s);
len = strlen(s);
for (int i = len + 1 - 1; i >= 1; i--) s[i] = s[i - 1];
Len = len * 2;
for (int i = len + 1; i < Len + 1; i++) s[i] = s[i - len];
Solve();
for (int i = 1; i < Len + 1; i++) {
Update(1, 1, Len, i);
data[n] = (int)s[i];
n++;
}
data[n] = 0;
Deal();
for (int i = 1; i < n; i++) Update(1, 1, n, i, height[i]);
int mx = (1 << 28), Open = 0, Id = 0;
for (int i = 1; i < len + 1; i++) {
z ans = Query(1, 1, Len, i, (i + len - 1));
int Cst = ans.cls + ans.opn;
Close[i] = ans.opn;
int CntOpn = ans.cls + (min(len, dp[i]));
if (mx > Cst) {
mx = Cst;
Open = CntOpn;
Id = i;
} else if (mx == Cst && CntOpn > Open) {
Open = CntOpn;
Id = i;
} else if (mx == Cst && CntOpn == Open) {
Id = HandleJhamela(Id, i, CntOpn, mx);
}
}
for (int i = 0; i < Open; i++) {
printf("(");
}
int baki = len + mx - Open - Close[Id];
int St = Id + dp[Id];
for (int i = 0; i < baki; i++) {
printf("%c", s[St + i]);
}
for (int i = 0; i < Close[Id]; i++) {
printf(")");
}
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using std::bitset;
using std::cin;
using std::cout;
using std::endl;
using std::make_pair;
using std::map;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
class MyTimer {
public:
void reset() {}
void report() {}
} myTimer;
template <typename A, typename B>
std::ostream &operator<<(std::ostream &cout, const pair<A, B> &x) {
return cout << "(" << x.first << ", " << x.second << ")";
}
template <typename T1, typename T2>
inline bool chmin(T1 &a, const T2 &b) {
return a > b ? a = b, true : false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, const T2 &b) {
return a < b ? a = b, true : false;
}
const int maxN = 2000000 + 233;
int n;
int a[maxN], s[maxN], pmin[maxN];
void initialize() {
static char str[maxN];
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; ++i) a[i] = (str[i] == '(' ? 1 : -1);
for (int i = n + 1; i <= 2 * n; ++i) a[i] = a[i - n];
s[0] = 0;
for (int i = 1; i <= 2 * n; ++i) s[i] = s[i - 1] + a[i];
static int q[maxN];
int f = 1, r = 0;
q[r = 1] = 0;
for (int i = 1; i <= n * 2; ++i) {
while (f <= r && s[q[r]] >= s[i]) --r;
q[++r] = i;
while (q[f] < i - n) ++f;
pmin[i] = s[q[f]];
}
for (int i = 1; i <= n; ++i) pmin[i] = pmin[i + n - 1] - s[i - 1];
;
;
}
int buc[maxN * 2], cub[maxN * 2], c[maxN];
int sa[maxN], rk[maxN], h[maxN];
void get_sa(int m) {
int n = ::n * 2;
memset(buc, -1, sizeof(buc));
memset(cub, -1, sizeof(cub));
int *x = buc, *y = cub;
for (int i = 0; i < m; ++i) c[i] = 0;
for (int i = 0; i < n; ++i) c[x[i] = (a[i + 1] == -1 ? '0' : '1')]++;
for (int i = 1; i < m; ++i) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; --i) sa[--c[x[i]]] = i;
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (int i = n - k; i < n; ++i) y[p++] = i;
for (int i = 0; i < n; ++i)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (int i = 0; i < m; ++i) c[i] = 0;
for (int i = 0; i < n; ++i) c[x[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];
std::swap(x, y);
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] + k] == y[sa[i - 1] + k]
? p - 1
: p++;
}
if (p == n) break;
m = p;
}
for (int i = 0; i < n; ++i) rk[i] = x[i];
}
void solve() {
get_sa(100);
int best = 1;
for (int i = 2; i <= n; ++i) {
if (pmin[best] < pmin[i])
best = i;
else if (pmin[best] == pmin[i]) {
if (rk[best - 1] < rk[i - 1]) best = i;
}
}
for (int i = 0; i < -pmin[best]; ++i) putchar('(');
for (int i = best; i < best + n; ++i) putchar(a[i] == -1 ? ')' : '(');
for (int i = 0; i < s[n] - pmin[best]; ++i) putchar(')');
putchar(10);
}
int main() {
initialize();
solve();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 2000010;
char A[NMax];
int N, can[NMax], H[NMax], min1[NMax], min2[NMax], H1[NMax];
int main() {
scanf("%s", A);
N = strlen(A);
int last = 0;
for (int i = 0; i < N; i++) A[N + i] = A[i];
for (int i = 0; i < N; i++) {
if (A[i] == '(')
H[i] = last + 1;
else
H[i] = last - 1;
last = H[i];
}
min1[0] = H[0];
for (int i = 1; i < N; i++) min1[i] = min(min1[i - 1], H[i]);
min2[N - 1] = H[N - 1];
for (int i = N - 2; i >= 0; i--) min2[i] = min(min2[i + 1], H[i]);
for (int i = 0; i < N; i++)
if (A[i] == '(') {
int flag = 1;
int delta = -1;
if (A[i] == '(') delta = 1;
if (min2[i] - H[i] + delta < 0) flag = 0;
if (i > 0 && min1[i - 1] + H[N - 1] - H[i] + delta < 0) flag = 0;
if (H[N - 1] > 0) can[i] = flag;
}
for (int i = 0; i < N; i++)
if (H[N - 1] == 0) can[i] = 1;
last = 0;
for (int i = N - 1; i >= 0; i--) {
if (A[i] == ')')
H1[N - i - 1] = last + 1;
else
H1[N - i - 1] = last - 1;
last = H1[N - i - 1];
}
min1[0] = H1[0];
for (int i = 1; i < N; i++) min1[i] = min(min1[i - 1], H1[i]);
min2[N - 1] = H1[N - 1];
for (int i = N - 2; i >= 0; i--) min2[i] = min(min2[i + 1], H1[i]);
for (int i = 0; i < N; i++)
if (A[N - i - 1] == ')') {
int flag = 1;
int delta = -1;
if (A[N - i - 1] == ')') delta = 1;
if (min2[i] - H1[i] + delta < 0) flag = 0;
if (i > 0 && min1[i - 1] + H1[N - 1] - H1[i] + delta < 0) flag = 0;
if (H[N - 1] < 0) can[(N - (i - 1 + N) % N - 1 + N) % N] = flag;
}
for (int i = 0; i < N; i++) can[i + N] = can[i];
int p1 = 0, p2 = 1, pos = -1;
while (p1 < 2 * N && !can[p1]) p1 = p1 + 1;
p2 = p1 + 1;
while (p2 < 2 * N && !can[p2]) p2 = p2 + 1;
while (p1 < N && p2 < N) {
if (A[p2] > A[p1]) {
p2 = p2 + 1;
while (p2 < 2 * N && !can[p2]) p2 = p2 + 1;
} else if (A[p2] < A[p1]) {
p1 = p2;
p2 = p2 + 1;
while (p2 < 2 * N && !can[p2]) p2 = p2 + 1;
} else {
int k = 1;
while (k < 2 * N && A[p1 + k] == A[p2 + k]) k++;
if (A[p1 + k] > A[p2 + k]) {
p1 = p1 + k + 1;
while (p1 < 2 * N && !can[p1]) p1 = p1 + 1;
} else {
p2 = p2 + k + 1;
while (p2 < 2 * N && !can[p2]) p2 = p2 + 1;
}
}
if (p1 == p2) {
p2 = p1 + 1;
while (p2 < 2 * N && !can[p2]) p2 = p2 + 1;
} else if (p1 > p2)
swap(p1, p2);
}
pos = p2;
if (p1 < p2) pos = p1;
if (pos >= N) pos -= N;
if (H[N - 1] > 0) {
printf("%c", A[pos]);
for (int i = (pos + 1) % N; i != pos; i = (i + 1) % N) printf("%c", A[i]);
while (H[N - 1]--) printf(")");
} else {
while (H[N - 1]++) printf("(");
printf("%c", A[pos]);
for (int i = (pos + 1) % N; i != pos; i = (i + 1) % N) printf("%c", A[i]);
}
puts("");
getchar();
getchar();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
int n, s[N], L[N];
char str[N], res[N];
int sa[N], t1[N], t2[N], c[N];
void buildsa(char *s, int n, int m) {
int i, k, p, a1, a2, *x = t1, *y = t2;
memset(c, 0, m << 2);
for (i = 0; i < n; ++i) ++c[x[i] = s[i]];
for (i = 1; i < m; ++i) c[i] += c[i - 1];
for (i = n - 1; i >= 0; --i) sa[--c[x[i]]] = i;
for (k = 1; k < n; k <<= 1) {
p = 0;
for (i = 0; i < n; ++i) y[p++] = (sa[i] + n - k) % n;
memset(c, 0, m << 2);
for (i = 0; i < n; ++i) ++c[x[y[i]]];
for (i = 1; i < m; ++i) c[i] += c[i - 1];
for (i = n - 1; i >= 0; --i) sa[--c[x[y[i]]]] = y[i];
swap(x, y), p = 1, x[sa[0]] = 0;
for (i = 1; i < n; ++i) {
a1 = y[(sa[i - 1] + k) % n];
a2 = y[(sa[i] + k) % n];
x[sa[i]] = (a1 == a2 && y[sa[i - 1]] == y[sa[i]]) ? p - 1 : p++;
}
if (p >= n) break;
m = p;
}
}
int Q[N], top, bot;
int m;
void work() {
int i, j, y;
char c;
while (c = getchar(), ~c && c != '\n') str[n++] = c;
for (i = n; i < n + n; ++i) str[i] = str[i - n];
for (i = 0; i < n + n; ++i) s[i + 1] = s[i] + (str[i] == '(' ? 1 : -1);
m = n;
buildsa(str, m, 128);
top = 0, bot = -1;
for (i = 1; i <= n + n; ++i) {
while (top <= bot && Q[top] < i - n + 1) ++top;
while (top <= bot && s[i] <= s[Q[bot]]) --bot;
Q[++bot] = i;
if (i >= n) L[i - n] = s[Q[top]];
}
y = min(s[n], 0);
for (i = 0; i < m; ++i) {
j = sa[i];
if (j >= n) continue;
if (L[j] >= s[j] + y) break;
}
m = 0;
for (i = 0; i < -s[n]; ++i) res[m++] = '(';
for (i = 0; i < n; ++i) res[m++] = str[i + j];
for (i = 0; i < s[n]; ++i) res[m++] = ')';
puts(res);
}
int main() {
work();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 100;
int na[N], nb[N], ns[N], nv[N];
int sa[N], he[N], rk[N];
int cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
void _sort(int x[N], int y[N], int n, int m) {
for (int i = 0; i < m; i++) ns[i] = 0;
for (int i = 0; i < n; i++) ns[x[y[i]]]++;
for (int i = 1; i < m; i++) ns[i] += ns[i - 1];
for (int i = n - 1; i >= 0; i--) {
sa[--ns[x[y[i]]]] = y[i];
}
}
void da(int *r, int n, int m) {
int *x = na, *y = nb;
for (int i = 0; i < n; i++) x[i] = r[i];
for (int i = 0; i < n; i++) y[i] = i;
_sort(x, y, n, m);
for (int j = 1, p = 1, i; p < n; j *= 2, m = p) {
for (p = 0, i = n - j; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) nv[i] = x[y[i]];
for (i = 0; i < m; i++) ns[i] = 0;
for (i = 0; i < n; i++) ns[nv[i]]++;
for (i = 1; i < m; i++) ns[i] += ns[i - 1];
for (i = n - 1; i >= 0; i--) sa[--ns[nv[i]]] = y[i];
swap(x, y);
p = 1;
x[sa[0]] = 0;
for (i = 1; i < n; i++) {
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
}
void gethe(int *r, int n) {
for (int i = 1; i <= n; i++) rk[sa[i]] = i;
for (int i = 0, k = 0, j = 0; i < n; he[rk[i++]] = k) {
for (k ? k-- : 0, j = sa[rk[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
}
void debug(int n) {
for (int i = 0; i <= n; i++) printf("%d ", rk[i]);
printf("rk\n");
for (int i = 0; i <= n; i++) printf("%d ", sa[i]);
printf("sa\n");
for (int i = 0; i <= n; i++) printf("%d ", he[i]);
printf("he\n");
}
void solve(int *r, int n) {
r[n] = 0;
da(r, n + 1, 3);
gethe(r, n);
}
int l, r, sta[N];
int aa[N], bb[N];
void ins(int id) {
while (r > l && aa[sta[r - 1]] >= aa[id]) r--;
sta[r++] = id;
}
char ss[N];
int vis[N];
int main() {
while (scanf("%s", ss) != EOF) {
int n = strlen(ss);
int num = 0;
for (int i = 0; i < n; i++) {
if (ss[i] == '(') {
aa[i] = 1;
bb[i] = 1;
num++;
} else {
aa[i] = -1;
bb[i] = 2;
num--;
}
}
for (int i = 0; i < n; i++) {
aa[i + n] = aa[i];
bb[i + n] = bb[i];
}
for (int i = 1; i < 2 * n; i++) {
aa[i] += aa[i - 1];
}
memset(vis, 0, sizeof(vis));
l = r = 0;
for (int i = 0; i < n; i++) {
ins(i);
}
for (int i = 0; i < n; i++) {
if (sta[l] < i) l++;
int x = aa[sta[l]];
if (i) x -= aa[i - 1];
if (num < 0) {
x += -num;
}
if (x >= 0) {
vis[i] = 1;
}
ins(i + n);
}
solve(bb, n * 2);
int id = -1;
for (int i = 0; i < n; i++)
if (vis[i]) {
if (id == -1 || rk[i] < rk[id]) {
id = i;
}
}
if (id == -1) {
printf("x\n");
continue;
}
for (int i = 0; i < -num; i++) {
printf("(");
}
for (int i = 0; i < n; i++) {
printf("%c", ss[id]);
id++;
if (id == n) id = 0;
}
for (int i = 0; i < num; i++) {
printf(")");
}
printf("\n");
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
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], op[N], zp[N],
os[N], zs[N], il[N], ir[N];
vector<int> st;
int get(int i, int ln) {
int ans, l1, l, r, ym;
l1 = min(il[i], 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) {
if (ln <= il[i]) return '(';
ln -= il[i];
if (ln <= n - i) return s[i + ln];
ln -= n - i;
if (ln <= i)
return s[ln];
else
return ')';
}
int ans;
bool cmp(int i, int j) {
int l, r, x;
l = 1, r = ans;
while (l <= r) {
x = (l + r) >> 1;
if (get(i, x) == get(j, x))
l = x + 1;
else
r = x - 1;
}
if (r + 1 > ans) return true;
return get_ch(i, r + 1) <= get_ch(j, r + 1);
}
int main() {
if (0) {
freopen("input.txt", "w", stdout);
int n = 1e6;
for (int i = 0; i < n; ++i) printf("(");
printf("\n");
return 0;
}
int i, j, len, mn;
gets(s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; ++i)
if (s[i] == '(')
p1[i] = p1[i - 1], p2[i] = p2[i - 1] + 1;
else if (p2[i - 1])
p1[i] = p1[i - 1] + 2, p2[i] = p2[i - 1] - 1;
else
p1[i] = p1[i - 1], p2[i] = p2[i - 1];
for (i = n; i; --i)
if (s[i] == ')')
s1[i] = s1[i + 1], s2[i] = s2[i + 1] + 1;
else if (s2[i + 1])
s1[i] = s1[i + 1] + 2, s2[i] = s2[i + 1] - 1;
else
s1[i] = s1[i + 1], s2[i] = s2[i + 1];
for (i = 0; i <= n; ++i) {
op[i] = p2[i];
zp[i] = i - p1[i] - op[i];
zs[i] = s2[i + 1];
os[i] = n - i - s1[i + 1] - zs[i];
il[i] = zs[i];
ir[i] = op[i];
if (os[i] > zp[i])
ir[i] += os[i] - zp[i];
else
il[i] += zp[i] - os[i];
}
ans = oo;
for (i = 0; i < n; ++i) {
len = n + zs[i] + op[i] + max(os[i], zp[i]) - min(os[i], zp[i]);
if (ans > len) st.clear();
if (ans >= len) ans = len, st.push_back(i);
}
stp[0] = 1;
for (i = 1; i < M; ++i) stp[i] = (stp[i - 1] * 1LL * OS) % MOD;
ho[0] = hz[0] = 0;
for (i = 1; i < N; ++i)
ho[i] = (ho[i - 1] + '(' * 1LL * stp[i - 1] % MOD) % MOD;
for (i = 1; i < N; ++i)
hz[i] = (hz[i - 1] + ')' * 1LL * stp[i - 1] % MOD) % MOD;
h[0] = 0;
for (i = 1; i <= n; ++i)
h[i] = (h[i - 1] + s[i] * 1LL * stp[i - 1] % MOD) % MOD;
mn = st[0];
for (i = 1; i < st.size(); ++i)
if (cmp(st[i], mn)) mn = st[i];
i = mn;
for (j = 0; j < il[i]; ++j) putchar('(');
for (j = i + 1; j <= n; ++j) putchar(s[j]);
for (j = 1; j <= i; ++j) putchar(s[j]);
for (j = 0; j < ir[i]; ++j) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
static unsigned rnd() {
static int second = 124612741;
second ^= second << 13;
second ^= second >> 17;
return second ^= second << 5;
}
inline int fpow(int a, int st, int mod) {
int ans = 1;
while (st) {
if (st % 2) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
st /= 2;
}
return ans;
}
int invmod(int first, int second) {
int a = 1, b = 0, k;
for (; second; swap(first, second), swap(a, b)) {
k = first / second;
first -= second * k;
a -= b * k;
}
return a + max(b, 0);
}
struct Hash {
Hash() : x1(0), x2(0) {}
Hash(const int& x1, const int& x2) : x1(x1), x2(x2) {}
int x1, x2;
static int mod1, mod2;
static int p1, p2;
static int invp1, invp2;
static bool initCalled;
static const Hash ONE, ZERO, INVALID;
static Hash UNIT, INV_UNIT;
static bool prime(int a) {
if (a == 1) return 0;
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
static void init() {
if (initCalled) return;
initCalled = true;
mod1 = 1000000000 + rnd() % 10000000;
while (!prime(mod1)) ++mod1;
mod2 = 1000000000 + rnd() % 10000000;
while (mod2 == mod1 || !prime(mod2)) ++mod2;
invp1 = fpow(p1, mod1 - 2, mod1);
invp2 = fpow(p2, mod2 - 2, mod2);
INV_UNIT = Hash(invp1, invp2);
}
inline Hash& operator+=(const Hash& other) {
x1 += other.x1;
x1 -= (((x1 - mod1) >> 31) + 1) * mod1;
x2 += other.x2;
x1 -= (((x1 - mod2) >> 31) + 1) * mod2;
return *this;
}
inline Hash& operator-=(const Hash& other) {
x1 -= other.x1;
x1 -= (x1 >> 31) * Hash::mod1;
x2 -= other.x2;
x2 -= (x2 >> 31) * Hash::mod2;
return *this;
}
inline Hash& operator*=(const Hash& other) {
x1 = (long long)x1 * other.x1 % Hash::mod1;
x2 = (long long)x2 * other.x2 % Hash::mod2;
return *this;
}
inline Hash& operator*=(const int& other) {
x1 = (long long)x1 * other % Hash::mod1;
x2 = (long long)x2 * other % Hash::mod2;
return *this;
}
inline Hash& operator^=(const int& power) {
int st = power;
Hash ans(1, 1);
while (st) {
if (st % 2) ans *= *this;
x1 = (long long)x1 * x1 % Hash::mod1;
x2 = (long long)x2 * x2 % Hash::mod2;
st /= 2;
}
return *this;
}
inline bool operator==(const Hash& other) const {
return x1 == other.x1 && x2 == other.x2;
}
};
bool Hash::initCalled = false;
int Hash::mod1 = 0;
int Hash::mod2 = 0;
int Hash::p1 = 23561;
int Hash::p2 = 10000019;
int Hash::invp1 = -1;
int Hash::invp2 = -1;
const Hash Hash::ONE(1, 1);
const Hash Hash::ZERO(0, 0);
const Hash Hash::INVALID(-1, -1);
Hash Hash::UNIT(Hash::p1, Hash::p2);
Hash Hash::INV_UNIT(-1, -1);
inline Hash operator+(const Hash& a, const Hash& b) {
Hash ans(a.x1 + b.x1, a.x2 + b.x2);
ans.x1 -= (((ans.x1 - Hash::mod1) >> 31) + 1) * Hash::mod1;
ans.x2 -= (((ans.x2 - Hash::mod2) >> 31) + 1) * Hash::mod2;
return ans;
}
inline Hash operator-(const Hash& a, const Hash& b) {
Hash ans(a.x1 - b.x1, a.x2 - b.x2);
ans.x1 -= (ans.x1 >> 31) * Hash::mod1;
ans.x2 -= (ans.x2 >> 31) * Hash::mod2;
return ans;
}
inline Hash operator*(const Hash& a, const Hash& b) {
return Hash((long long)a.x1 * b.x1 % Hash::mod1,
(long long)a.x2 * b.x2 % Hash::mod2);
}
inline Hash operator*(const Hash& a, const int& b) {
return Hash((long long)a.x1 * b % Hash::mod1,
(long long)a.x2 * b % Hash::mod2);
}
inline Hash operator^(const Hash& a, const int& power) {
int st = power;
Hash ans(1, 1), cur(a);
while (st) {
if (st % 2) ans *= cur;
cur *= cur;
st /= 2;
}
return ans;
}
inline Hash fpow(const Hash& a, const int& power) { return a ^ power; }
inline Hash invmod(const Hash& a) {
return Hash(invmod(a.x1, Hash::mod1), invmod(a.x2, Hash::mod2));
}
template <class H>
struct HashString : public string {
HashString() : string() { precalc(0); }
HashString(const HashString& other) : string(other) { precalc(size()); }
HashString(HashString&& other)
: hh(std::move(other.hh)), string(std::move(other)) {
precalc(size());
}
HashString(const string& other) : string(other) {
precalc(size());
build();
}
HashString(string&& other) : string(std::move(other)) {
precalc(size());
build();
}
HashString(const char* other) : string(other) {
precalc(size());
build();
}
inline void clear() {
hh.clear();
string::clear();
}
inline static H getPow(int p) {
if (p < haveN) {
return pp[p];
} else {
return fpow(H::UNIT, p);
}
}
inline static H getInvPow(size_t p) {
if (p < invpp.size()) {
return invpp[p];
} else {
return fpow(H::INV_UNIT, p);
}
}
inline H getInvRegister(const H& p) const {
if (p == register_) {
return registerValue_;
} else {
register_ = p;
return registerValue_ = invmod(p);
}
}
static void precalc(int N = 0) {
Hash::init();
if (haveN >= N) return;
pp.resize(N);
invpp.resize(N);
if (!haveN) {
pp[0] = H::ONE;
invpp[0] = H::ONE;
haveN = 1;
}
for (int i = haveN; i < N; ++i) {
pp[i] = pp[i - 1] * H::UNIT;
invpp[i] = invpp[i - 1] * H::INV_UNIT;
}
haveN = N;
}
inline void build() {
int curSize = size();
if (haveN <= curSize) {
precalc(curSize);
}
for (int i = hh.size(); i < curSize; ++i) {
H pr = i ? hh.back() : H::ZERO;
hh.push_back(pr + getPow(i) * (*this)[i]);
}
}
inline H getHash(int pos, int len) const {
if (len <= 0) return H::ZERO;
const int S = size();
if (pos + len - 1 < S) {
H ans = hh[pos + len - 1];
if (pos) {
ans -= hh[pos - 1];
ans *= getInvPow(pos);
}
return ans;
} else {
H head = hh.back();
if (pos) {
head -= hh[pos - 1];
head *= getInvPow(pos);
}
int full = -1, en = -1;
H mid = H::ZERO;
int midlen = 0;
if (len <= S) {
en = pos + len - 1 - S;
H tail = hh[en];
full = 0;
return head + tail * getPow(S - pos);
} else {
en = (pos + len - 1) % S;
H tail = hh[en];
full = (len - (S - pos) - (en + 1)) / S;
mid = hh.back() * (H::ONE - getInvPow(full * S)) *
getInvRegister(H::ONE - getInvPow(S));
return head + mid * getPow(S - pos) + tail * getPow(len - (en + 1));
}
}
}
inline HashString& operator+=(const char& ch) {
string::operator+=(ch);
build();
return *this;
}
inline HashString& operator+=(const HashString& other) {
string::operator+=(other);
build();
return *this;
}
inline bool operator==(const HashString& other) const {
return hh.back() == other.hh.back();
}
inline bool operator<(const HashString& other) const {
int s1 = size();
int s2 = other.size();
const int S = min(s1, s2);
int l = 0, r = S + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
if (getHash(0, xx) == other.getHash(0, xx))
l = xx;
else
r = xx;
}
char c1 = 0, c2 = 0;
if (l < s1) c1 = (*this)[l];
if (l < s2) c2 = other[l];
return c1 < c2;
}
inline bool operator<=(const HashString& other) const {
return (*this == other) || (*this < other);
}
inline bool operator>(const HashString& other) const {
return !(*this == other) && !(*this < other);
}
inline bool operator>=(const HashString& other) const {
return !(*this < other);
}
inline bool operator!=(const HashString& other) const {
return !(*this == other);
}
inline void reserve(int N) {
hh.reserve(N);
string::reserve(N);
}
vector<H> hh;
static vector<H> pp, invpp;
private:
mutable H register_, registerValue_;
static int haveN;
};
template <>
int HashString<Hash>::haveN = 0;
template <>
vector<Hash> HashString<Hash>::pp = vector<Hash>();
template <>
vector<Hash> HashString<Hash>::invpp = vector<Hash>();
template <class H, bool cyclic = true>
struct HashStringPiece {
explicit HashStringPiece(const HashString<H>& s, int pos, int len)
: s(s), pos(pos), len(len), hash(H::INVALID) {}
inline H getHash() const {
if (hash == H::INVALID) hash = s.getHash(pos, len);
return hash;
}
inline H getPartialHash(int needLen) const { return s.getHash(pos, needLen); }
inline char getChar(int i) const {
i += pos;
const int S = s.size();
if (i < S) return s[i];
if (!cyclic) return 0;
i -= S;
if (i < S) return s[i];
return s[i % S];
}
const HashString<H>& s;
const int pos, len;
mutable H hash;
};
template <class H, class T>
char getHSPRangeChar(T beg, T en, int pos) {
for (T it = beg; it != en; ++it) {
if (pos < it->len) {
return it->getChar(pos);
}
pos -= it->len;
}
return 0;
}
template <class H, class T>
H getHSPRangeHash(T beg, T en, int len) {
H ans = H::ZERO;
int cur = 0;
for (T it = beg; it != en; ++it) {
if (len >= it->len) {
ans += it->getHash() * it->s.getPow(cur);
cur += it->len;
len -= it->len;
} else {
ans += it->getPartialHash(len) * it->s.getPow(cur);
break;
}
}
return ans;
}
int TB, IT;
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, int len1, T beg2, T en2, int len2) {
if (beg1 == en1 && beg2 == en2) return 0;
if (beg1 == en1) return -1;
if (beg2 == en2) return 1;
int l = 0, r = min(len1, len2) + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
auto h1 = getHSPRangeHash<H, T>(beg1, en1, xx);
auto h2 = getHSPRangeHash<H, T>(beg2, en2, xx);
if (h1 == h2)
l = xx;
else
r = xx;
}
char c1 = getHSPRangeChar<H, T>(beg1, en1, l);
char c2 = getHSPRangeChar<H, T>(beg2, en2, l);
if (c1 < c2)
return -1;
else if (c1 == c2)
return 0;
else
return 1;
}
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, T beg2, T en2) {
int len1 = 0;
for (T it = beg1; it != en1; ++it) {
len1 += it->len;
}
int len2 = 0;
for (T it = beg2; it != en2; ++it) {
len2 += it->len;
}
return compareHSPRanges<H, T>(beg1, en1, len1, beg2, en2, len2);
}
int a, b, c, d, n, m, k;
char str[1000002];
int bal[2000002];
HashString<Hash> s;
inline string build(pair<pair<int, int>, int> a) {
string ans = "";
for (int _n((a.first.first) - 1), i(0); i <= _n; i++) ans += '(';
for (int _n((n)-1), i(0); i <= _n; i++) {
int cur = a.second + i;
if (cur >= n) cur -= n;
ans += str[cur];
}
for (int _n((a.first.second) - 1), i(0); i <= _n; i++) ans += ')';
return ans;
}
HashString<Hash> op, cl;
inline bool better(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b,
const HashString<Hash>& s) {
HashStringPiece<Hash> A[3] = {HashStringPiece<Hash>(op, 0, a.first.first),
HashStringPiece<Hash>(s, a.second, n),
HashStringPiece<Hash>(cl, 0, a.first.second)};
HashStringPiece<Hash> B[3] = {HashStringPiece<Hash>(op, 0, b.first.first),
HashStringPiece<Hash>(s, b.second, n),
HashStringPiece<Hash>(cl, 0, b.first.second)};
int t = compareHSPRanges<Hash>(A, A + 3, B, B + 3);
if (t == -1)
return 1;
else
return 0;
}
int main() {
gets(str);
n = (int)strlen(str);
HashString<Hash> s(str);
HashString<Hash>::precalc(2 * n + 1);
op.reserve(n + 1);
cl.reserve(n + 1);
for (int _n((n)-1), i(0); i <= _n; i++) {
op += '(';
cl += ')';
}
c = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (str[i] == '(')
++c;
else
--c;
}
bal[0] = 0;
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i) bal[i] = bal[i - 1];
int cur = i;
if (i >= n) cur = i - n;
if (str[cur] == '(')
++bal[i];
else
--bal[i];
}
int blen = 1000000000;
pair<pair<int, int>, int> best = make_pair(make_pair(0, 0), 0);
stack<pair<int, int> > s1, s2;
for (int _n((n)-1), i(0); i <= _n; i++) {
int new_element = bal[i];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
for (int _n((n)-1), cyc(0); cyc <= _n; cyc++) {
int current_minimum = -1000000000;
if (s1.empty() || s2.empty())
current_minimum = s1.empty() ? s2.top().second : s1.top().second;
else
current_minimum = min(s1.top().second, s2.top().second);
int p = 0;
if (cyc) p = bal[cyc - 1];
int mn = current_minimum - p;
int beg = max(0, -mn);
int en = c + beg;
int len = beg + en + n;
if (len < blen ||
(len == blen && better(make_pair(make_pair(beg, en), cyc), best, s))) {
blen = len;
best = make_pair(make_pair(beg, en), cyc);
}
if (s2.empty()) {
while (!s1.empty()) {
int element = s1.top().first;
s1.pop();
int minima = s2.empty() ? element : min(element, s2.top().second);
s2.push(make_pair(element, minima));
}
}
s2.pop();
int new_element = bal[cyc + n];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
string ans = build(best);
printf("%s\n", ans.c_str());
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)2e6 + 10;
const int inf = (int)1e9;
const int P[] = {(int)1e9 + 7, (int)1e9 + 9};
const int Q[] = {17, 239};
int stp[2][maxn];
int h[2][maxn];
int h1[2][maxn];
int h2[2][maxn];
const int sh = 1 << 21;
int rm[2 * sh + 10];
void upd(int first, int val) {
first += sh;
rm[first] = val;
while (first > 1) {
first /= 2;
rm[first] = min(rm[first * 2], rm[first * 2 + 1]);
}
}
int get_min(int l, int r) {
l += sh;
r += sh;
int ans = inf;
while (l <= r) {
ans = min(rm[l], ans);
ans = min(rm[r], ans);
l = (l + 1) / 2;
r = (r - 1) / 2;
}
return ans;
}
char s[maxn];
int n;
int sum[maxn];
void print(pair<int, pair<int, int> > ans) {
for (int j = 0; j < ans.first; j++) {
printf("(");
}
for (int j = 0; j < n; j++) {
printf("%c", s[ans.second.first + j]);
}
for (int j = 0; j < ans.second.second; j++) {
printf(")");
}
printf("\n");
}
int get_c(const pair<int, pair<int, int> >& a, int l) {
if (l < a.first) return -1;
if (l < a.first + n) {
return s[a.second.first + l - a.first] == '(' ? -1 : 1;
}
return 1;
}
pair<int, int> get_hash(const pair<int, pair<int, int> >& a, int l) {
if (l <= a.first) {
return make_pair(h1[0][l], h1[1][l]);
}
if (l <= a.first + n) {
int l2 = l - a.first;
pair<int, int> H1 = make_pair(h1[0][a.first], h1[1][a.first]);
pair<int, int> H2 =
make_pair(((h[0][a.second.first] -
(long long)h[0][a.second.first + l2] * stp[0][l2]) %
P[0] +
P[0]) %
P[0],
((h[1][a.second.first] -
(long long)h[1][a.second.first + l2] * stp[1][l2]) %
P[1] +
P[1]) %
P[1]);
return make_pair(
(H1.first + (long long)H2.first * stp[0][a.first]) % P[0],
(H1.second + (long long)H2.second * stp[1][a.first]) % P[1]);
}
{
int l2 = l - a.first - n;
pair<int, int> H1 = get_hash(a, a.first + n);
pair<int, int> H2 = make_pair(h2[0][l2], h2[1][l2]);
;
return make_pair(
(H1.first + (long long)H2.first * stp[0][a.first + n]) % P[0],
(H1.second + (long long)H2.second * stp[1][a.first + n]) % P[1]);
}
}
bool super_less(const pair<int, pair<int, int> >& a,
const pair<int, pair<int, int> >& b) {
if (a.first + a.second.second != b.first + b.second.second) {
return a.first + a.second.second < b.first + b.second.second;
}
int l = 0;
int r = a.first + a.second.second + n;
while (l < r) {
int m = (l + r + 1) / 2;
if (get_hash(a, m) == get_hash(b, m)) {
l = m;
} else {
r = m - 1;
}
}
if (r == a.first + a.second.second + n) {
return false;
}
return get_c(a, l) < get_c(b, l);
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) {
s[i + n] = s[i];
}
stp[0][0] = 1;
stp[1][0] = 1;
for (int j = 0; j < 2; j++) {
for (int i = 1; i <= 2 * n; i++) {
stp[j][i] = ((long long)stp[j][i - 1] * Q[j]) % P[j];
}
}
for (int j = 0; j < 2; j++) {
h[j][2 * n] = 0;
for (int i = 2 * n - 1; i >= 0; i--) {
h[j][i] = ((long long)h[j][i + 1] * Q[j] + (s[i] == '(' ? 1 : 2)) % P[j];
}
}
for (int j = 0; j < 2; j++) {
h1[j][0] = 0;
h2[j][0] = 0;
for (int i = 1; i <= 2 * n; i++) {
h1[j][i] = ((long long)h1[j][i - 1] * Q[j] + 1) % P[j];
h2[j][i] = ((long long)h2[j][i - 1] * Q[j] + 2) % P[j];
}
}
sum[0] = 0;
for (int i = 0; i < 2 * n; i++) {
if (s[i] == '(') {
sum[i + 1] = sum[i] + 1;
} else {
sum[i + 1] = sum[i] - 1;
}
}
for (int i = 0; i <= 2 * n; i++) {
upd(i, sum[i]);
}
pair<int, pair<int, int> > ans = make_pair(inf, make_pair(0, inf));
for (int i = 0; i < n; i++) {
int mn = min(0, get_min(i, i + n) - sum[i]);
int add_beg = abs(mn);
int add_end = sum[i + n] + add_beg - sum[i];
pair<int, pair<int, int> > res = make_pair(add_beg, make_pair(i, add_end));
if (super_less(res, ans)) {
ans = res;
}
}
print(ans);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000000;
const int MAX_N2 = MAX_N * 2;
const int MAX_E2 = 1 << 22;
const int INF = 1 << 30;
template <typename T, const int MAX_E2>
struct SegTreeMin {
int e2;
T nodes[MAX_E2], inf;
SegTreeMin() {}
void init(int n, T _inf) {
inf = _inf;
for (e2 = 1; e2 < n; e2 <<= 1)
;
fill(nodes, nodes + MAX_E2, inf);
}
T &get(int i) { return nodes[e2 - 1 + i]; }
void set(int i, T v) { get(i) = v; }
void setall() {
for (int j = e2 - 2; j >= 0; j--)
nodes[j] = min(nodes[j * 2 + 1], nodes[j * 2 + 2]);
}
T min_range(int r0, int r1, int k, int i0, int i1) {
if (r1 <= i0 || i1 <= r0) return inf;
if (r0 <= i0 && i1 <= r1) return nodes[k];
int im = (i0 + i1) / 2;
T v0 = min_range(r0, r1, k * 2 + 1, i0, im);
T v1 = min_range(r0, r1, k * 2 + 2, im, i1);
return min(v0, v1);
}
T min_range(int r0, int r1) { return min_range(r0, r1, 0, 0, e2); }
};
char s[MAX_N2 + 4];
int ords[MAX_N2 + 1];
SegTreeMin<int, MAX_E2> st;
inline unsigned char mask(int i) { return (unsigned char)(1 << (7 - i)); }
inline bool tget(vector<unsigned char> &t, int i) {
return (t[i / 8] & mask(i % 8)) ? true : false;
}
inline void tset(vector<unsigned char> &t, int i, bool b) {
if (b)
t[i / 8] |= mask(i % 8);
else
t[i / 8] &= ~mask(i % 8);
}
inline bool isLMS(vector<unsigned char> &t, int i) {
return (i > 0 && tget(t, i) && !tget(t, i - 1));
}
void getBuckets(int *s, vector<int> &bkt, int n, int k, bool end) {
bkt.assign(k, 0);
for (int i = 0; i < n; i++) bkt[s[i]]++;
for (int i = 0, sum = 0; i < k; i++) {
sum += bkt[i];
bkt[i] = end ? sum : sum - bkt[i];
}
}
void induceSAl(vector<unsigned char> &t, int *SA, int *s, vector<int> &bkt,
int n, int k, bool end) {
getBuckets(s, bkt, n, k, end);
for (int i = 0; i < n; i++) {
int j = SA[i] - 1;
if (j >= 0 && !tget(t, j)) SA[bkt[s[j]]++] = j;
}
}
void induceSAs(vector<unsigned char> &t, int *SA, int *s, vector<int> &bkt,
int n, int k, bool end) {
getBuckets(s, bkt, n, k, end);
for (int i = n - 1; i >= 0; i--) {
int j = SA[i] - 1;
if (j >= 0 && tget(t, j)) SA[--bkt[s[j]]] = j;
}
}
void SA_IS(int *s, int *SA, int n, int k) {
vector<unsigned char> t(n / 8 + 1);
tset(t, n - 1, true);
tset(t, n - 2, false);
for (int i = n - 3; i >= 0; i--)
if (s[i] < s[i + 1] || (s[i] == s[i + 1] && tget(t, i + 1)))
tset(t, i, true);
vector<int> bkt(k);
getBuckets(s, bkt, n, k, true);
for (int i = 0; i < n; i++) SA[i] = -1;
for (int i = 1; i < n; i++)
if (isLMS(t, i)) SA[--bkt[s[i]]] = i;
induceSAl(t, SA, s, bkt, n, k, false);
induceSAs(t, SA, s, bkt, n, k, true);
int n1 = 0;
for (int i = 0; i < n; i++)
if (isLMS(t, SA[i])) SA[n1++] = SA[i];
for (int i = n1; i < n; i++) SA[i] = -1;
int name = 0, prev = -1;
for (int i = 0; i < n1; i++) {
int pos = SA[i];
bool diff = false;
for (int d = 0; d < n; d++) {
if (prev == -1 || s[pos + d] != s[prev + d] ||
tget(t, pos + d) != tget(t, prev + d)) {
diff = true;
break;
} else if (d > 0 && (isLMS(t, pos + d) || isLMS(t, prev + d)))
break;
}
if (diff) name++, prev = pos;
pos /= 2;
SA[n1 + pos] = name - 1;
}
for (int i = n - 1, j = n - 1; i >= n1; i--)
if (SA[i] >= 0) SA[j--] = SA[i];
int *SA1 = SA, *s1 = SA + n - n1;
if (name < n1)
SA_IS(s1, SA1, n1, name);
else
for (int i = 0; i < n1; i++) SA1[s1[i]] = i;
bkt.assign(k, 0);
getBuckets(s, bkt, n, k, true);
for (int i = 1, j = 0; i < n; i++)
if (isLMS(t, i)) s1[j++] = i;
for (int i = 0; i < n1; i++) SA1[i] = s1[SA1[i]];
for (int i = n1; i < n; i++) SA[i] = -1;
for (int i = n1 - 1; i >= 0; i--) {
int j = SA[i];
SA[i] = -1;
SA[--bkt[s[j]]] = j;
}
induceSAl(t, SA, s, bkt, n, k, false);
induceSAs(t, SA, s, bkt, n, k, true);
}
void SA_IS(int n, char s[], vector<int> &SA, int k = 256) {
int *buf0 = new int[n + 1], *buf1 = new int[n + 1];
for (int i = 0; i < n; i++) buf0[i] = s[i];
buf0[n] = 0;
SA_IS(buf0, buf1, n + 1, k);
SA.resize(n + 1);
for (int i = 0; i <= n; i++) SA[i] = buf1[i];
}
int main() {
scanf("%s", s);
int n = strlen(s), n2 = n * 2;
copy(s, s + n, s + n);
vector<int> sa;
SA_IS(n2, s, sa);
for (int i = 0; i <= n2; i++) {
ords[sa[i]] = i;
}
st.init(n2 + 1, INF);
st.set(0, 0);
int sum = 0;
for (int i = 0; i < n2; i++) {
int d = (s[i] == '(') ? 1 : -1;
st.set(i + 1, st.get(i) + d);
sum += d;
}
st.setall();
sum /= 2;
int maxd = -INF, mino = INF, mini = -1;
for (int i = 0; i < n; i++) {
int d = st.min_range(i, i + n + 1) - st.get(i);
if (maxd < d || (maxd == d && mino > ords[i]))
maxd = d, mino = ords[i], mini = i;
}
int on = max(-sum, -maxd), cn = on + sum;
while (on--) putchar('(');
for (int i = 0; i < n; i++) putchar(s[i + mini]);
while (cn--) putchar(')');
putchar('\n');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
int const N = 2234567;
int const X = 33533;
long long M1;
long long M2;
long long const MASK = (1LL << 32) - 1;
long long POW1[N], POW2[N];
int s[N];
int bal[N];
struct hash {
long long h;
int len;
};
bool operator==(hash const& a, hash const& b) {
return a.len == b.len && a.h == b.h;
}
hash OPEN[N], CLOSE[N], hs[N];
long long add1(long long h1, long long h2, int len2) {
return (h1 * POW1[len2] + h2) % M1;
}
long long add2(long long h1, long long h2, int len2) {
return (h1 * POW2[len2] + h2) % M2;
}
hash operator+(hash const& a, hash const& b) {
return {(add1(a.h >> 32, b.h >> 32, b.len) << 32) |
add2(a.h & MASK, b.h & MASK, b.len),
a.len + b.len};
}
int const TR = 1 << 21;
int const INF = 1 << 30;
int trmin[TR * 2];
void settree(int x, int y) {
x += TR;
trmin[x] = y;
while (x > 1) {
x >>= 1;
if (trmin[x * 2] < trmin[x * 2 + 1])
trmin[x] = trmin[x * 2];
else
trmin[x] = trmin[x * 2 + 1];
}
}
int getmin(int left, int right) {
--right;
left += TR;
right += TR;
int ret = INF;
while (left <= right) {
if (left & 1) {
if (ret > trmin[left]) ret = trmin[left];
++left;
}
if ((right & 1) == 0) {
if (ret > trmin[right]) ret = trmin[right];
--right;
}
left >>= 1;
right >>= 1;
}
return ret;
}
struct answer {
int addOpen;
int pos;
int addClose;
};
int n;
int getChar(answer const& f, int id) {
if (id < f.addOpen) return '(';
id -= f.addOpen;
if (id < n) return s[f.pos + id];
id -= n;
if (id < f.addClose) return ')';
assert(false);
}
hash getHash(int left, int right) {
long long h1 = hs[right - 1].h >> 32;
long long h2 = hs[right - 1].h & MASK;
long long g1 = hs[left - 1].h >> 32;
long long g2 = hs[left - 1].h & MASK;
h1 -= g1 * POW1[right - left] % M1;
h2 -= g2 * POW2[right - left] % M2;
if (h1 < 0) h1 += M1;
if (h2 < 0) h2 += M2;
return {(h1 << 32) | h2, right - left};
}
hash getHash(answer const& f, int len) {
if (len <= f.addOpen) {
return OPEN[len];
}
hash z = OPEN[f.addOpen];
len -= f.addOpen;
if (len <= n) {
return z + getHash(f.pos, f.pos + len);
}
z = z + getHash(f.pos, f.pos + n);
len -= n;
if (len <= f.addClose) {
return z + CLOSE[len];
}
assert(false);
}
bool operator<(answer const& f, answer const& g) {
if (f.addOpen + f.addClose != g.addOpen + g.addClose)
return f.addOpen + f.addClose < g.addOpen + g.addClose;
int left = 0;
int right = f.addOpen + f.addClose + n + 1;
while (left < right - 1) {
int mid = (left + right) >> 1;
if (getHash(f, mid) == getHash(g, mid)) {
left = mid;
} else {
right = mid;
}
}
if (left == f.addOpen + f.addClose + n) return false;
return getChar(f, left) < getChar(g, left);
}
std::mt19937 rnd(std::chrono::system_clock::now().time_since_epoch().count());
int const HALFBILLION = 500000000;
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
void gen(long long& M) {
M = rnd() % HALFBILLION + HALFBILLION;
while (!prime(M)) {
++M;
}
}
int main() {
gen(M1);
gen(M2);
POW1[0] = POW2[0] = 1;
OPEN[0] = {0, 0};
CLOSE[0] = {0, 0};
for (int i = 1; i < N; i++) {
POW1[i] = POW1[i - 1] * X % M1;
POW2[i] = POW2[i - 1] * X % M2;
if (i == 1) {
OPEN[i] = {(long long)'(', 1};
CLOSE[i] = {(long long)')', 1};
} else {
OPEN[i] = OPEN[i - 1] + OPEN[1];
CLOSE[i] = CLOSE[i - 1] + CLOSE[1];
}
}
int c = getchar();
while (c <= 32) c = getchar();
n = 1;
while (c > 32) {
s[n++] = c;
c = getchar();
}
--n;
for (int i = 1; i <= n; i++) s[i + n] = s[i];
bal[0] = 0;
for (int i = 1; i <= 2 * n; i++) {
bal[i] = bal[i - 1] + (s[i] == '(' ? 1 : -1);
settree(i, bal[i]);
}
hs[0] = {0, 0};
for (int i = 1; i <= 2 * n; i++) {
hash cur = {(long long)s[i], 1};
hs[i] = hs[i - 1] + cur;
}
answer ans = {INF / 2, -1, INF / 2};
for (int start = 1; start <= n; start++) {
int minB = getmin(start - 1, start + n);
int addOpen = bal[start - 1] - minB;
int addClose = bal[start + n - 1] - minB;
answer cur = {addOpen, start, addClose};
if (cur < ans) ans = cur;
}
for (int i = 0; i < ans.addOpen; i++) putchar('(');
for (int i = 0; i < n; i++) putchar(s[ans.pos + i]);
for (int i = 0; i < ans.addClose; i++) putchar(')');
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXlogN = 22;
int wa[2000015], wb[2000015], wv[2000015], Ws[2000015];
int cmp(int* r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
int sa[2000015], Rank[2000015], LCP[2000015];
void buildSA(string s, int* sa, int n, int m) {
int i, j, p, *x = wa, *y = wb, *t;
for (i = 0; i < m; i++) Ws[i] = 0;
for (i = 0; i < n; i++) Ws[x[i] = s[i]]++;
for (i = 1; i < m; i++) Ws[i] += Ws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--Ws[x[i]]] = i;
for (j = 1, p = 1; p < n; j <<= 1, m = p) {
for (p = 0, i = n - j; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (i = 0; i < n; i++) wv[i] = x[y[i]];
for (i = 0; i < m; i++) Ws[i] = 0;
for (i = 0; i < n; i++) Ws[wv[i]]++;
for (i = 1; i < m; i++) Ws[i] += Ws[i - 1];
for (i = n - 1; i >= 0; i--) sa[--Ws[wv[i]]] = y[i];
for (t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
int A[2000015];
int Log[2000015];
int M[2000015][MAXlogN];
void buildSparse(int n) {
for (int i = 1; i <= n; i++) M[i][0] = A[i];
for (int i = 2; i <= n; i++) Log[i] = Log[i - 1] + !(i & (i - 1));
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; (i + (1 << j) - 1) <= n; i++)
M[i][j] = min(M[i][j - 1], M[i + (1 << (j - 1))][j - 1]);
}
}
int Query(int i, int j) {
int k = Log[j - i + 1];
return min(M[i][k], M[j - (1 << k) + 1][k]);
}
string str;
int main() {
cin >> str;
int cc = 0;
for (char ch : str) cc += (ch == '(') ? 1 : -1;
str = str + str;
int n = str.size();
buildSA(str, sa, n + 1, 130);
A[0] = (str[0] == '(') ? 1 : -1;
for (int i = 1; i < n; i++) {
if (str[i] == '(')
A[i] = 1;
else
A[i] = -1;
A[i] += A[i - 1];
}
for (int i = n; i >= 1; i--) A[i] = A[i - 1];
buildSparse(n);
int mn = 0;
for (int i = 1; i <= n; i++) {
if (sa[i] < n / 2) {
int xx = Query(sa[i] + 1, (sa[i] + 1) + n / 2 - 1);
if (xx - A[sa[i]] + max(-cc, 0) >= 0) {
mn = sa[i];
break;
}
}
}
string ans;
ans.resize(n / 2 + abs(cc));
if (cc >= 0) {
int cur = 0;
for (int i = mn; i < n / 2; i++, cur++) ans[cur] = str[i];
for (int i = 0; i < mn; i++, cur++) ans[cur] = str[i];
for (int i = 1; i <= cc; i++, cur++) ans[cur] = ')';
} else {
int cur = 0;
for (int i = 1; i <= abs(cc); i++, cur++) ans[cur] = '(';
for (int i = mn; i < n / 2; i++, cur++) ans[cur] = str[i];
for (int i = 0; i < mn; i++, cur++) ans[cur] = str[i];
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
char s[maxn];
int sa[maxn], rk[maxn], tp[maxn], tax[maxn];
int sum[maxn], mn[maxn], que[maxn];
int n, p1, p2;
void rsort(int n, int m) {
for (int i = 0; i <= m; ++i) tax[i] = 0;
for (int i = 1; i <= n; ++i) ++tax[rk[tp[i]]];
for (int i = 1; i <= m; ++i) tax[i] += tax[i - 1];
for (int i = n; i >= 1; --i) sa[tax[rk[tp[i]]]--] = tp[i];
}
inline int cmp(int x, int y, int len, int n) {
return tp[x] == tp[y] && x + len <= n && y + len <= n &&
tp[x + len] == tp[y + len];
}
void da(int n, int m) {
for (int i = 1; i <= n; ++i) tp[i] = i, rk[i] = s[i];
rsort(n, m);
for (int len = 1, p = 0; p < n && len < n; len <<= 1, m = p) {
p = 0;
for (int i = 1; i <= n; ++i) tp[++p] = (sa[i] - len - 1 + n) % n + 1;
rsort(n, m);
for (int i = 1; i <= n; ++i) tp[i] = tp[i + n] = rk[i];
rk[sa[1]] = p = 1;
for (int i = 2; i <= n; ++i)
rk[sa[i]] = cmp(sa[i - 1], sa[i], len, 2 * n) ? p : ++p;
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) s[i + n] = s[i];
da(n, 256);
int tn = n;
n <<= 1;
for (int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1] + (s[i] == '(' ? 1 : -1);
}
p1 = 1, p2 = 0;
for (int i = 1; i <= n; ++i) {
while (p1 <= p2 && sum[que[p2]] >= sum[i]) --p2;
que[++p2] = i;
while (i - que[p1] + 1 > tn) ++p1;
if (i >= tn) mn[i - tn + 1] = sum[que[p1]] - sum[i - tn];
}
int x = inf, y;
for (int i = 1; i <= tn; ++i) {
mn[i] = mn[i] >= 0 ? 0 : -mn[i];
x = min(x, mn[i]);
}
int p = 0;
y = x + sum[tn];
for (int i = 1; i <= tn; ++i) {
if (mn[sa[i]] == x) {
p = sa[i];
break;
}
}
while (x--) putchar('(');
s[p + tn] = 0;
printf("%s", s + p);
while (y--) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
static unsigned rnd() {
static int second = 124612741;
second ^= second << 13;
second ^= second >> 17;
return second ^= second << 5;
}
inline int fpow(int a, int st, int mod) {
int ans = 1;
while (st) {
if (st % 2) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
st /= 2;
}
return ans;
}
int invmod(int first, int second) {
int a = 1, b = 0, k;
for (; second; swap(first, second), swap(a, b)) {
k = first / second;
first -= second * k;
a -= b * k;
}
return a + max(b, 0);
}
struct Hash {
Hash() : x1(0), x2(0) {}
Hash(const int& x1, const int& x2) : x1(x1), x2(x2) {}
int x1, x2;
static int mod1, mod2;
static int p1, p2;
static int invp1, invp2;
static bool initCalled;
static const Hash ONE, ZERO, INVALID;
static Hash UNIT, INV_UNIT;
static bool prime(int a) {
if (a == 1) return 0;
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
static void init() {
if (initCalled) return;
initCalled = true;
mod1 = 1000000000 + rnd() % 10000000;
while (!prime(mod1)) ++mod1;
mod2 = 1000000000 + rnd() % 10000000;
while (mod2 == mod1 || !prime(mod2)) ++mod2;
invp1 = fpow(p1, mod1 - 2, mod1);
invp2 = fpow(p2, mod2 - 2, mod2);
INV_UNIT = Hash(invp1, invp2);
}
inline Hash& operator+=(const Hash& other) {
x1 += other.x1;
if (x1 >= Hash::mod1) x1 -= Hash::mod1;
x2 += other.x2;
if (x2 >= Hash::mod2) x2 -= Hash::mod2;
return *this;
}
inline Hash& operator-=(const Hash& other) {
x1 -= other.x1;
if (x1 < 0) x1 += Hash::mod1;
x2 -= other.x2;
if (x2 < 0) x2 += Hash::mod2;
return *this;
}
inline Hash& operator*=(const Hash& other) {
x1 = (long long)x1 * other.x1 % Hash::mod1;
x2 = (long long)x2 * other.x2 % Hash::mod2;
return *this;
}
inline Hash& operator*=(const int& other) {
x1 = (long long)x1 * other % Hash::mod1;
x2 = (long long)x2 * other % Hash::mod2;
return *this;
}
inline Hash& operator^=(const int& power) {
int st = power;
Hash ans(1, 1);
while (st) {
if (st % 2) ans *= *this;
x1 = (long long)x1 * x1 % Hash::mod1;
x2 = (long long)x2 * x2 % Hash::mod2;
st /= 2;
}
return *this;
}
inline bool operator==(const Hash& other) const {
return x1 == other.x1 && x2 == other.x2;
}
};
bool Hash::initCalled = false;
int Hash::mod1 = 0;
int Hash::mod2 = 0;
int Hash::p1 = 23561;
int Hash::p2 = 10000019;
int Hash::invp1 = -1;
int Hash::invp2 = -1;
const Hash Hash::ONE(1, 1);
const Hash Hash::ZERO(0, 0);
const Hash Hash::INVALID(-1, -1);
Hash Hash::UNIT(Hash::p1, Hash::p2);
Hash Hash::INV_UNIT(-1, -1);
inline Hash operator+(const Hash& a, const Hash& b) {
Hash ans(a.x1 + b.x1, a.x2 + b.x2);
if (ans.x1 >= Hash::mod1) ans.x1 -= Hash::mod1;
if (ans.x2 >= Hash::mod2) ans.x2 -= Hash::mod2;
return ans;
}
inline Hash operator-(const Hash& a, const Hash& b) {
Hash ans(a.x1 - b.x1, a.x2 - b.x2);
if (ans.x1 < 0) ans.x1 += Hash::mod1;
if (ans.x2 < 0) ans.x2 += Hash::mod2;
return ans;
}
inline Hash operator*(const Hash& a, const Hash& b) {
return Hash((long long)a.x1 * b.x1 % Hash::mod1,
(long long)a.x2 * b.x2 % Hash::mod2);
}
inline Hash operator*(const Hash& a, const int& b) {
return Hash((long long)a.x1 * b % Hash::mod1,
(long long)a.x2 * b % Hash::mod2);
}
inline Hash operator^(const Hash& a, const int& power) {
int st = power;
Hash ans(1, 1), cur(a);
while (st) {
if (st % 2) ans *= cur;
cur *= cur;
st /= 2;
}
return ans;
}
inline Hash fpow(const Hash& a, const int& power) { return a ^ power; }
inline Hash invmod(const Hash& a) {
return Hash(invmod(a.x1, Hash::mod1), invmod(a.x2, Hash::mod2));
}
template <class H>
struct HashString : public string {
HashString() : string() { precalc(0); }
HashString(const HashString& other) : string(other) { precalc(size()); }
HashString(HashString&& other)
: hh(std::move(other.hh)), string(std::move(other)) {
precalc(size());
}
HashString(const string& other) : string(other) {
precalc(size());
build();
}
HashString(string&& other) : string(std::move(other)) {
precalc(size());
build();
}
HashString(const char* other) : string(other) {
precalc(size());
build();
}
inline void clear() {
hh.clear();
string::clear();
}
inline static H getPow(int p) {
if (p < haveN) {
return pp[p];
} else {
return fpow(H::UNIT, p);
}
}
inline static H getInvPow(size_t p) {
if (p < invpp.size()) {
return invpp[p];
} else {
return fpow(H::INV_UNIT, p);
}
}
inline H getInvRegister(const H& p) const {
if (p == register_) {
return registerValue_;
} else {
register_ = p;
return registerValue_ = invmod(p);
}
}
static void precalc(int N = 0) {
Hash::init();
if (haveN >= N) return;
pp.resize(N);
invpp.resize(N);
if (!haveN) {
pp[0] = H::ONE;
invpp[0] = H::ONE;
haveN = 1;
}
for (int i = haveN; i < N; ++i) {
pp[i] = pp[i - 1] * H::UNIT;
invpp[i] = invpp[i - 1] * H::INV_UNIT;
}
haveN = N;
}
inline void build() {
int curSize = size();
if (haveN <= curSize) {
precalc(curSize);
}
for (int i = hh.size(); i < curSize; ++i) {
H pr = i ? hh.back() : H::ZERO;
hh.push_back(pr + getPow(i) * (*this)[i]);
}
}
inline H getHash(int pos, int len) const {
if (len <= 0) return H::ZERO;
const int S = size();
if (pos + len - 1 < S) {
H ans = hh[pos + len - 1];
if (pos) {
ans -= hh[pos - 1];
}
return ans * getInvPow(pos);
} else {
H head = hh.back();
if (pos) {
head -= hh[pos - 1];
}
head *= getInvPow(pos);
int full = -1, en = -1;
H mid = H::ZERO;
int midlen = 0;
if (len <= S) {
en = pos + len - 1 - S;
H tail = hh[en];
full = 0;
return head + tail * getPow(S - pos);
} else {
en = (pos + len - 1) % S;
H tail = hh[en];
full = (len - (S - pos) - (en + 1)) / S;
mid = hh.back() * (H::ONE - getInvPow(full * S)) *
getInvRegister(H::ONE - getInvPow(S));
return head + mid * getPow(S - pos) + tail * getPow(len - (en + 1));
}
}
}
inline HashString& operator+=(const char& ch) {
string::operator+=(ch);
build();
return *this;
}
inline HashString& operator+=(const HashString& other) {
string::operator+=(other);
build();
return *this;
}
inline bool operator==(const HashString& other) const {
return hh.back() == other.hh.back();
}
inline bool operator<(const HashString& other) const {
int s1 = size();
int s2 = other.size();
const int S = min(s1, s2);
int l = 0, r = S + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
if (getHash(0, xx) == other.getHash(0, xx))
l = xx;
else
r = xx;
}
char c1 = 0, c2 = 0;
if (l < s1) c1 = (*this)[l];
if (l < s2) c2 = other[l];
return c1 < c2;
}
inline bool operator<=(const HashString& other) const {
return (*this == other) || (*this < other);
}
inline bool operator>(const HashString& other) const {
return !(*this == other) && !(*this < other);
}
inline bool operator>=(const HashString& other) const {
return !(*this < other);
}
inline bool operator!=(const HashString& other) const {
return !(*this == other);
}
inline void reserve(int N) {
hh.reserve(N);
string::reserve(N);
}
vector<H> hh;
static vector<H> pp, invpp;
private:
mutable H register_, registerValue_;
static int haveN;
};
template <>
int HashString<Hash>::haveN = 0;
template <>
vector<Hash> HashString<Hash>::pp = vector<Hash>();
template <>
vector<Hash> HashString<Hash>::invpp = vector<Hash>();
template <class H, bool cyclic = true>
struct HashStringPiece {
explicit HashStringPiece(const HashString<H>& s, int pos, int len)
: s(s), pos(pos), len(len), hash(H::INVALID) {}
inline H getHash() const {
if (hash == H::INVALID) hash = s.getHash(pos, len);
return hash;
}
inline H getPartialHash(int needLen) const { return s.getHash(pos, needLen); }
inline char getChar(int i) const {
i += pos;
const int S = s.size();
if (i < S) return s[i];
if (!cyclic) return 0;
i -= S;
if (i < S) return s[i];
return s[i % S];
}
const HashString<H>& s;
const int pos, len;
mutable H hash;
};
template <class H, class T>
char getHSPRangeChar(T beg, T en, int pos) {
for (T it = beg; it != en; ++it) {
if (pos < it->len) {
return it->getChar(pos);
}
pos -= it->len;
}
return 0;
}
template <class H, class T>
H getHSPRangeHash(T beg, T en, int len) {
H ans = H::ZERO;
int cur = 0;
for (T it = beg; it != en; ++it) {
if (len >= it->len) {
ans += it->getHash() * it->s.getPow(cur);
cur += it->len;
len -= it->len;
} else {
ans += it->getPartialHash(len) * it->s.getPow(cur);
break;
}
}
return ans;
}
int TB, IT;
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, int len1, T beg2, T en2, int len2) {
if (beg1 == en1 && beg2 == en2) return 0;
if (beg1 == en1) return -1;
if (beg2 == en2) return 1;
int l = 0, r = min(len1, len2) + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
auto h1 = getHSPRangeHash<H, T>(beg1, en1, xx);
auto h2 = getHSPRangeHash<H, T>(beg2, en2, xx);
if (h1 == h2)
l = xx;
else
r = xx;
}
char c1 = getHSPRangeChar<H, T>(beg1, en1, l);
char c2 = getHSPRangeChar<H, T>(beg2, en2, l);
if (c1 < c2)
return -1;
else if (c1 == c2)
return 0;
else
return 1;
}
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, T beg2, T en2) {
int len1 = 0;
for (T it = beg1; it != en1; ++it) {
len1 += it->len;
}
int len2 = 0;
for (T it = beg2; it != en2; ++it) {
len2 += it->len;
}
return compareHSPRanges<H, T>(beg1, en1, len1, beg2, en2, len2);
}
int a, b, c, d, n, m, k;
char str[1000002];
int bal[2000002];
HashString<Hash> s;
inline string build(pair<pair<int, int>, int> a) {
string ans = "";
for (int _n((a.first.first) - 1), i(0); i <= _n; i++) ans += '(';
for (int _n((n)-1), i(0); i <= _n; i++) {
int cur = a.second + i;
if (cur >= n) cur -= n;
ans += str[cur];
}
for (int _n((a.first.second) - 1), i(0); i <= _n; i++) ans += ')';
return ans;
}
HashString<Hash> op, cl;
inline bool better(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b,
const HashString<Hash>& s) {
HashStringPiece<Hash> A[3] = {HashStringPiece<Hash>(op, 0, a.first.first),
HashStringPiece<Hash>(s, a.second, n),
HashStringPiece<Hash>(cl, 0, a.first.second)};
HashStringPiece<Hash> B[3] = {HashStringPiece<Hash>(op, 0, b.first.first),
HashStringPiece<Hash>(s, b.second, n),
HashStringPiece<Hash>(cl, 0, b.first.second)};
int t = compareHSPRanges<Hash>(A, A + 3, B, B + 3);
if (t == -1)
return 1;
else
return 0;
}
int main() {
gets(str);
n = (int)strlen(str);
HashString<Hash> s(str);
HashString<Hash>::precalc(2 * n + 1);
for (int _n((n)-1), i(0); i <= _n; i++) {
op += '(';
cl += ')';
}
c = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (str[i] == '(')
++c;
else
--c;
}
bal[0] = 0;
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i) bal[i] = bal[i - 1];
int cur = i;
if (i >= n) cur = i - n;
if (str[cur] == '(')
++bal[i];
else
--bal[i];
}
int blen = 1000000000;
pair<pair<int, int>, int> best = make_pair(make_pair(0, 0), 0);
stack<pair<int, int> > s1, s2;
for (int _n((n)-1), i(0); i <= _n; i++) {
int new_element = bal[i];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
for (int _n((n)-1), cyc(0); cyc <= _n; cyc++) {
int current_minimum = -1000000000;
if (s1.empty() || s2.empty())
current_minimum = s1.empty() ? s2.top().second : s1.top().second;
else
current_minimum = min(s1.top().second, s2.top().second);
int p = 0;
if (cyc) p = bal[cyc - 1];
int mn = current_minimum - p;
int beg = max(0, -mn);
int en = c + beg;
int len = beg + en + n;
if (len < blen ||
(len == blen && better(make_pair(make_pair(beg, en), cyc), best, s))) {
blen = len;
best = make_pair(make_pair(beg, en), cyc);
}
if (s2.empty()) {
while (!s1.empty()) {
int element = s1.top().first;
s1.pop();
int minima = s2.empty() ? element : min(element, s2.top().second);
s2.push(make_pair(element, minima));
}
}
s2.pop();
int new_element = bal[cyc + n];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
string ans = build(best);
printf("%s\n", ans.c_str());
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
char a[6000000];
int A[6000000];
int sa[6000000];
int it[6000000];
int n;
int good[6000000];
int S = 2097152;
void update(int x) {
for (x /= 2; x > 0; x /= 2) it[x] = min(it[x * 2], it[x * 2 + 1]);
}
int getmin(int x, int y) {
int mi = ((1 << 30) - 1);
while (x <= y) {
if (x % 2 == 1) mi = min(mi, it[x++]);
if (y % 2 == 0) mi = min(mi, it[y--]);
x /= 2, y /= 2;
}
return mi;
}
struct SuffixArray {
int N;
vector<int> raank, lcp, sa;
string S;
SuffixArray(string S) : S(S) {
int i, h = 0;
vector<int> tmp, tr;
N = S.size();
raank.resize(N + 1);
sa.resize(N + 1);
tmp.resize(N + 1);
for (i = 0; i < N + 1; i++) sa[i] = i, raank[i] = i == N ? -1 : S[i];
for (int k = 1; k <= N; k <<= 1) {
auto pred2 = [k, this](int& a, int& b) -> bool {
return (((a + k <= N) ? raank[a + k] : -1) <
((b + k <= N) ? raank[b + k] : -1));
};
auto pred = [pred2, k, this](int& a, int& b) -> bool {
return (raank[a] != raank[b]) ? (raank[a] < raank[b]) : pred2(a, b);
};
int x = 0;
if (k != 1)
for (i = 1; i < N + 1; i++)
if (raank[sa[i]] != raank[sa[x]])
sort(sa.begin() + x, sa.begin() + i, pred2), x = i;
sort(sa.begin() + x, sa.end(), pred);
for (i = 0; i < N + 1; i++)
tmp[sa[i]] = (i == 0) ? 0 : tmp[sa[i - 1]] + pred(sa[i - 1], sa[i]);
swap(raank, tmp);
}
lcp.resize(N + 1);
tr.resize(N + 1);
for (i = 0; i < N + 1; i++) tr[sa[i]] = i;
for (i = 0; i < N; i++) {
int j = sa[tr[i] - 1];
for (h = max(h - 1, 0); i + h < N && j + h < N; h++)
if (S[j + h] != S[i + h]) break;
lcp[tr[i] - 1] = h;
}
}
};
int main() {
int i, j, k;
scanf("%s", a);
n = strlen(a);
for (i = 0; i < n; i++) a[i + n] = a[i];
string s = string(a);
SuffixArray ssa(s);
for (i = 0; i < n * 2; i++) sa[ssa.raank[i] - 1] = i;
int now = 0;
for (i = 0; i < n * 2; i++) {
now += a[i] == '(' ? 1 : -1;
it[S + i + 1] = now;
update(S + i + 1);
}
int pad = 0;
now /= 2;
if (now < 0) pad = -now;
for (i = 0; i < n; i++) {
if (getmin(S + i, S + i + n) - it[S + i] + pad >= 0) good[i] = 1;
}
for (i = 0; i < n * 2; i++) {
if (good[sa[i]] == 1) {
for (j = now; j < 0; j++) printf("(");
for (j = sa[i]; j < sa[i] + n; j++) printf("%c", a[j]);
for (j = 0; j < now; j++) printf(")");
return 0;
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2111111;
char buf[maxn];
int sum[maxn];
bool ok[maxn];
inline void fix(int& i, int n) {
while (!ok[i] && i <= n) {
++i;
}
}
inline void print(char ch, int n) {
while (n--) {
putchar(ch);
}
}
int run(char s[], int m) {
int n = m >> 1;
int i = 1, j = 2, k = 0;
fix(i, n);
j = i + 1;
fix(j, n);
while (j <= n && i <= n) {
for (k = 0; k < n; ++k) {
if (s[i + k] ^ s[j + k]) {
break;
}
}
if (s[i + k] > s[j + k]) {
i += k + 1;
fix(i, n);
} else {
j += k + 1;
fix(j, n);
}
if (j == i) {
++j;
fix(j, n);
}
}
return std::min(i, j);
}
int main() {
gets(buf + 1);
int n = std::strlen(buf + 1);
int A, B;
A = B = 0;
for (int i = 1; i <= n; ++i) {
buf[i + n] = buf[i];
if (buf[i] == '(') {
++A;
} else {
++B;
}
}
int m = n << 1;
for (int i = 1; i <= m; ++i) {
if (buf[i] == '(') {
sum[i] = 1;
} else {
sum[i] = -1;
}
sum[i] += sum[i - 1];
}
static int q[maxn];
int front, rear;
front = rear = 0;
static int min[maxn];
int add = 0;
if (A < B) {
add = B - A;
}
for (int i = 1; i <= m; ++i) {
if (front < rear && q[front] + n <= i) {
++front;
}
while (front < rear && sum[q[rear - 1]] >= sum[i]) {
--rear;
}
q[rear++] = i;
min[i] = sum[q[front]];
}
for (int i = 1; i <= n; ++i) {
if (add + min[i + n - 1] >= sum[i - 1]) {
ok[i] = true;
}
}
int index = run(buf, m);
if (A < B) {
print('(', B - A);
}
for (int i = index; i < index + n; ++i) {
putchar(buf[i]);
}
if (B < A) {
print(')', A - B);
}
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
string st;
long bal[1 << 20];
long minsuf[1 << 20], minpref[1 << 20];
long val1, val2;
long n;
long s[1 << 20];
long p[1 << 20], pn[1 << 20], cnt[1 << 20], c[1 << 20], cn[1 << 20];
long classes, mid1, mid2;
long ans, k;
long open, clos;
long blen, bc, tlen, nopen;
int main() {
ios_base::sync_with_stdio(0);
cin >> st;
n = st.size();
for (int i = 0; i < n; i++)
if (st[i] == '(')
s[i] = 0;
else
s[i] = 1;
for (int i = 0; i < n; i++) ++cnt[s[i]];
for (int i = 1; i < 100; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i < n; i++) {
p[--cnt[s[i]]] = i;
}
c[p[0]] = 0;
classes = 1;
for (int i = 1; i < n; i++) {
if (s[p[i]] != s[p[i - 1]]) ++classes;
c[p[i]] = classes - 1;
}
for (int h = 0; (1 << h) < n; ++h) {
for (int i = 0; i < n; i++) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += n;
}
for (int i = 0; i <= classes; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[c[pn[i]]]++;
for (int i = 1; i < classes; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; --i) p[--cnt[c[pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (int i = 1; i < n; i++) {
mid1 = p[i] + (1 << h);
mid2 = p[i - 1] + (1 << h);
mid1 %= n;
mid2 %= n;
if (c[p[i]] != c[p[i - 1]] || c[mid1] != c[mid2]) ++classes;
cn[p[i]] = classes - 1;
}
for (int i = 0; i <= n; i++) c[i] = cn[i];
}
for (int i = 0; i < st.size(); i++) {
if (st[i] == '(')
bal[i + 1] = bal[i] + 1;
else
bal[i + 1] = bal[i] - 1;
minpref[i + 1] = min(minpref[i], bal[i + 1]);
if (st[i] == '(')
++open;
else
++clos;
}
minsuf[st.size()] = bal[st.size()];
for (int i = st.size() - 1; i + 1; --i) {
minsuf[i] = min(minsuf[i + 1], bal[i]);
}
blen = 1e9;
bc = 0;
for (int i = 0; i < st.size(); i++) {
val1 = minsuf[i + 1] - bal[i];
val2 = minpref[i] + (bal[st.size()] - bal[i]);
val1 = min(val1, val2);
if (val1 >= 0) {
tlen = st.size() + (open - clos);
if (tlen < blen || (tlen == blen && c[i] < c[bc])) {
blen = tlen;
bc = i;
}
} else {
nopen = open - val1;
tlen = st.size() + (nopen - clos);
if (tlen < blen || (tlen == blen && c[i] < c[bc])) {
blen = tlen;
bc = i;
}
}
}
string ts = "";
for (int i = bc; i < st.size(); i++) ts += st[i];
for (int i = 0; i < bc; i++) ts += st[i];
long mb = 0;
long qb = 0;
for (int i = 0; i < ts.size(); i++) {
if (ts[i] == '(')
qb++;
else
qb--;
if (qb < mb) mb = qb;
}
reverse(ts.begin(), ts.end());
if (mb < 0) {
mb *= -1;
for (int i = 0; i < mb; i++) ts += '(';
}
reverse(ts.begin(), ts.end());
qb = 0;
for (int i = 0; i < ts.size(); i++) {
if (ts[i] == '(')
++qb;
else
--qb;
}
for (int i = 0; i < qb; i++) ts += ')';
cout << ts << endl;
cin.get();
cin.get();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, A[2000005], B[2000005], sum[2000005], ord[2000005];
pair<pair<int, int>, int> E[2000005];
char s[2000005];
void SA() {
N <<= 1;
for (int i = 0; i < N; i++) ord[i] = (s[i] == ')');
for (int s = 1; s < N; s <<= 1) {
for (int i = 0; i < N; i++)
E[i] = (make_pair)(make_pair(ord[i], i + s < N ? ord[i + s] : N), i);
sort(E, E + N);
pair<int, int> now = pair<int, int>(-1, 0);
int rank = -1;
for (int i = 0; i < N; i++) {
if (E[i].first != now) rank++, now = E[i].first;
ord[E[i].second] = rank;
}
}
N >>= 1;
}
int main() {
scanf("%s", s);
N = strlen(s);
for (int i = N; i < N + N; i++) s[i] = s[i - N];
SA();
for (int i = 1; i < N + 1; i++)
sum[i] = sum[i - 1] + (s[i - 1] == '(' ? 1 : -1);
A[0] = sum[N];
B[N - 1] = sum[N - 1];
for (int i = 1; i < N; i++) A[i] = min(A[i - 1], sum[i] + sum[N]);
for (int i = N - 2; i + 1; i--) B[i] = min(B[i + 1], sum[i]);
int Len = min(0, sum[N]), Ans = -1;
for (int i = 0; i < N; i++)
if (min(A[i], B[i]) - sum[i] == Len)
if (Ans == -1 || ord[i] < ord[Ans]) Ans = i;
for (int i = 0; i < -sum[N]; 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;
const int maxN = 1000010;
const int maxL = 21;
namespace suffixArray {
int ra[maxN], sa[maxN], P[maxL][maxN];
int lg, len, cum[maxN];
struct node {
int a, b, c;
} L[maxN], tmp[maxN];
inline int cSort(int idx) {
int n = max(300, len + 2), sum = 0;
for (int i = 0; i < n; i++) cum[i] = 0;
for (int i = 0; i < len; i++) {
if (idx)
cum[L[i].a + 1]++;
else
cum[L[i].b + 1]++;
}
for (int i = 0; i < n; i++) sum += cum[i], cum[i] = sum - cum[i];
for (int i = 0; i < len; i++) {
if (idx)
tmp[cum[L[i].a + 1]++] = L[i];
else
tmp[cum[L[i].b + 1]++] = L[i];
}
for (int i = 0; i < len; i++) L[i] = tmp[i];
}
inline void construct(const char* s) {
len = strlen(s);
lg = 1;
for (int i = 0; i < len; i++) P[0][i] = int(s[i]);
for (int shift = 1; shift < len; shift <<= 1, lg++) {
for (int i = 0; i < len; i++) {
L[i].a = P[lg - 1][i];
L[i].b = i + shift < len ? P[lg - 1][i + shift] : -1;
L[i].c = i;
}
cSort(0);
cSort(1);
for (int i = 0; i < len; i++)
P[lg][L[i].c] = (i > 0 && L[i].a == L[i - 1].a && L[i].b == L[i - 1].b)
? P[lg][L[i - 1].c]
: i;
}
lg--;
for (int i = 0; i < len; i++) sa[i] = 0;
for (int i = 0; i < len; i++) sa[P[lg][i]] = i;
for (int i = 0; i < len; i++) ra[sa[i]] = i;
}
inline int lcp(int i, int j) {
if (i == j) return len - i;
int l = 0;
for (int k = lg; k >= 0 && i < len && j < len; k--) {
if (P[k][i] == P[k][j]) {
i += 1 << k;
j += 1 << k;
l += 1 << k;
}
}
return l;
}
} // namespace suffixArray
char s[maxN];
int prefMin[maxN], sufMin[maxN], balance[maxN];
int main() {
scanf("%s", s);
int n = strlen(s);
suffixArray::construct(s);
s[n] = 0;
int open = 0, close = 0;
for (int i = 0; i < (n); ++i) {
if (s[i] == '(') {
++open;
if (i == 0)
balance[i] = 1;
else
balance[i] = balance[i - 1] + 1;
} else {
++close;
if (i == 0)
balance[i] = -1;
else
balance[i] = balance[i - 1] - 1;
}
}
for (int i = 0; i < (n); ++i) {
if (i == 0)
prefMin[i] = balance[i];
else
prefMin[i] = min(prefMin[i - 1], balance[i]);
}
for (int i = n - 1; i >= 0; --i) {
if (i == n - 1)
sufMin[i] = balance[i];
else
sufMin[i] = min(sufMin[i + 1], balance[i]);
}
int start = -1;
for (int i = 0; i < (n); ++i)
if (suffixArray::sa[i] < n) {
int p = suffixArray::sa[i];
if (p == 0) {
if (max(close - open, 0) + sufMin[p] >= 0) {
if (start == -1) {
start = p;
}
}
} else {
if (max(close - open, 0) + sufMin[p] - balance[p - 1] >= 0) {
if (prefMin[p - 1] + max(close - open, 0) + balance[n - 1] -
balance[p - 1] >=
0) {
if (start == -1) {
start = p;
} else {
int common = suffixArray::lcp(start, p);
if (common < n - start) {
break;
} else {
if (suffixArray::ra[p + common] < suffixArray::ra[0]) {
start = p;
}
}
}
}
}
}
}
assert(start != -1);
while (open < close) putchar('('), ++open;
for (int i = 0; i < (n); ++i) putchar(s[(start + i) % n]);
while (open > close) putchar(')'), ++close;
puts("");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
inline long long parse(const string &s) {
stringstream ss(s);
long long x;
ss >> x;
return x;
}
const double EPS = 1e-9;
const int inf = 1000 * 1000 * 1000;
const char cinf = 102;
const long long linf = inf * 1ll * inf;
const double dinf = 1e200;
const double PI = 3.1415926535897932384626433832795l;
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
struct sufar {
static const int maxlen = 1001000;
int pn[maxlen], cn[maxlen];
int p[maxlen], cnt[maxlen], c[maxlen];
void doit(const char *s, int n) {
memset(cnt, 0, 200 * sizeof(int));
for (int i = 0; i < n; ++i) ++cnt[s[i]];
for (int i = 1; i < 200; ++i) cnt[i] += cnt[i - 1];
for (int i = 0; i < n; ++i) p[--cnt[s[i]]] = i;
c[p[0]] = 0;
int classes = 1;
for (int i = 1; i < n; ++i) {
if (s[p[i]] != s[p[i - 1]]) ++classes;
c[p[i]] = classes - 1;
}
for (int h = 0; (1 << h) < n; ++h) {
for (int i = 0; i < n; ++i) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += n;
}
memset(cnt, 0, classes * sizeof(int));
for (int i = 0; i < n; ++i) ++cnt[c[pn[i]]];
for (int i = 1; i < classes; ++i) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; --i) p[--cnt[c[pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (int i = 1; i < n; ++i) {
int mid1 = (p[i] + (1 << h)) % n, mid2 = (p[i - 1] + (1 << h)) % n;
if (c[p[i]] != c[p[i - 1]] || c[mid1] != c[mid2]) ++classes;
cn[p[i]] = classes - 1;
}
memcpy(c, cn, n * sizeof(int));
}
}
};
sufar sa;
char S[2001000];
char S0[1001000];
int n;
int main() {
gets(S);
n = strlen(S);
sa.doit(S, n);
vector<int> ip(n);
for (int i = 0; i < (n); ++i) {
ip[sa.p[i]] = i;
}
vector<int> mn1(n + 1), mn2(n + 1), A(n + 1);
for (int i = 0; i < (n); ++i) {
A[i + 1] = A[i] + (S[i] == '(' ? 1 : -1);
mn1[i + 1] = min(mn1[i], A[i + 1]);
}
mn2[n] = A[n];
for (int i = n - 1; i >= 0; --i) {
mn2[i] = min(mn2[i + 1], A[i]);
}
pair<pair<int, int>, pair<pair<int, int>, int>> res(
make_pair(inf, inf), make_pair(make_pair(-1, -1), -1));
for (int i = 0; i < (n); ++i) {
int m = min(mn1[i] + (A[n] - A[i]), mn2[i] - A[i]);
assert(m <= 0);
int a = -m;
int b = A[n] - m;
res = min(
res, make_pair(make_pair(a + b, ip[i]), make_pair(make_pair(a, b), i)));
}
rotate(S, S + res.second.second, S + n);
int d = 0;
for (int i = 0; i < (res.second.first.first); ++i) {
S0[i] = '(';
++d;
}
printf("%s", S0);
for (int i = 0; i < (res.second.first.second); ++i) {
S[n++] = ')';
}
puts(S);
for (int i = 0; i < (n); ++i) {
d += (S[i] == '(' ? 1 : -1);
assert(d >= 0);
}
assert(d == 0);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
static unsigned rnd() {
static int second = 124612741;
second ^= second << 13;
second ^= second >> 17;
return second ^= second << 5;
}
inline int fpow(int a, int st, int mod) {
int ans = 1;
while (st) {
if (st % 2) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
st /= 2;
}
return ans;
}
int invmod(int first, int second) {
int a = 1, b = 0, k;
for (; second; swap(first, second), swap(a, b)) {
k = first / second;
first -= second * k;
a -= b * k;
}
return a + max(b, 0);
}
inline int calcBits(int a) { return __builtin_popcount(a); }
struct Hash {
Hash() : x1(0), x2(0) {}
Hash(const int& x1, const int& x2) : x1(x1), x2(x2) {}
int x1, x2;
static int mod1, mod2;
static int p1, p2;
static int invp1, invp2;
static bool initCalled;
static const Hash ONE, ZERO, INVALID;
static Hash UNIT, INV_UNIT;
static bool prime(int a) {
if (a == 1) return 0;
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
static int pickModHelper(int start, int bad) {
int mn = 1000000000, best = -1;
for (int _n(start + 1000), i(start); i <= _n; i++) {
if (i == bad || !prime(i)) continue;
int cur = calcBits(i);
if (cur < mn) {
mn = cur;
best = i;
}
}
return best;
}
static void init() {
if (initCalled) return;
initCalled = true;
mod1 = pickModHelper((1 << 29) + rnd() % 1000000, -1);
while (!prime(mod1)) ++mod1;
mod2 = pickModHelper((1 << 29) + rnd() % 1000000, mod1);
invp1 = fpow(p1, mod1 - 2, mod1);
invp2 = fpow(p2, mod2 - 2, mod2);
INV_UNIT = Hash(invp1, invp2);
}
inline Hash& operator+=(const Hash& other) {
x1 += other.x1;
if (x1 >= Hash::mod1) x1 -= Hash::mod1;
x2 += other.x2;
if (x2 >= Hash::mod2) x2 -= Hash::mod2;
return *this;
}
inline Hash& operator-=(const Hash& other) {
x1 -= other.x1;
if (x1 < 0) x1 += Hash::mod1;
x2 -= other.x2;
if (x2 < 0) x2 += Hash::mod2;
return *this;
}
inline Hash& operator*=(const Hash& other) {
x1 = (long long)x1 * other.x1 % Hash::mod1;
x2 = (long long)x2 * other.x2 % Hash::mod2;
return *this;
}
inline Hash& operator*=(const int& other) {
x1 = (long long)x1 * other % Hash::mod1;
x2 = (long long)x2 * other % Hash::mod2;
return *this;
}
inline Hash& operator^=(const int& power) {
int st = power;
Hash ans(1, 1);
while (st) {
if (st % 2) ans *= *this;
x1 = (long long)x1 * x1 % Hash::mod1;
x2 = (long long)x2 * x2 % Hash::mod2;
st /= 2;
}
return *this;
}
inline bool operator==(const Hash& other) const {
return x1 == other.x1 && x2 == other.x2;
}
};
bool Hash::initCalled = false;
int Hash::mod1 = 0;
int Hash::mod2 = 0;
int Hash::p1 = 23561;
int Hash::p2 = 10000019;
int Hash::invp1 = -1;
int Hash::invp2 = -1;
const Hash Hash::ONE(1, 1);
const Hash Hash::ZERO(0, 0);
const Hash Hash::INVALID(-1, -1);
Hash Hash::UNIT(Hash::p1, Hash::p2);
Hash Hash::INV_UNIT(-1, -1);
inline Hash operator+(const Hash& a, const Hash& b) {
Hash ans(a.x1 + b.x1, a.x2 + b.x2);
if (ans.x1 >= Hash::mod1) ans.x1 -= Hash::mod1;
if (ans.x2 >= Hash::mod2) ans.x2 -= Hash::mod2;
return ans;
}
inline Hash operator-(const Hash& a, const Hash& b) {
Hash ans(a.x1 - b.x1, a.x2 - b.x2);
if (ans.x1 < 0) ans.x1 += Hash::mod1;
if (ans.x2 < 0) ans.x2 += Hash::mod2;
return ans;
}
inline Hash operator*(const Hash& a, const Hash& b) {
return Hash((long long)a.x1 * b.x1 % Hash::mod1,
(long long)a.x2 * b.x2 % Hash::mod2);
}
inline Hash operator*(const Hash& a, const int& b) {
return Hash((long long)a.x1 * b % Hash::mod1,
(long long)a.x2 * b % Hash::mod2);
}
inline Hash operator^(const Hash& a, const int& power) {
int st = power;
Hash ans(1, 1), cur(a);
while (st) {
if (st % 2) ans *= cur;
cur *= cur;
st /= 2;
}
return ans;
}
inline Hash fpow(const Hash& a, const int& power) { return a ^ power; }
inline Hash invmod(const Hash& a) {
return Hash(invmod(a.x1, Hash::mod1), invmod(a.x2, Hash::mod2));
}
template <class H>
struct HashString : public string {
HashString() : string() { precalc(0); }
HashString(const HashString& other) : string(other) { precalc(size()); }
HashString(HashString&& other)
: hh(std::move(other.hh)), string(std::move(other)) {
precalc(size());
}
HashString(const string& other) : string(other) {
precalc(size());
build();
}
HashString(string&& other) : string(std::move(other)) {
precalc(size());
build();
}
HashString(const char* other) : string(other) {
precalc(size());
build();
}
inline void clear() {
hh.clear();
string::clear();
}
inline static H getPow(int p) {
if (p < haveN) {
return pp[p];
} else {
return fpow(H::UNIT, p);
}
}
inline static H getInvPow(size_t p) {
if (p < invpp.size()) {
return invpp[p];
} else {
return fpow(H::INV_UNIT, p);
}
}
inline H getInvRegister(const H& p) const {
if (p == register_) {
return registerValue_;
} else {
register_ = p;
return registerValue_ = invmod(p);
}
}
static void precalc(int N = 0) {
Hash::init();
if (haveN >= N) return;
pp.resize(N);
invpp.resize(N);
if (!haveN) {
pp[0] = H::ONE;
invpp[0] = H::ONE;
haveN = 1;
}
for (int i = haveN; i < N; ++i) {
pp[i] = pp[i - 1] * H::UNIT;
invpp[i] = invpp[i - 1] * H::INV_UNIT;
}
haveN = N;
}
inline void build() {
int curSize = size();
if (haveN <= curSize) {
precalc(curSize);
}
for (int i = hh.size(); i < curSize; ++i) {
H pr = i ? hh.back() : H::ZERO;
hh.push_back(pr + getPow(i) * (*this)[i]);
}
}
inline H getHash(int pos, int len) const {
if (len <= 0) return H::ZERO;
const int S = size();
if (pos + len - 1 < S) {
H ans = hh[pos + len - 1];
if (pos) {
ans -= hh[pos - 1];
ans *= getInvPow(pos);
}
return ans;
} else {
H head = hh.back();
if (pos) {
head -= hh[pos - 1];
head *= getInvPow(pos);
}
int full = -1, en = -1;
H mid = H::ZERO;
int midlen = 0;
if (len <= S) {
en = pos + len - 1 - S;
H tail = hh[en];
full = 0;
return head + tail * getPow(S - pos);
} else {
en = (pos + len - 1) % S;
H tail = hh[en];
full = (len - (S - pos) - (en + 1)) / S;
mid = hh.back() * (H::ONE - getInvPow(full * S)) *
getInvRegister(H::ONE - getInvPow(S));
return head + mid * getPow(S - pos) + tail * getPow(len - (en + 1));
}
}
}
inline HashString& operator+=(const char& ch) {
string::operator+=(ch);
build();
return *this;
}
inline HashString& operator+=(const HashString& other) {
string::operator+=(other);
build();
return *this;
}
inline bool operator==(const HashString& other) const {
return hh.back() == other.hh.back();
}
inline bool operator<(const HashString& other) const {
int s1 = size();
int s2 = other.size();
const int S = min(s1, s2);
int l = 0, r = S + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
if (getHash(0, xx) == other.getHash(0, xx))
l = xx;
else
r = xx;
}
char c1 = 0, c2 = 0;
if (l < s1) c1 = (*this)[l];
if (l < s2) c2 = other[l];
return c1 < c2;
}
inline bool operator<=(const HashString& other) const {
return (*this == other) || (*this < other);
}
inline bool operator>(const HashString& other) const {
return !(*this == other) && !(*this < other);
}
inline bool operator>=(const HashString& other) const {
return !(*this < other);
}
inline bool operator!=(const HashString& other) const {
return !(*this == other);
}
inline void reserve(int N) {
hh.reserve(N);
string::reserve(N);
}
vector<H> hh;
static vector<H> pp, invpp;
private:
mutable H register_, registerValue_;
static int haveN;
};
template <>
int HashString<Hash>::haveN = 0;
template <>
vector<Hash> HashString<Hash>::pp = vector<Hash>();
template <>
vector<Hash> HashString<Hash>::invpp = vector<Hash>();
template <class H, bool cyclic = true>
struct HashStringPiece {
explicit HashStringPiece(const HashString<H>& s, int pos, int len)
: s(s), pos(pos), len(len), hash(H::INVALID) {}
inline H getHash() const {
if (hash == H::INVALID) hash = s.getHash(pos, len);
return hash;
}
inline H getPartialHash(int needLen) const { return s.getHash(pos, needLen); }
inline char getChar(int i) const {
i += pos;
const int S = s.size();
if (i < S) return s[i];
if (!cyclic) return 0;
i -= S;
if (i < S) return s[i];
return s[i % S];
}
const HashString<H>& s;
const int pos, len;
mutable H hash;
};
template <class H, class T>
char getHSPRangeChar(T beg, T en, int pos) {
for (T it = beg; it != en; ++it) {
if (pos < it->len) {
return it->getChar(pos);
}
pos -= it->len;
}
return 0;
}
template <class H, class T>
H getHSPRangeHash(T beg, T en, int len) {
H ans = H::ZERO;
int cur = 0;
for (T it = beg; it != en; ++it) {
if (len >= it->len) {
ans += it->getHash() * it->s.getPow(cur);
cur += it->len;
len -= it->len;
} else {
ans += it->getPartialHash(len) * it->s.getPow(cur);
break;
}
}
return ans;
}
int TB, IT;
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, int len1, T beg2, T en2, int len2) {
if (beg1 == en1 && beg2 == en2) return 0;
if (beg1 == en1) return -1;
if (beg2 == en2) return 1;
int l = 0, r = min(len1, len2) + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
auto h1 = getHSPRangeHash<H, T>(beg1, en1, xx);
auto h2 = getHSPRangeHash<H, T>(beg2, en2, xx);
if (h1 == h2)
l = xx;
else
r = xx;
}
char c1 = getHSPRangeChar<H, T>(beg1, en1, l);
char c2 = getHSPRangeChar<H, T>(beg2, en2, l);
if (c1 < c2)
return -1;
else if (c1 == c2)
return 0;
else
return 1;
}
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, T beg2, T en2) {
int len1 = 0;
for (T it = beg1; it != en1; ++it) {
len1 += it->len;
}
int len2 = 0;
for (T it = beg2; it != en2; ++it) {
len2 += it->len;
}
return compareHSPRanges<H, T>(beg1, en1, len1, beg2, en2, len2);
}
int a, b, c, d, n, m, k;
char str[1000002];
int bal[2000002];
HashString<Hash> s;
inline string build(pair<pair<int, int>, int> a) {
string ans = "";
for (int _n((a.first.first) - 1), i(0); i <= _n; i++) ans += '(';
for (int _n((n)-1), i(0); i <= _n; i++) {
int cur = a.second + i;
if (cur >= n) cur -= n;
ans += str[cur];
}
for (int _n((a.first.second) - 1), i(0); i <= _n; i++) ans += ')';
return ans;
}
HashString<Hash> op, cl;
inline bool better(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b,
const HashString<Hash>& s) {
HashStringPiece<Hash> A[3] = {HashStringPiece<Hash>(op, 0, a.first.first),
HashStringPiece<Hash>(s, a.second, n),
HashStringPiece<Hash>(cl, 0, a.first.second)};
HashStringPiece<Hash> B[3] = {HashStringPiece<Hash>(op, 0, b.first.first),
HashStringPiece<Hash>(s, b.second, n),
HashStringPiece<Hash>(cl, 0, b.first.second)};
int t = compareHSPRanges<Hash>(A, A + 3, B, B + 3);
if (t == -1)
return 1;
else
return 0;
}
int main() {
gets(str);
n = (int)strlen(str);
HashString<Hash> s(str);
HashString<Hash>::precalc(2 * n + 1);
op.reserve(n + 1);
cl.reserve(n + 1);
for (int _n((n)-1), i(0); i <= _n; i++) {
op += '(';
cl += ')';
}
c = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (str[i] == '(')
++c;
else
--c;
}
bal[0] = 0;
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i) bal[i] = bal[i - 1];
int cur = i;
if (i >= n) cur = i - n;
if (str[cur] == '(')
++bal[i];
else
--bal[i];
}
int blen = 1000000000;
pair<pair<int, int>, int> best = make_pair(make_pair(0, 0), 0);
stack<pair<int, int> > s1, s2;
for (int _n((n)-1), i(0); i <= _n; i++) {
int new_element = bal[i];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
for (int _n((n)-1), cyc(0); cyc <= _n; cyc++) {
int current_minimum = -1000000000;
if (s1.empty() || s2.empty())
current_minimum = s1.empty() ? s2.top().second : s1.top().second;
else
current_minimum = min(s1.top().second, s2.top().second);
int p = 0;
if (cyc) p = bal[cyc - 1];
int mn = current_minimum - p;
int beg = max(0, -mn);
int en = c + beg;
int len = beg + en + n;
if (len < blen ||
(len == blen && better(make_pair(make_pair(beg, en), cyc), best, s))) {
blen = len;
best = make_pair(make_pair(beg, en), cyc);
}
if (s2.empty()) {
while (!s1.empty()) {
int element = s1.top().first;
s1.pop();
int minima = s2.empty() ? element : min(element, s2.top().second);
s2.push(make_pair(element, minima));
}
}
s2.pop();
int new_element = bal[cyc + n];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
string ans = build(best);
printf("%s\n", ans.c_str());
}
| 7 | CPP |
#include <bits/stdc++.h>
const int MAXN = 1e6 + 10;
char buf[MAXN];
int n;
int pre[MAXN], suc[MAXN];
inline int tr(int x) { return x > n ? x - n : x; }
const int MAXP = MAXN << 1;
int R[MAXP], nxt[MAXP][2], fail[MAXP];
int tot, lst, at[MAXN];
void extend(int x, int id) {
static int p, v, t, now;
R[now = ++tot] = R[p = lst] + 1;
at[id] = lst = now;
for (; p && !nxt[p][x]; p = fail[p]) nxt[p][x] = now;
if (!p)
fail[now] = 1;
else {
t = nxt[p][x];
if (R[t] == R[p] + 1)
fail[now] = t;
else {
R[v = ++tot] = R[p] + 1;
memcpy(nxt[v], nxt[t], sizeof(nxt[0]));
fail[v] = fail[t];
fail[t] = fail[now] = v;
for (; p && nxt[p][x] == t; p = fail[p]) nxt[p][x] = v;
}
}
}
int head[MAXP], nt[MAXP];
int dep[MAXP], top[MAXP], son[MAXP], sz[MAXP];
void dfs(int u) {
sz[u] = 1;
for (int i = head[u]; i; i = nt[i]) {
dep[i] = dep[u] + 1;
dfs(i);
sz[u] += sz[i];
if (sz[i] > sz[son[u]]) son[u] = i;
}
}
void dfs2(int u) {
if (son[u]) top[son[u]] = top[u], dfs2(son[u]);
for (int i = head[u]; i; i = nt[i])
if (i != son[u]) top[i] = i, dfs2(i);
}
int LCP(int x, int y) {
x = at[tr(x)], y = at[tr(y)];
while (top[x] != top[y])
dep[top[x]] > dep[top[y]] ? x = fail[top[x]] : y = fail[top[y]];
return R[dep[x] < dep[y] ? x : y];
}
void build() {
tot = lst = 1;
for (int i = n; i; --i) extend(buf[i] == ')', i);
for (int i = 2; i <= tot; ++i) nt[i] = head[fail[i]], head[fail[i]] = i;
top[1] = 1;
dfs(1);
dfs2(1);
}
bool cmp(int x, int y) {
int lcp = LCP(x, y);
if (lcp + y == n + 1) lcp += LCP(x + lcp, 1);
if (lcp >= n) return false;
return buf[tr(x + lcp)] > buf[tr(y + lcp)];
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> buf + 1;
n = strlen(buf + 1);
build();
int ct = 0;
for (int i = 1; i <= n; ++i) suc[i] = pre[i] = ct += buf[i] == '(' ? 1 : -1;
for (int i = n - 1; ~i; --i) suc[i] = std::min(suc[i], suc[i + 1]);
int best = -1;
int pmin = 0;
for (int i = 0; i <= n; ++i) {
pmin = std::min(pmin, pre[i]);
bool can = true;
if (ct <= 0) {
can &= suc[i + 1] - pre[i] - ct >= 0;
can &= pmin + (pre[n] - pre[i]) - ct >= 0;
}
if (ct > 0) {
can &= suc[i + 1] - pre[i] >= 0;
can &= std::min(pmin, pre[i] - ct) + (pre[n] - pre[i]) >= 0;
}
if (can) {
if (best == -1 || cmp(best, i + 1)) best = i + 1;
}
}
if (ct < 0)
for (int i = 1; i <= std::abs(ct); ++i) std::cout << '(';
for (int i = 0; i < n; ++i) std::cout << buf[tr(best + i)];
if (ct > 0)
for (int i = 1; i <= ct; ++i) std::cout << ')';
std::cout << '\n';
return 0;
}
| 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);
cout << fixed << setprecision(10);
double beg_clock = 1.0 * clock() / CLOCKS_PER_SEC;
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 (0) cout << "SAinv:\n";
for (long long i = (1); i <= (n); ++i) {
if (0) cout << SAinv[i] << " ";
}
if (0) cout << "\n";
;
if (bil < 0) {
for (long long i = (1); i <= (-bil); ++i) {
cout << '(';
}
}
for (long long i = (best); i <= (best + n - 1); ++i) {
cout << br[i];
}
if (bil >= 0) {
for (long long i = (1); i <= (bil); ++i) {
cout << ')';
}
}
cout << "\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 1000005;
const int logMax = 20;
int N;
char S[NMax * 2];
int Partial[NMax * 2];
int Tree[NMax * 8];
int open, closed, last;
struct SArray {
int pos;
int nb[2];
} L[2 * NMax], Aux[2 * NMax];
vector<int> V[2 * NMax];
int Cnt[NMax * 2], Ind[NMax * 2];
int P[2][NMax * 2];
void Read() {
scanf("%s", S + 1);
N = strlen(S + 1);
for (int i = N + 1; i <= 2 * N; i++) S[i] = S[i - N];
}
void precalcPartial() {
for (int i = 1; i <= N * 2; i++) {
if (S[i] == '(')
Partial[i] = Partial[i - 1] + 1;
else
Partial[i] = Partial[i - 1] - 1;
}
}
inline bool cmp(SArray a, SArray b) {
if (a.nb[0] == b.nb[0]) return a.nb[1] < b.nb[1];
return a.nb[0] < b.nb[0];
}
void Sort() {
for (int i = 1; i <= N * 2; i++) {
Cnt[L[i].nb[1]]++;
}
int p = 0;
Ind[0] = 1;
for (int i = 1; i <= 2 * N; i++) Ind[i] = Ind[i - 1] + Cnt[i - 1];
for (int i = 1; i <= 2 * N; i++) Aux[Ind[L[i].nb[1]]++] = L[i];
Cnt[0] = Ind[0] = 0;
for (int i = 1; i <= 2 * N; i++) L[i] = Aux[i], Cnt[i] = 0, Ind[i] = 0;
for (int i = 1; i <= N * 2; i++) {
Cnt[L[i].nb[0]]++;
}
Ind[0] = 1;
for (int i = 1; i <= 2 * N; i++) Ind[i] = Ind[i - 1] + Cnt[i - 1];
for (int i = 1; i <= 2 * N; i++) Aux[Ind[L[i].nb[0]]++] = L[i];
Cnt[0] = Ind[0] = 0;
for (int i = 1; i <= 2 * N; i++) L[i] = Aux[i], Cnt[i] = 0, Ind[i] = 0;
}
void buildSuffixArray() {
for (int i = 1; i <= N * 2; i++) P[0][i] = S[i] - '(' + 1;
int ind = 1;
for (int i = 1; (1 << (i - 1)) <= N * 2; i++, ind ^= 1) {
last = i;
for (int j = 1; j <= N * 2; j++) {
L[j].pos = j;
L[j].nb[0] = P[ind ^ 1][j];
L[j].nb[1] =
(j + (1 << (i - 1)) <= N * 2) ? P[ind ^ 1][j + (1 << (i - 1))] : 0;
}
Sort();
int cnt = 0;
for (int j = 1; j <= 2 * N; j++) {
if (L[j].nb[0] != L[j - 1].nb[0] || L[j].nb[1] != L[j - 1].nb[1]) ++cnt;
P[ind][L[j].pos] = cnt;
}
}
last = ind ^ 1;
}
void precalcOpenClosed() {
for (int i = 1; i <= N; i++) {
if (S[i] == '(')
++open;
else
++closed;
}
}
void buildTree(int K, int L, int R) {
if (L == R) {
Tree[K] = Partial[L];
return;
}
buildTree(K * 2, L, (L + R) / 2);
buildTree(K * 2 + 1, (L + R) / 2 + 1, R);
Tree[K] = min(Tree[K * 2], Tree[K * 2 + 1]);
}
int Query(int K, int L, int R, int x, int y) {
if (L > R || L > y || R < x) return 1000000005;
if (L >= x && R <= y) return Tree[K];
int a = Query(K * 2, L, (L + R) / 2, x, y);
int b = Query(K * 2 + 1, (L + R) / 2 + 1, R, x, y);
return min(a, b);
}
void ifOpenLessThenClosed() {
int suff = -1, Min = 1000000005;
for (int i = 1; i <= N; i++) {
if (Query(1, 1, 2 * N, i, i + N - 1) - Partial[i - 1] + closed - open < 0)
continue;
if (Min > P[last][i]) {
Min = P[last][i];
suff = i;
}
}
for (int i = 1; i <= closed - open; i++) printf("(");
for (int i = suff; i - suff + 1 <= N; i++) printf("%c", S[i]);
printf("\n");
}
void ifClosedLessThenOpen() {
int suff = -1, Min = 1000000005;
for (int i = 1; i <= N; i++) {
if (Query(1, 1, 2 * N, i, i + N - 1) - Partial[i - 1] < 0) continue;
if (Min > P[last][i]) {
Min = P[last][i];
suff = i;
}
}
for (int i = suff; i - suff + 1 <= N; i++) printf("%c", S[i]);
for (int i = 1; i <= open - closed; i++) printf(")");
printf("\n");
}
int main() {
Read();
precalcPartial();
buildSuffixArray();
buildTree(1, 1, 2 * N);
precalcOpenClosed();
if (open >= closed)
ifClosedLessThenOpen();
else
ifOpenLessThenClosed();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const long double pi = acos(-1.0);
const int N = (int)2e6 + 10;
const int M = (int)1e9 + 9;
const int H = 2;
const long long P[2] = {17239, 23917};
long long h[2][N], ppow[2][N];
int n, prefsum[N], minprefsum[N], sufsum[N], minsufsum[N];
char s[N];
bool equal(int i, int j, int len) {
for (int t = 0; t < H; ++t)
if (((h[t][i + len] - h[t][i] * ppow[t][len]) -
(h[t][j + len] - h[t][j] * ppow[t][len])) %
M !=
0)
return false;
return true;
}
bool is_less(int i, int j) {
int l = 0, r = n;
while (l < r) {
int q = (l + r + 1) / 2;
if (equal(i, j, q))
l = q;
else
r = q - 1;
}
return (s[i + l] < s[j + l]);
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) s[i + n] = s[i];
for (int j = 0; j < 2; ++j) {
h[j][0] = 0, ppow[j][0] = 1;
for (int i = 0; i < 2 * n; ++i) {
h[j][i + 1] = (h[j][i] * P[j] + s[i]) % M;
ppow[j][i + 1] = (ppow[j][i] * P[j]) % M;
}
}
prefsum[0] = 0;
for (int i = 0; i < n; ++i)
prefsum[i + 1] = prefsum[i] + ((s[i] == '(') ? 1 : -1);
minprefsum[0] = prefsum[0];
for (int i = 0; i < n; ++i)
minprefsum[i + 1] = min(minprefsum[i], prefsum[i + 1]);
minsufsum[n] = prefsum[n];
for (int i = n - 1; i >= 0; --i)
minsufsum[i] = min(minsufsum[i + 1], prefsum[i]);
int total = prefsum[n], bound = min(total, 0);
vector<int> a;
for (int i = 0; i < n; ++i)
if ((minsufsum[i + 1] >= bound + prefsum[i]) &&
(minprefsum[i] >= bound - total + prefsum[i]))
a.push_back(i);
int best = a[0];
for (int i = 1; i < ((int)(a).size()); ++i)
if (is_less(a[i], best)) best = a[i];
for (int i = 0; i < -total; ++i) printf("(");
for (int i = 0; i < n; ++i) printf("%c", s[best + i]);
for (int i = 0; i < total; ++i) printf(")");
printf("\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 9;
const int base = 11;
string s;
int n;
int hsh[maxn], pw[maxn];
int pm[maxn], sm[maxn], a[maxn];
int get_hsh(int f, int len) {
int s = f + len - 1;
if (f == 0) return hsh[s];
return (hsh[s] - 1ll * hsh[f - 1] * pw[len] % mod + mod) % mod;
}
int get_min(int v, int u, int times = 0) {
if (v > u) return 1 ^ get_min(u, v, times);
int lo = 0, hi = n - u + 1;
while (hi - lo > 1) {
int mid = (lo + hi) >> 1;
if (get_hsh(v, mid) == get_hsh(u, mid))
lo = mid;
else
hi = mid;
}
if (lo != n - u) return (s[v + lo] == '(');
if (times == 3) return true;
v = (v + lo) % n, u = (u + lo) % n;
return get_min(v, u, times + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> s;
n = s.size();
for (int i = 0; i < n; i++)
a[i] = (i > 0 ? a[i - 1] : 0) + (s[i] == '(') - (s[i] == ')');
int tot = a[n - 1];
for (int i = 0; i < n; i++) pm[i] = min((i > 0 ? pm[i - 1] : n), a[i]);
for (int i = n - 1; i >= 0; i--)
sm[i] = min((i < n - 1 ? sm[i + 1] : n), a[i]);
vector<int> candid;
for (int i = 0; i < n; i++) {
int mnm;
if (i == 0)
mnm = sm[0];
else
mnm = min(sm[i] - a[i - 1], pm[i - 1] + (a[n - 1] - a[i - 1]));
if (tot >= 0) {
if (mnm >= 0) candid.push_back(i);
} else {
if (mnm == tot) candid.push_back(i);
}
}
pw[0] = 1;
for (int i = 1; i < n; i++) pw[i] = 1ll * pw[i - 1] * base % mod;
if (s[0] == '(')
hsh[0] = 1;
else
hsh[0] = 2;
for (int i = 1; i < n; i++)
hsh[i] = (1ll * hsh[i - 1] * base + 1 + (s[i] == ')')) % mod;
int m = candid.size();
while (candid.size() > 1) {
int i = candid[m - 1], j = candid[m - 2];
m--;
candid.pop_back(), candid.pop_back();
if (get_min(i, j) == true)
candid.push_back(i);
else
candid.push_back(j);
}
int st = candid[0];
if (tot < 0)
for (int i = 0; i < abs(tot); i++) cout << '(';
for (int i = st; i < n; i++) cout << s[i];
for (int i = 0; i < st; i++) cout << s[i];
if (tot > 0)
for (int i = 0; i < tot; i++) cout << ')';
cout << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool b[2000005];
char c[2000005];
int h[2000005], q[2000005];
int i, j, k, n, H, T, t;
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (i = 1; i <= n; i++) t += (c[i] == '(') ? 1 : -1;
for (i = n + 1; i <= n * 2; i++) c[i] = c[i - n];
if (t < 0)
for (i = 1; i <= -t; i++) putchar('(');
for (i = 1; i <= 2 * n; i++) h[i] = h[i - 1] + ((c[i] == '(') ? 1 : -1);
H = 1;
T = 0;
for (i = 1; i <= n; i++) {
for (; T && h[i] < h[q[T]]; T--)
;
q[++T] = i;
}
for (i = 1; i <= n; i++) {
if (h[q[H]] - h[i - 1] < min(t, 0)) b[i] = 1;
for (; T >= H && h[n + i] < h[q[T]]; T--)
;
q[++T] = n + i;
if (q[H] == i) H++;
}
for (i = 1, j = 2;;) {
for (; b[i]; i++)
;
for (; b[j]; j++)
;
if (i == j)
for (j++; b[j]; j++)
;
if (i > n || j > n) break;
for (k = 0; k < n && c[i + k] == c[j + k]; k++)
;
if (c[i + k] < c[j + k])
j = j + k + 1;
else
i = i + k + 1;
}
if (j < i) i = j;
for (j = i; j < n + i; j++) putchar(c[j]);
if (t > 0)
for (i = 1; i <= t; i++) putchar(')');
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
clock_t start = clock();
double runt() { return ((double)(clock() - start)) / CLOCKS_PER_SEC; }
char s[2000015];
int A, B;
struct SuffixArray {
int sa[2000015];
int c[2000015], x[2000015], y[2000015];
void get_SA(const char *s, int n, int m) {
for (int(i) = 1; (i) <= (int)(n); (i)++) ++c[x[i] = s[i]];
for (int i = 2; i <= m; ++i) c[i] += c[i - 1];
for (int i = n; i >= 1; --i) sa[c[x[i]]--] = i;
for (int k = 1; k <= n; k <<= 1) {
int num = 0;
for (int i = n - k + 1; i <= n; ++i) y[++num] = i;
for (int i = 1; i <= n; ++i)
if (sa[i] > k) y[++num] = sa[i] - k;
for (int i = 1; i <= m; ++i) c[i] = 0;
for (int i = 1; i <= n; ++i) ++c[x[i]];
for (int i = 2; i <= m; ++i) c[i] += c[i - 1];
for (int i = n; i >= 1; --i) {
sa[c[x[y[i]]]--] = y[i];
y[i] = 0;
}
swap(x, y);
x[sa[1]] = 1;
num = 1;
for (int i = 2; i <= n; ++i)
x[sa[i]] =
(y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k])
? num
: ++num;
if (num == n) break;
m = num;
}
}
} sa;
int T[2000015][22];
void init(int n) {
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
T[i][j] = min(T[i][j - 1], T[i + (1 << (j - 1))][j - 1]);
}
}
}
int qym(int l, int r) {
int x = log(r - l + 1) / log(2);
int y = min(T[l][x], T[r - (1 << x) + 1][x]);
return y;
}
void pp(int pos) {
for (int(i) = 0; (i) < (int)(B - A); (i)++) printf("(");
for (int i = pos; i < pos + n; i++) printf("%c", s[i] == 'a' ? '(' : ')');
for (int(i) = 0; (i) < (int)(A - B); (i)++) printf(")");
puts("");
exit(0);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
int id = i;
if (s[i] == '(') {
A++;
s[i] = s[i + n] = 'a';
T[id][0] = T[id - 1][0] + 1;
} else {
B++;
s[i] = s[i + n] = 'b';
T[id][0] = T[id - 1][0] - 1;
}
}
for (int i = n + 1; i <= n + n; i++)
T[i][0] = T[i - 1][0] + (s[i] == 'a' ? 1 : -1);
init(n + n);
sa.get_SA(s, n + n, 122);
for (int(i) = 1; (i) <= (int)(n + n); (i)++) {
int pos = sa.sa[i];
if (pos > n) continue;
int mi = qym(pos, pos + n - 1) - T[pos - 1][0];
if (A < B) {
if (B - A + mi >= 0) pp(pos);
} else {
if (mi >= 0) pp(pos);
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
char c;
bool fu = 0;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x *= -1;
}
template <class T>
inline void read(T &x, T &y) {
read(x);
read(y);
}
template <class T>
inline void read(T &x, T &y, T &z) {
read(x, y);
read(z);
}
const int N = 2000010;
char ch[N];
deque<int> Q;
bool can[N];
int len, l, m = 127, s1, s2, u1[N], u2[N], *x = u1, *y = u2, t[N], sa[N],
ans[N], s[N];
inline bool cmp(int *r, int a, int b, int l) {
return r[a] == r[b] && r[a + l] == r[b + l];
}
int main() {
gets(ch + 1);
len = strlen(ch + 1);
for (int _tmp = len, i = 1; i <= _tmp; ++i) ch[len + i] = ch[i];
l = len << 1;
ch[0] = ch[len];
for (int _tmp = l, i = 1; i <= _tmp; ++i) ++t[x[i] = ch[i]];
for (int _tmp = m, i = 1; i <= _tmp; ++i) t[i] += t[i - 1];
for (int _tmp = 1, i = l; i >= _tmp; --i) sa[t[x[i]]--] = i;
for (int j = 1, p = 0; j <= l && p != l; m = p, j *= 2, p = 0) {
for (int _tmp = l, i = l - j + 1; i <= _tmp; ++i) y[++p] = i;
for (int _tmp = l, i = 1; i <= _tmp; ++i)
if (sa[i] > j) y[++p] = sa[i] - j;
for (int _tmp = m, i = 0; i <= _tmp; ++i) t[i] = 0;
for (int _tmp = l, i = 1; i <= _tmp; ++i) s[i] = x[y[i]];
for (int _tmp = l, i = 1; i <= _tmp; ++i) ++t[s[i]];
for (int _tmp = m, i = 1; i <= _tmp; ++i) t[i] += t[i - 1];
for (int _tmp = 1, i = l; i >= _tmp; --i) sa[t[s[i]]--] = y[i];
swap(x, y);
x[sa[1]] = 1, p = 1;
for (int _tmp = l, i = 2; i <= _tmp; ++i)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p : ++p;
}
for (int _tmp = len, i = 1; i <= _tmp; ++i) ++(ch[i] == '(' ? s1 : s2);
for (int _tmp = len, i = l; i >= _tmp; --i) {
s[i] = s[i + 1] + (ch[i] == '(' ? 1 : -1);
while (!Q.empty() && s[i] > s[Q.back()]) Q.pop_back();
Q.push_back(i);
can[i] = 0;
}
for (int _tmp = 1, i = len; i >= _tmp; --i) {
s[i] = s[i + 1] + (ch[i] == '(' ? 1 : -1);
can[i] = (max(s2 - s1, 0) + (s[i] - s[Q.front()]) >= 0);
while (!Q.empty() && s[i] > s[Q.back()]) Q.pop_back();
Q.push_back(i);
while (!Q.empty() && Q.front() >= i + len) Q.pop_front();
}
int p = 1;
for (int _tmp = l, i = 1; i <= _tmp; ++i)
if (can[sa[i]]) {
p = sa[i];
break;
}
while (s1 < s2) ++s1, putchar('(');
for (int _tmp = p + len - 1, i = p; i <= _tmp; ++i) putchar(ch[i]);
while (s1 > s2) ++s2, putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int INF = 1e9;
const long long lINF = 1e18;
const double EPS = 1e-12;
using namespace std;
const int N = 1e6 + 100;
char s[N];
int p[N], c[N], last[N];
int pn[N], cn[N];
int n, balance[N], mnl[N], mnr[N];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) {
last[s[i] - 'a' + 1]++;
}
for (int i = 2; i <= 26; i++) {
last[i] += last[i - 1];
}
for (int i = 0; i < n; i++) {
c[i] = last[s[i] - 'a'];
}
for (int i = 0; i < n; i++) {
p[last[s[i] - 'a']++] = i;
}
for (int l = 1; l < n; l <<= 1) {
for (int i = 0; i < n; i++) last[i] = i;
for (int i = 0; i < n; i++) {
int pp = (p[i] - l + n) % n;
pn[last[c[pp]]++] = pp;
}
memcpy(p, pn, n * sizeof(n));
cn[p[0]] = 0;
int nlast = 0;
for (int i = 1; i < n; i++) {
int mid1 = (p[i] + l) % n, mid2 = (p[i - 1] + l) % n;
if (c[p[i]] > c[p[i - 1]] || c[mid1] > c[mid2]) nlast = i;
cn[p[i]] = nlast;
}
memcpy(c, cn, n * sizeof(n));
}
mnl[0] = INF;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
balance[i + 1] = balance[i] + 1;
} else {
balance[i + 1] = balance[i] - 1;
}
mnl[i + 1] = min(balance[i + 1], mnl[i]);
}
mnr[n - 1] = balance[n];
for (int i = n - 2; i >= 0; i--) {
mnr[i] = min(mnr[i + 1], balance[i + 1]);
}
int ans = INF, ansi = 0, good = min(0, balance[n]);
for (int i = 0; i < n; i++) {
if (mnl[i] + balance[n] - balance[i] >= good &&
mnr[i] - balance[i] >= good) {
if (ans > c[i]) {
ans = c[i];
ansi = i;
}
}
}
for (int i = 0; i < -balance[n]; i++) {
putchar('(');
}
for (int i = ansi; i < ansi + n; i++) {
putchar(s[i % n]);
}
for (int i = 0; i < balance[n]; i++) {
putchar(')');
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef int arr[3000010];
string s;
int n, ans, l, r, q[1000010], y = 1;
inline bool check(int x) {
while (l < r && q[l % n] < x) l++;
for (; y <= x; y++) {
if (s[y - 1] == '(')
q[r++] = y - 1 + n;
else if (l < r)
r--;
}
return r - l > max(ans, 0);
}
inline void solve() {
int i = -1;
for (int j = 0, k, l; j < n;) {
if (check(j)) {
j++;
continue;
}
if (i == -1) {
i = j;
j++;
continue;
}
for (k = 0; k < n && s[(i + k) % n] == s[(j + k) % n]; k++)
;
if (k >= n) break;
if (s[(i + k) % n] < s[(j + k) % n])
j += k + 1;
else
l = i + k, i = j, j = max(l, j) + 1;
}
cout << s.substr(i, n);
}
int main() {
cin >> s;
n = s.length();
for (int i = 0; i < n; i++)
if (s[i] == '(')
ans++, q[r++] = i;
else {
ans--;
if (r > 0) r--;
}
if (ans < 0)
for (int i = 1; i <= -ans; i++) putchar('(');
s += s;
solve();
if (ans > 0)
for (int i = 1; i <= ans; i++) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000010;
const int H = 37;
const int P = 1000000007;
int k, n, m;
int a[N], sum;
int Ans = 1e9, x;
int h[N], p[N];
vector<int> g;
multiset<int> S;
char s[N];
int Get(int l, int r) {
return ((h[r] - 1ll * h[l - 1] * p[r - l + 1]) % P + P) % P;
}
bool Cmp(int x, int y) {
int l = 0, r = n - 1;
while (l <= r) {
int Mid = l + r >> 1;
if (Get(x, x + Mid) == Get(y, y + Mid))
l = Mid + 1;
else
r = Mid - 1;
}
if (l == n) return 0;
return a[x + l] < a[y + l];
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 1; i <= n; i++)
a[i + n] = a[i] = s[i - 1] == '(' ? 0 : 1, sum += a[i] ? 1 : -1;
for (int i = 1; i <= n * 2; i++) h[i] = (1ll * h[i - 1] * H + a[i] + 1) % P;
p[0] = 1;
for (int i = 1; i <= n; i++) p[i] = 1ll * p[i - 1] * H % P;
int t = 0, T = 0;
for (int i = 1; i < n; i++) {
t += a[i] ? 1 : -1;
S.insert(t);
}
for (int i = 1; i <= n; i++) {
t += a[i + n - 1] ? 1 : -1;
S.insert(t);
int len = max((*S.rbegin()) - T, 0) * 2 - sum;
if (len < Ans) Ans = len, x = max((*S.rbegin()) - T, 0), g.clear();
if (len == Ans) g.push_back(i);
T += a[i] ? 1 : -1;
S.erase(S.find(T));
}
int pos = g[0];
for (int i = 1; i < g.size(); i++)
if (Cmp(g[i], pos)) pos = g[i];
for (int i = 1; i <= x; i++) putchar('(');
for (int i = pos; i <= pos + n - 1; i++) putchar(a[i] ? ')' : '(');
for (int i = 1; i <= Ans - x; i++) putchar(')');
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct SuffixArray {
int N;
vector<int> rank, lcp, sa;
string S;
SuffixArray(string S) : S(S) {
int i, h = 0;
vector<int> tmp, tr;
N = S.size();
rank.resize(N + 1);
sa.resize(N + 1);
tmp.resize(N + 1);
for (i = 0; i < N + 1; i++) sa[i] = i, rank[i] = i == N ? -1 : S[i];
for (int k = 1; k <= N; k <<= 1) {
auto pred = [k, this](int& a, int& b) -> bool {
return (rank[a] != rank[b]) ? (rank[a] < rank[b])
: (((a + k <= N) ? rank[a + k] : -1) <
((b + k <= N) ? rank[b + k] : -1));
};
auto pred2 = [k, this](int& a, int& b) -> bool {
return (((a + k <= N) ? rank[a + k] : -1) <
((b + k <= N) ? rank[b + k] : -1));
};
int x = 0;
if (k != 1) {
for (i = 1; i < N + 1; i++)
if (rank[sa[i]] != rank[sa[x]])
sort(sa.begin() + x, sa.begin() + i, pred), x = i;
}
sort(sa.begin() + x, sa.end(), pred);
for (i = 0; i < N + 1; i++)
tmp[sa[i]] = (i == 0) ? 0 : tmp[sa[i - 1]] + pred(sa[i - 1], sa[i]);
swap(rank, tmp);
}
}
};
string S;
int L;
int P;
int score[2500000];
int sd[4500000];
const int OFF = 2200000;
int mi = OFF;
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> S;
L = S.size();
S += S;
SuffixArray sa(S);
for (i = 0; i < L; i++) {
score[i + 1] = score[i] + ((S[i] == '(') ? 1 : -1);
sd[OFF + score[i + 1]]++;
mi = min(mi, OFF + score[i + 1]);
}
int dif = score[L];
int ret = -1;
for (i = 0; i < L; i++) {
if ((mi - OFF) - score[i] >= min(0, dif)) {
if (ret == -1 || sa.rank[i] <= sa.rank[ret]) ret = i;
}
score[i + L + 1] = score[i + L] + ((S[i + L] == '(') ? 1 : -1);
sd[OFF + score[i + L + 1]]++;
if (mi > OFF + score[i + L + 1]) mi = OFF + score[i + L + 1];
if (--sd[OFF + score[i + 1]] == 0 && mi == OFF + score[i + 1]) {
if (sd[OFF + score[i + 1] - 1])
mi--;
else
mi++;
}
}
if (dif < 0) cout << string(-dif, '(');
cout << S.substr(ret, L);
if (dif > 0) cout << string(dif, ')');
cout << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false);
for (i = 0; i < argc - 1; i++) s += argv[i + 1], s += '\n';
for (i = 0; i < s.size(); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long INF = ~0ULL >> 1;
const int mn = 2100000;
char s[mn];
int N, Index, l1, l2, SA[mn], wv[mn], wa[mn * 2], wb[mn * 2], Rank[mn * 2],
cnt[mn], Height[mn];
inline bool cmp(const int &a, const int &b) { return s[a] < s[b]; }
void Suffix_Array(int N, int M) {
int *x = wa, *y = wb, *t;
int p = 1;
N++;
for (int i = (0); i <= (N - 1); ++i) SA[i] = i;
sort(SA, SA + N, cmp);
for (int i = (1); i <= (N - 1); ++i)
x[SA[i]] = (s[SA[i]] > s[SA[i - 1]]) ? (p++) : x[SA[i - 1]];
for (int k = 1;; k <<= 1) {
int n = 0;
for (int i = (N - k); i < (N); ++i) y[n++] = i;
for (int i = (0); i < (N); ++i)
if (SA[i] >= k) y[n++] = SA[i] - k;
for (int i = (0); i < (N); ++i) wv[i] = x[y[i]];
for (int i = (0); i < (p); ++i) cnt[i] = 0;
for (int i = (0); i < (N); ++i) cnt[wv[i]]++;
for (int i = (1); i < (p); ++i) cnt[i] += cnt[i - 1];
for (int i = (N - 1); i >= (0); --i) SA[--cnt[wv[i]]] = y[i];
p = 1;
swap(x, y);
x[SA[0]] = 0;
for (int i = (1); i <= (N - 1); ++i) {
if (y[SA[i]] == y[SA[i - 1]] && y[SA[i] + k] == y[SA[i - 1] + k])
x[SA[i]] = p - 1;
else
x[SA[i]] = p++;
}
if (p == N) break;
}
N--;
}
pair<int, int> t[2000000 * 4 + 100000];
void build(int p, int l, int r) {
if (l == r) {
t[p] = (s[l] == '(') ? make_pair(1, 0) : make_pair(-1, -1);
return;
}
build(p << 1, l, l + r >> 1);
build(p << 1 | 1, (l + r >> 1) + 1, r);
t[p] =
make_pair(t[p << 1].first + t[p << 1 | 1].first,
min(t[p << 1].second, t[p << 1].first + t[p << 1 | 1].second));
}
pair<int, int> query(int p, int L, int R, int l, int r) {
if (L == l && R == r) return t[p];
int m = L + R >> 1;
if (r <= m)
return query(p << 1, L, m, l, r);
else if (l > m)
return query(p << 1 | 1, m + 1, R, l, r);
else {
pair<int, int> left = query(p << 1, L, m, l, m);
pair<int, int> right = query(p << 1 | 1, m + 1, R, m + 1, r);
return make_pair(left.first + right.first,
min(left.second, left.first + right.second));
}
}
int L, cntl, cntr, addl, addr;
int main() {
gets(s);
N = strlen(s);
for (int i = (N); i <= (2 * N - 1); ++i) s[i] = s[i - N];
L = N;
N <<= 1;
for (int i = (0); i < (L); ++i)
if (s[i] == '(')
cntl++;
else
cntr++;
if (cntl > cntr)
addr = cntl - cntr;
else
addl = cntr - cntl;
build(1, 0, N - 1);
for (int i = (0); i < (N); ++i)
if (s[i] == '(')
s[i] = 1;
else
s[i] = 2;
Suffix_Array(N, 3);
for (int i = (1); i <= (N); ++i)
if (SA[i] < L &&
addl + query(1, 0, N - 1, SA[i], SA[i] + L - 1).second >= 0) {
for (int k = (1); k <= (addl); ++k) putchar('(');
for (int k = (SA[i]); k <= (SA[i] + L - 1); ++k)
putchar((s[k] == 2) ? ')' : '(');
for (int k = (1); k <= (addr); ++k) putchar(')');
puts("");
return 0;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
static unsigned rnd() {
static int second = 124612741;
second ^= second << 13;
second ^= second >> 17;
return second ^= second << 5;
}
inline int fpow(int a, int st, int mod) {
int ans = 1;
while (st) {
if (st % 2) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
st /= 2;
}
return ans;
}
int invmod(int first, int second) {
int a = 1, b = 0, k;
for (; second; swap(first, second), swap(a, b)) {
k = first / second;
first -= second * k;
a -= b * k;
}
return a + max(b, 0);
}
struct Hash {
Hash() : x1(0), x2(0) {}
Hash(const int& x1, const int& x2) : x1(x1), x2(x2) {}
int x1, x2;
static int mod1, mod2;
static int p1, p2;
static int invp1, invp2;
static bool initCalled;
static const Hash ONE, ZERO, INVALID;
static Hash UNIT, INV_UNIT;
static bool prime(int a) {
if (a == 1) return 0;
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
static void init() {
if (initCalled) return;
initCalled = true;
mod1 = 1000000000 + rnd() % 10000000;
while (!prime(mod1)) ++mod1;
mod2 = 1000000000 + rnd() % 10000000;
while (mod2 == mod1 || !prime(mod2)) ++mod2;
invp1 = fpow(p1, mod1 - 2, mod1);
invp2 = fpow(p2, mod2 - 2, mod2);
INV_UNIT = Hash(invp1, invp2);
}
inline Hash& operator+=(const Hash& other) {
x1 += other.x1;
if (x1 >= Hash::mod1) x1 -= Hash::mod1;
x2 += other.x2;
if (x2 >= Hash::mod2) x2 -= Hash::mod2;
return *this;
}
inline Hash& operator-=(const Hash& other) {
x1 -= other.x1;
if (x1 < 0) x1 += Hash::mod1;
x2 -= other.x2;
if (x2 < 0) x2 += Hash::mod2;
return *this;
}
inline Hash& operator*=(const Hash& other) {
x1 = (long long)x1 * other.x1 % Hash::mod1;
x2 = (long long)x2 * other.x2 % Hash::mod2;
return *this;
}
inline Hash& operator*=(const int& other) {
x1 = (long long)x1 * other % Hash::mod1;
x2 = (long long)x2 * other % Hash::mod2;
return *this;
}
inline Hash& operator^=(const int& power) {
int st = power;
Hash ans(1, 1);
while (st) {
if (st % 2) ans *= *this;
x1 = (long long)x1 * x1 % Hash::mod1;
x2 = (long long)x2 * x2 % Hash::mod2;
st /= 2;
}
return *this;
}
inline bool operator==(const Hash& other) const {
return x1 == other.x1 && x2 == other.x2;
}
};
bool Hash::initCalled = false;
int Hash::mod1 = 0;
int Hash::mod2 = 0;
int Hash::p1 = 23561;
int Hash::p2 = 10000019;
int Hash::invp1 = -1;
int Hash::invp2 = -1;
const Hash Hash::ONE(1, 1);
const Hash Hash::ZERO(0, 0);
const Hash Hash::INVALID(-1, -1);
Hash Hash::UNIT(Hash::p1, Hash::p2);
Hash Hash::INV_UNIT(-1, -1);
inline Hash operator+(const Hash& a, const Hash& b) {
Hash ans(a.x1 + b.x1, a.x2 + b.x2);
if (ans.x1 >= Hash::mod1) ans.x1 -= Hash::mod1;
if (ans.x2 >= Hash::mod2) ans.x2 -= Hash::mod2;
return ans;
}
inline Hash operator-(const Hash& a, const Hash& b) {
Hash ans(a.x1 - b.x1, a.x2 - b.x2);
if (ans.x1 < 0) ans.x1 += Hash::mod1;
if (ans.x2 < 0) ans.x2 += Hash::mod2;
return ans;
}
inline Hash operator*(const Hash& a, const Hash& b) {
return Hash((long long)a.x1 * b.x1 % Hash::mod1,
(long long)a.x2 * b.x2 % Hash::mod2);
}
inline Hash operator*(const Hash& a, const int& b) {
return Hash((long long)a.x1 * b % Hash::mod1,
(long long)a.x2 * b % Hash::mod2);
}
inline Hash operator^(const Hash& a, const int& power) {
int st = power;
Hash ans(1, 1), cur(a);
while (st) {
if (st % 2) ans *= cur;
cur *= cur;
st /= 2;
}
return ans;
}
inline Hash fpow(const Hash& a, const int& power) { return a ^ power; }
inline Hash invmod(const Hash& a) {
return Hash(invmod(a.x1, Hash::mod1), invmod(a.x2, Hash::mod2));
}
template <class H>
struct HashString : public string {
HashString() : string() { precalc(0); }
HashString(const HashString& other) : string(other) { precalc(size()); }
HashString(HashString&& other)
: hh(std::move(other.hh)), string(std::move(other)) {
precalc(size());
}
HashString(const string& other) : string(other) {
precalc(size());
build();
}
HashString(string&& other) : string(std::move(other)) {
precalc(size());
build();
}
HashString(const char* other) : string(other) {
precalc(size());
build();
}
inline void clear() {
hh.clear();
string::clear();
}
inline static H getPow(int p) {
if (p < haveN) {
return pp[p];
} else {
return fpow(H::UNIT, p);
}
}
inline static H getInvPow(size_t p) {
if (p < invpp.size()) {
return invpp[p];
} else {
return fpow(H::INV_UNIT, p);
}
}
inline H getInvRegister(const H& p) const {
if (p == register_) {
return registerValue_;
} else {
register_ = p;
return registerValue_ = invmod(p);
}
}
static void precalc(int N = 0) {
Hash::init();
if (haveN >= N) return;
pp.resize(N);
invpp.resize(N);
if (!haveN) {
pp[0] = H::ONE;
invpp[0] = H::ONE;
haveN = 1;
}
for (int i = haveN; i < N; ++i) {
pp[i] = pp[i - 1] * H::UNIT;
invpp[i] = invpp[i - 1] * H::INV_UNIT;
}
haveN = N;
}
inline void build() {
int curSize = size();
if (haveN <= curSize) {
precalc(curSize);
}
for (int i = hh.size(); i < curSize; ++i) {
H pr = i ? hh.back() : H::ZERO;
hh.push_back(pr + getPow(i) * (*this)[i]);
}
}
inline H getHash(int pos, int len) const {
if (len <= 0) return H::ZERO;
const int S = size();
if (pos + len - 1 < S) {
H ans = hh[pos + len - 1];
if (pos) {
ans -= hh[pos - 1];
ans *= getInvPow(pos);
}
return ans;
} else {
H head = hh.back();
if (pos) {
head -= hh[pos - 1];
head *= getInvPow(pos);
}
int full = -1, en = -1;
H mid = H::ZERO;
int midlen = 0;
if (len <= S) {
en = pos + len - 1 - S;
H tail = hh[en];
full = 0;
return head + tail * getPow(S - pos);
} else {
en = (pos + len - 1) % S;
H tail = hh[en];
full = (len - (S - pos) - (en + 1)) / S;
mid = hh.back() * (H::ONE - getInvPow(full * S)) *
getInvRegister(H::ONE - getInvPow(S));
return head + mid * getPow(S - pos) + tail * getPow(len - (en + 1));
}
}
}
inline HashString& operator+=(const char& ch) {
string::operator+=(ch);
build();
return *this;
}
inline HashString& operator+=(const HashString& other) {
string::operator+=(other);
build();
return *this;
}
inline bool operator==(const HashString& other) const {
return hh.back() == other.hh.back();
}
inline bool operator<(const HashString& other) const {
int s1 = size();
int s2 = other.size();
const int S = min(s1, s2);
int l = 0, r = S + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
if (getHash(0, xx) == other.getHash(0, xx))
l = xx;
else
r = xx;
}
char c1 = 0, c2 = 0;
if (l < s1) c1 = (*this)[l];
if (l < s2) c2 = other[l];
return c1 < c2;
}
inline bool operator<=(const HashString& other) const {
return (*this == other) || (*this < other);
}
inline bool operator>(const HashString& other) const {
return !(*this == other) && !(*this < other);
}
inline bool operator>=(const HashString& other) const {
return !(*this < other);
}
inline bool operator!=(const HashString& other) const {
return !(*this == other);
}
inline void reserve(int N) {
hh.reserve(N);
string::reserve(N);
}
vector<H> hh;
static vector<H> pp, invpp;
private:
mutable H register_, registerValue_;
static int haveN;
};
template <>
int HashString<Hash>::haveN = 0;
template <>
vector<Hash> HashString<Hash>::pp = vector<Hash>();
template <>
vector<Hash> HashString<Hash>::invpp = vector<Hash>();
template <class H, bool cyclic = true>
struct HashStringPiece {
explicit HashStringPiece(const HashString<H>& s, int pos, int len)
: s(s), pos(pos), len(len), hash(H::INVALID) {}
inline H getHash() const {
if (hash == H::INVALID) hash = s.getHash(pos, len);
return hash;
}
inline H getPartialHash(int needLen) const { return s.getHash(pos, needLen); }
inline char getChar(int i) const {
i += pos;
const int S = s.size();
if (i < S) return s[i];
if (!cyclic) return 0;
i -= S;
if (i < S) return s[i];
return s[i % S];
}
const HashString<H>& s;
const int pos, len;
mutable H hash;
};
template <class H, class T>
char getHSPRangeChar(T beg, T en, int pos) {
for (T it = beg; it != en; ++it) {
if (pos < it->len) {
return it->getChar(pos);
}
pos -= it->len;
}
return 0;
}
template <class H, class T>
H getHSPRangeHash(T beg, T en, int len) {
H ans = H::ZERO;
int cur = 0;
for (T it = beg; it != en; ++it) {
if (len >= it->len) {
ans += it->getHash() * it->s.getPow(cur);
cur += it->len;
len -= it->len;
} else {
ans += it->getPartialHash(len) * it->s.getPow(cur);
break;
}
}
return ans;
}
int TB, IT;
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, int len1, T beg2, T en2, int len2) {
if (beg1 == en1 && beg2 == en2) return 0;
if (beg1 == en1) return -1;
if (beg2 == en2) return 1;
int l = 0, r = min(len1, len2) + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
auto h1 = getHSPRangeHash<H, T>(beg1, en1, xx);
auto h2 = getHSPRangeHash<H, T>(beg2, en2, xx);
if (h1 == h2)
l = xx;
else
r = xx;
}
char c1 = getHSPRangeChar<H, T>(beg1, en1, l);
char c2 = getHSPRangeChar<H, T>(beg2, en2, l);
if (c1 < c2)
return -1;
else if (c1 == c2)
return 0;
else
return 1;
}
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, T beg2, T en2) {
int len1 = 0;
for (T it = beg1; it != en1; ++it) {
len1 += it->len;
}
int len2 = 0;
for (T it = beg2; it != en2; ++it) {
len2 += it->len;
}
return compareHSPRanges<H, T>(beg1, en1, len1, beg2, en2, len2);
}
int a, b, c, d, n, m, k;
char str[1000002];
int bal[2000002];
HashString<Hash> s;
inline string build(pair<pair<int, int>, int> a) {
string ans = "";
for (int _n((a.first.first) - 1), i(0); i <= _n; i++) ans += '(';
for (int _n((n)-1), i(0); i <= _n; i++) {
int cur = a.second + i;
if (cur >= n) cur -= n;
ans += str[cur];
}
for (int _n((a.first.second) - 1), i(0); i <= _n; i++) ans += ')';
return ans;
}
HashString<Hash> op, cl;
inline bool better(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b,
const HashString<Hash>& s) {
HashStringPiece<Hash> A[3] = {HashStringPiece<Hash>(op, 0, a.first.first),
HashStringPiece<Hash>(s, a.second, n),
HashStringPiece<Hash>(cl, 0, a.first.second)};
HashStringPiece<Hash> B[3] = {HashStringPiece<Hash>(op, 0, b.first.first),
HashStringPiece<Hash>(s, b.second, n),
HashStringPiece<Hash>(cl, 0, b.first.second)};
int t = compareHSPRanges<Hash>(A, A + 3, B, B + 3);
if (t == -1)
return 1;
else
return 0;
}
int main() {
gets(str);
n = (int)strlen(str);
HashString<Hash> s(str);
HashString<Hash>::precalc(2 * n + 1);
op.reserve(n + 1);
cl.reserve(n + 1);
for (int _n((n)-1), i(0); i <= _n; i++) {
op += '(';
cl += ')';
}
c = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (str[i] == '(')
++c;
else
--c;
}
bal[0] = 0;
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i) bal[i] = bal[i - 1];
int cur = i;
if (i >= n) cur = i - n;
if (str[cur] == '(')
++bal[i];
else
--bal[i];
}
int blen = 1000000000;
pair<pair<int, int>, int> best = make_pair(make_pair(0, 0), 0);
stack<pair<int, int> > s1, s2;
for (int _n((n)-1), i(0); i <= _n; i++) {
int new_element = bal[i];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
for (int _n((n)-1), cyc(0); cyc <= _n; cyc++) {
int current_minimum = -1000000000;
if (s1.empty() || s2.empty())
current_minimum = s1.empty() ? s2.top().second : s1.top().second;
else
current_minimum = min(s1.top().second, s2.top().second);
int p = 0;
if (cyc) p = bal[cyc - 1];
int mn = current_minimum - p;
int beg = max(0, -mn);
int en = c + beg;
int len = beg + en + n;
if (len < blen ||
(len == blen && better(make_pair(make_pair(beg, en), cyc), best, s))) {
blen = len;
best = make_pair(make_pair(beg, en), cyc);
}
if (s2.empty()) {
while (!s1.empty()) {
int element = s1.top().first;
s1.pop();
int minima = s2.empty() ? element : min(element, s2.top().second);
s2.push(make_pair(element, minima));
}
}
s2.pop();
int new_element = bal[cyc + n];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
string ans = build(best);
printf("%s\n", ans.c_str());
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 16;
const int B = 233;
const int MO = 1e9 + 9;
string s, q;
int n, nn, a[N], b[N], t[N * 4], p[N], h[N];
void build(int k = 1, int l = 0, int r = nn) {
if (l == r) {
t[k] = b[l];
return;
}
int h = l + r >> 1;
build(k << 1, l, h);
build(k << 1 | 1, h + 1, r);
t[k] = min(t[k << 1], t[k << 1 | 1]);
}
int query(int L, int R, int k = 1, int l = 0, int r = nn) {
if (L <= l && r <= R) return t[k];
int h = l + r >> 1, o = N;
if (L <= h) o = min(o, query(L, R, k << 1, l, h));
if (h < R) o = min(o, query(L, R, k << 1 | 1, h + 1, r));
return o;
}
int geth(int l, int r) {
l--;
return (h[r] - (long long)h[l] * p[r - l] % MO + MO) % MO;
}
int f(int l1, int r1, int l2, int r2) {
if (geth(l1, r1) == geth(l2, r2)) return 0;
int x, y;
while (l1 < r1) {
x = l1 + r1 >> 1;
y = l2 + r2 >> 1;
if (geth(l1, x) == geth(l2, y))
l1 = x + 1, l2 = y + 1;
else
r1 = x, r2 = y;
}
return a[l1] > a[l2];
}
int main() {
int i, x, o, e, bl, br;
cin >> s;
n = s.length();
s = s + s;
nn = n + n;
p[0] = 1;
for (i = 1; i <= nn; i = i + 1) {
b[i] = b[i - 1];
if (s[i - 1] == '(')
a[i] = 0, b[i]++;
else
a[i] = 1, b[i]--;
p[i] = (long long)p[i - 1] * B % MO;
h[i] = ((long long)h[i - 1] * B % MO + a[i]) % MO;
}
bl = 0, br = b[n];
build();
x = 1, o = -query(0, n);
for (i = 2; i <= n; i = i + 1) {
e = b[i - 1] - query(i - 1, i + n - 1);
if (o > e) {
o = e;
x = i;
continue;
}
if (e == o && f(x, x + n - 1, i, i + n - 1)) x = i;
}
bl += o, br += o;
while (bl--) {
q += '(';
}
for (i = x; i < x + n; i = i + 1) q += s[i - 1];
while (br--) {
q += ')';
}
cout << q;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
string str;
int deq[2000666];
int sp[2000666];
long long v1[2000666], v2[2000666];
long long p1[2000666], p2[2000666];
int a[2000666];
vector<int> P;
bool comp(int i1, int i2, int mval) {
if (a[i1] != a[i2]) return a[i1] < a[i2];
int pos, step;
if (i1 > i2) swap(i1, i2);
long long m1 = p1[i2 - i1];
long long m2 = p2[i2 - i1];
for (step = 1; step <= mval; step <<= 1)
;
for (pos = 0; step; step >>= 1)
if (i2 + pos + step <= mval + mval) {
long long val1_first =
(v1[i1] - v1[i1 + pos + step] + ((long long)666013)) %
((long long)666013);
long long val2_first =
(v2[i1] - v2[i1 + pos + step] + ((long long)111111)) %
((long long)111111);
long long val1_second =
((v1[i2] - v1[i2 + pos + step] + ((long long)666013)) * m1) %
((long long)666013);
long long val2_second =
((v2[i2] - v2[i2 + pos + step] + ((long long)111111)) * m2) %
((long long)111111);
if (val1_first == val1_second && val2_first == val2_second) pos += step;
}
return a[i1 + pos] < a[i2 + pos];
}
int main() {
cin >> str;
int N = str.size(), suma = 0;
int i;
for (i = 0; i < N; ++i) {
a[i + 1] = (str[i] == '(' ? 1 : 0);
suma += (a[i + 1] == 1 ? 1 : -1);
a[i + N + 1] = a[i + 1];
}
int val_need = min(suma, 0);
for (i = 1; i <= N + N; ++i) sp[i] = sp[i - 1] + (a[i] == 1 ? 1 : -1);
int j = 0, st = 1, dr = 0;
for (i = 1; i <= N; ++i) {
while (j < i + N - 1) {
++j;
while (dr >= st && sp[deq[dr]] >= sp[j]) --dr;
deq[++dr] = j;
}
while (st <= dr && deq[st] < i) ++st;
if (sp[deq[st]] - sp[i - 1] >= val_need) P.push_back(i);
}
p1[0] = 1;
p2[0] = 1;
for (i = 1; i <= N + N; ++i) {
p1[i] = (p1[i - 1] * 2) % ((long long)666013);
p2[i] = (p2[i - 1] * (long long)2) % ((long long)111111);
}
for (i = N + N; i > 0; --i) {
v1[i] = (v1[i + 1] + a[i] * p1[N + N - i]) % ((long long)666013);
v2[i] = (v2[i + 1] + a[i] * p2[N + N - i]) % ((long long)111111);
}
int NP = P.size();
int last_cand = P[0];
for (i = 1; i < NP; ++i) {
bool X = comp(last_cand, P[i], N);
if (X == true) last_cand = P[i];
}
for (; suma < 0; ++suma) cout << "(";
for (i = last_cand; i <= last_cand + N - 1; ++i)
if (a[i])
cout << '(';
else
cout << ')';
for (; suma > 0; --suma) cout << ")";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100;
int n;
char s[MAXN];
int balance[MAXN];
int pref[MAXN];
int pos[MAXN];
int sa[MAXN], rnk[MAXN], cnt[MAXN], tmp[MAXN];
int ranks;
void build() {
for (int i = 0; i < n; ++i) ++cnt[(int)s[i]];
for (int i = 1; i < 256; ++i) cnt[i] += cnt[i - 1];
for (int i = 0; i < n; ++i) sa[--cnt[(int)s[i]]] = i;
rnk[sa[0]] = 0;
ranks = 1;
for (int i = 1; i < n; ++i) {
if (s[sa[i]] != s[sa[i - 1]])
rnk[sa[i]] = ranks++;
else
rnk[sa[i]] = rnk[sa[i - 1]];
}
memset(cnt, 0, sizeof(int) * 256);
for (int step = 1; step < n; step <<= 1) {
for (int i = 0; i < n; ++i) {
tmp[i] = sa[i] - step;
if (tmp[i] < 0) tmp[i] += n;
}
for (int i = 0; i < n; ++i) ++cnt[rnk[i]];
for (int i = 1; i < ranks; ++i) cnt[i] += cnt[i - 1];
for (int i = n - 1; i > -1; --i) sa[--cnt[rnk[tmp[i]]]] = tmp[i];
memset(cnt, 0, sizeof(int) * ranks);
tmp[sa[0]] = 0;
ranks = 1;
for (int i = 1; i < n; ++i) {
if (rnk[sa[i]] != rnk[sa[i - 1]] ||
rnk[(sa[i] + step) % n] != rnk[(sa[i - 1] + step) % n])
tmp[sa[i]] = ranks++;
else
tmp[sa[i]] = tmp[sa[i - 1]];
}
memcpy(rnk, tmp, sizeof(int) * n);
}
}
int main() {
scanf("%s", s);
n = strlen(s);
build();
for (int i = 0; i < n; ++i) pos[sa[i]] = i;
for (int i = 0; i < n; ++i) {
balance[i] = s[i] == '(' ? 1 : -1;
pref[i] = balance[i];
if (i) {
balance[i] += balance[i - 1];
pref[i] = min(pref[i - 1], balance[i]);
}
}
int suff = 1e8;
int bestShift = -1;
for (int i = n - 1; i > -1; --i) {
int tmp = min(suff - balance[i], balance[n - 1] - balance[i] + pref[i]);
if (tmp >= min(0, balance[n - 1]))
if (bestShift == -1 || pos[bestShift] > pos[(i + 1) % n])
bestShift = (i + 1) % n;
suff = min(suff, balance[i]);
}
for (int i = 0; i < -balance[n - 1]; ++i) putchar('(');
for (int i = 0; i < n; ++i) {
putchar(s[(bestShift + i) % n]);
}
for (int i = 0; i < balance[n - 1]; ++i) putchar(')');
puts("");
return 0;
}
| 7 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.