text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[188];
int dist[188][188];
int n, m;
int dp[188][188];
int best[188];
void dfs(int x, int p) {
for (int i = 0; i < v[x].size(); i++) {
int t = v[x][i];
if (t != p) dfs(t, x);
}
best[x] = 1;
for (int c = 1; c <= n; c++) {
for (int j = 0; j < v[x].size(); j++) {
int t = v[x][j];
if (t == p) continue;
dp[x][c] += min(dp[t][c], dp[t][best[t]] + m);
}
dp[x][c] += dist[x][c];
if (dp[x][c] < dp[x][best[x]]) best[x] = c;
}
}
int bel[188];
void process(int x, int p, int c) {
bel[x] = c;
for (int i = 0; i < v[x].size(); i++) {
int t = v[x][i];
if (t == p) continue;
if (dp[t][c] < dp[t][best[t]] + m)
process(t, x, c);
else
process(t, x, best[t]);
}
}
int cost[188];
int main() {
cin >> n >> m;
memset(dist, 0x3f, sizeof(dist));
for (int i = 1; i < n; i++) cin >> cost[i];
dist[1][1] = 0;
for (int i = 1; i < n; i++) {
dist[i + 1][i + 1] = 0;
int x, y;
scanf("%d%d", &x, &y);
dist[x][y] = dist[y][x] = 1;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
dist[j][k] = min(dist[j][i] + dist[i][k], dist[j][k]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dist[i][j] = cost[dist[i][j]];
dfs(1, 0);
cout << dp[1][best[1]] + m << "\n";
process(1, 0, best[1]);
for (int i = 1; i <= n; i++) cout << bel[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[200][200], dis[200][200], ans[200], d[200], t;
int pre[200], r;
vector<int> e[200];
void init() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[dis[u][i]] + t;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == fa) continue;
dfs(v, u);
for (int j = 1; j <= n; j++) dp[u][j] += min(dp[v][ans[v]], dp[v][j] - t);
}
ans[u] = 1;
for (int i = 2; i <= n; i++)
if (dp[u][ans[u]] > dp[u][i]) ans[u] = i;
}
void print(int u, int fa, int x) {
pre[u] = x;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == fa) continue;
if (dp[v][ans[v]] < dp[v][x] - t)
print(v, u, ans[v]);
else
print(v, u, x);
}
}
int main() {
scanf("%d%d", &n, &t);
memset(dis, 0x3f3f3f3f, sizeof(dis));
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
dis[a][b] = dis[b][a] = 1;
}
init();
dfs(1, 0);
printf("%d\n", dp[1][ans[1]]);
print(1, 0, ans[1]);
for (int i = 1; i <= n; i++) printf("%d ", pre[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> e[301];
long long n, k, d[301], f[301][301], dp[301][301], mini[301], wwk[301];
void tr_dp(long long x, long long dd) {
for (long long i = 1; i <= n; i++) dp[x][i] = d[f[x][i]] + k;
for (long long i = 0; i < e[x].size(); i++) {
long long y = e[x][i];
if (dd == y) continue;
tr_dp(y, x);
for (long long j = 1; j <= n; j++)
dp[x][j] += min(dp[y][mini[y]], dp[y][j] - k);
}
mini[x] = 1;
for (long long i = 2; i <= n; i++)
if (dp[x][i] < dp[x][mini[x]]) mini[x] = i;
}
void tr_put(long long x, long long dd, long long ff) {
wwk[x] = ff;
for (long long i = 0; i < e[x].size(); i++) {
long long y = e[x][i];
if (y == dd) continue;
if (dp[y][mini[y]] < dp[y][ff] - k)
tr_put(y, x, mini[y]);
else
tr_put(y, x, ff);
}
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i < n; i++) scanf("%lld", &d[i]);
memset(f, 0x3f3f3f3f, sizeof(f));
for (long long i = 1; i <= n; i++) f[i][i] = 0;
for (long long i = 1; i < n; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
f[a][b] = 1;
f[b][a] = 1;
}
for (long long k = 1; k <= n; k++)
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++)
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
tr_dp(1, 0);
printf("%lld\n", dp[1][mini[1]]);
tr_put(1, 0, mini[1]);
for (long long i = 1; i <= n; i++) printf("%lld ", wwk[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> gh[205];
int cost[205];
int f[205][205];
int dis[205][205];
int best[205];
int sel[205];
vector<pair<int, int> > vec[205][205];
int col[205];
void dfs(int u, int fa) {
for (int i = 0; i < gh[u].size(); i++) {
int v = gh[u][i];
if (v == fa) continue;
dfs(v, u);
}
for (int i = 1; i <= n; i++) {
int sum = 0;
for (int j = 0; j < gh[u].size(); j++) {
int v = gh[u][j];
if (v == fa) continue;
if (f[v][i] - k < best[v]) {
vec[u][i].push_back(make_pair(v, i));
} else {
vec[u][i].push_back(make_pair(v, sel[v]));
}
sum += min(f[v][i] - k, best[v]);
}
f[u][i] = sum + k + cost[dis[u][i]];
}
for (int i = 1; i <= n; i++) {
if (dis[1][i] == dis[1][u] + dis[u][i]) {
if (f[u][i] < best[u]) {
best[u] = f[u][i];
sel[u] = i;
}
}
}
}
void gao(int u, int tv) {
col[tv] = 1;
for (int i = 0; i < vec[u][tv].size(); i++) {
pair<int, int> tmp = vec[u][tv][i];
gao(tmp.first, tmp.second);
}
}
int pre[205];
int dd[205];
int key[205];
bool inq[205];
queue<int> Q;
int calc(int u) {
if (key[u] != -1) {
return key[u];
}
return key[u] = calc(pre[u]);
}
void spfa() {
for (int i = 1; i <= n; i++) {
dd[i] = (int)1e9;
pre[i] = -1;
key[i] = -1;
}
for (int i = 1; i <= n; i++) {
if (col[i]) {
pre[i] = i;
dd[i] = 0;
Q.push(i);
inq[i] = 1;
key[i] = i;
}
}
while (!Q.empty()) {
int u = Q.front();
Q.pop();
inq[u] = 0;
for (int i = 0; i < gh[u].size(); i++) {
int v = gh[u][i];
if (dd[v] > dd[u] + 1) {
dd[v] = dd[u] + 1;
pre[v] = u;
if (!inq[v]) {
inq[v] = 1;
Q.push(v);
}
}
}
}
for (int i = 1; i <= n; i++) {
calc(i);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n - 1; i++) {
cin >> cost[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dis[i][j] = (int)1e9;
f[i][j] = (int)1e9;
}
best[i] = (int)1e9;
}
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
gh[a].push_back(b);
gh[b].push_back(a);
dis[a][b] = 1;
dis[b][a] = 1;
}
for (int i = 1; i <= n; ++i) {
dis[i][i] = 0;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
dfs(1, -1);
cout << best[1] << endl;
gao(1, sel[1]);
spfa();
for (int i = 1; i <= n; i++) {
cout << key[i] << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 209;
int f[maxn][maxn], b[maxn], c[maxn], d[maxn], g[maxn][maxn];
vector<int> e[maxn];
int n, K, u, v;
void dfs(int u, int fa) {
for (int i = (0); i <= int(e[u].size() - 1); i++)
if (e[u][i] != fa) dfs(e[u][i], u);
for (int i = (1); i <= int(n); i++) {
for (int j = (0); j <= int(e[u].size() - 1); j++)
if (e[u][j] != fa)
f[u][i] += min(f[e[u][j]][i], f[e[u][j]][b[e[u][j]]] + K);
}
b[u] = 1;
for (int i = (2); i <= int(n); i++)
if (f[u][i] < f[u][b[u]]) b[u] = i;
}
void dfs2(int u, int fa, int d) {
c[u] = d;
for (int i = (0); i <= int(e[u].size() - 1); i++)
if (e[u][i] != fa)
dfs2(e[u][i], u,
(f[e[u][i]][d] < f[e[u][i]][b[e[u][i]]] + K ? d : b[e[u][i]]));
}
int main() {
scanf("%d%d", &n, &K);
for (int i = (1); i <= int(n - 1); i++) scanf("%d", &d[i]);
for (int i = (1); i <= int(n); i++)
for (int j = (1); j <= int(n); j++) g[i][j] = (i != j) << 20;
for (int i = (1); i <= int(n - 1); i++) {
scanf("%d%d", &u, &v);
g[u][v] = g[v][u] = 1;
e[u].push_back(v);
e[v].push_back(u);
}
for (int k = (1); k <= int(n); k++)
for (int i = (1); i <= int(n); i++)
for (int j = (1); j <= int(n); j++)
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
for (int i = (1); i <= int(n); i++)
for (int j = (1); j <= int(n); j++) f[i][j] = d[g[i][j]];
dfs(1, 0);
dfs2(1, 0, b[1]);
printf("%d\n", f[1][b[1]] + K);
for (int i = (1); i <= int(n); i++) printf("%d ", c[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9 + 29;
const int N = 2e2 + 22;
int dist[N][N], d[N], dp[N], ans[N], dp2[N][N];
set<int> vert[N];
vector<int> g[N];
void setdfs(int v, int p) {
for (int u : g[v]) {
if (u != p) setdfs(u, v);
}
vert[v].insert(v);
for (int x : vert[v]) {
vert[p].insert(x);
}
}
int dfs2(int v, int p, int x, int flg) {
int sum = d[dist[v][x]];
for (int u : g[v]) {
if (u != p) {
if (flg && vert[u].count(x))
sum += dfs2(u, v, x, 1);
else
sum += dfs2(u, v, x, 0);
}
}
if (!flg) sum = min(sum, dp[v]);
return sum;
}
void dfs(int v, int p) {
for (int u : g[v]) {
if (u != p) dfs(u, v);
}
int ret = inf;
for (int x : vert[v]) {
ret = min(ret, dfs2(v, p, x, 1));
}
dp[v] = ret;
return;
}
void backTrack(int v, int p, int x, int flg) {
if (!flg) {
if (dfs2(v, p, x, 1) <= dp[v]) {
ans[v] = x;
for (int u : g[v]) {
if (u != p) backTrack(u, v, x, 0);
}
return;
}
for (int y : vert[v]) {
if (dfs2(v, p, y, 1) == dp[v]) {
return backTrack(v, p, y, 1);
}
}
}
ans[v] = x;
for (int u : g[v]) {
if (u != p) {
if (vert[u].count(x))
backTrack(u, v, x, 1);
else
backTrack(u, v, x, 0);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> d[i];
}
memset(dist, 0x3f, sizeof(dist));
dist[1][1] = 0;
for (int i = 2; i <= n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
dist[i][i] = 0;
dist[u][v] = dist[v][u] = 1;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
setdfs(1, 0);
dfs(1, 0);
backTrack(1, 0, 1, 0);
cout << dp[1] << endl;
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[202], c[201], dis[201][201], f[201][202], ans[202];
void dfs(int x, int fa) {
int i, j;
for (i = 1; i <= n; i++) f[x][i] = c[dis[x][i]] + m;
for (i = 1; i <= n; i++)
if (dis[x][i] == 1 && i != fa) {
dfs(i, x);
for (j = 1; j <= n; j++) f[x][j] += min(f[i][j] - m, f[i][ans[i]]);
}
ans[x] = 1;
for (i = 2; i <= n; i++)
if (f[x][i] < f[x][ans[x]]) ans[x] = i;
}
void get(int x, int fa, int now) {
a[x] = now;
int i;
for (i = 1; i <= n; i++)
if (dis[x][i] == 1 && i != fa) {
if (f[i][now] - m < f[i][ans[i]])
get(i, x, now);
else
get(i, x, ans[i]);
}
}
int main() {
int i, j, x, y, k;
scanf("%d%d", &n, &m);
for (i = 1; i < n; i++) scanf("%d", &c[i]);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i == j)
dis[i][j] = 0;
else
dis[i][j] = 1e9;
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
dis[x][y] = dis[y][x] = 1;
}
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
printf("%d\n", f[1][ans[1]]);
get(1, 0, ans[1]);
for (i = 1; i <= n; i++) printf("%d ", a[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, pr[190];
long long dp1[190][190], dp2[190][190];
int pdp[190][190];
vector<int> fo[190], ofo[190];
void init_dp(int vr) {
long long CV = 10000000000000000LL;
int POS = -1;
for (int L = 0; L <= N; ++L) {
int i;
dp1[vr][L] = 10000000000000000LL;
if (L > 0) dp1[vr][L] = min(dp1[vr][L], dp1[vr][0] + K);
long long CUR = pr[L];
if (L + 1 <= N) {
for (i = 0; i < fo[vr].size(); ++i) CUR += dp1[fo[vr][i]][L + 1];
if (dp1[vr][L] > CUR) dp1[vr][L] = CUR;
}
if (L + 1 <= N && L > 0) {
long long neo = pr[L], T;
for (i = 0; i < fo[vr].size(); ++i) neo += dp1[fo[vr][i]][L + 1];
for (i = 0; i < fo[vr].size(); ++i) {
if (CV > (T = neo - dp1[fo[vr][i]][L + 1] + dp2[fo[vr][i]][L - 1])) {
CV = T;
POS = L;
}
}
}
dp1[vr][L] = min(dp1[vr][L], CV);
pdp[vr][L] = POS;
if (L == 0) {
dp2[vr][L] = K;
for (i = 0; i < fo[vr].size(); ++i) dp2[vr][L] += dp1[fo[vr][i]][1];
} else {
dp2[vr][L] = dp2[vr][L - 1];
if (L + 1 <= N && L > 0) {
long long neo = pr[L];
for (i = 0; i < fo[vr].size(); ++i) neo += dp1[fo[vr][i]][L + 1];
for (i = 0; i < fo[vr].size(); ++i)
dp2[vr][L] = min(dp2[vr][L],
neo - dp1[fo[vr][i]][L + 1] + dp2[fo[vr][i]][L - 1]);
}
}
}
}
bool PUT[190];
void parse_dp2(int vr, int L);
void parse_dp1(int vr, int L) {
int i, j;
if (L > 0 && dp1[vr][L] == dp1[vr][0] + K) {
PUT[vr] = true;
parse_dp1(vr, 0);
return;
}
long long CUR = pr[L];
if (L + 1 <= N) {
for (i = 0; i < fo[vr].size(); ++i) CUR += dp1[fo[vr][i]][L + 1];
if (dp1[vr][L] == CUR) {
for (i = 0; i < fo[vr].size(); ++i) parse_dp1(fo[vr][i], L + 1);
return;
}
}
if (pdp[vr][L] >= 0) {
int l = pdp[vr][L];
long long neo = pr[l];
for (i = 0; i < fo[vr].size(); ++i) neo += dp1[fo[vr][i]][l + 1];
for (i = 0; i < fo[vr].size(); ++i)
if (dp1[vr][L] == neo - dp1[fo[vr][i]][l + 1] + dp2[fo[vr][i]][l - 1])
break;
for (j = 0; j < fo[vr].size(); ++j)
if (j != i)
parse_dp1(fo[vr][j], l + 1);
else
parse_dp2(fo[vr][j], l - 1);
}
}
void parse_dp2(int vr, int L) {
int i, j;
if (L == 0) {
PUT[vr] = true;
for (i = 0; i < fo[vr].size(); ++i) parse_dp1(fo[vr][i], 1);
} else {
if (dp2[vr][L] == dp2[vr][L - 1]) {
parse_dp2(vr, L - 1);
return;
}
if (L + 1 <= N && L > 0) {
long long neo = pr[L];
for (i = 0; i < fo[vr].size(); ++i) neo += dp1[fo[vr][i]][L + 1];
for (i = 0; i < fo[vr].size(); ++i)
if (dp2[vr][L] == neo - dp1[fo[vr][i]][L + 1] + dp2[fo[vr][i]][L - 1])
break;
for (j = 0; j < fo[vr].size(); ++j)
if (i != j)
parse_dp1(fo[vr][j], L + 1);
else
parse_dp2(fo[vr][j], L - 1);
}
}
}
void dfs(int vr, int par) {
if (par != -1) fo[vr].erase(find(fo[vr].begin(), fo[vr].end(), par));
for (int i = 0; i < fo[vr].size(); ++i) dfs(fo[vr][i], vr);
init_dp(vr);
}
int used[190], ust;
int Q[200], QL, QR;
int BFS(int vr) {
++ust;
QL = QR = 0;
Q[QR++] = vr;
used[vr] = ust;
while (QL < QR) {
vr = Q[QL++];
if (PUT[vr]) return vr;
for (int i = 0; i < ofo[vr].size(); ++i)
if (used[ofo[vr][i]] != ust) {
used[ofo[vr][i]] = ust;
Q[QR++] = ofo[vr][i];
}
}
}
int main() {
int i, j, k, l, x, y;
scanf("%d%d", &N, &K);
for (i = 1; i < N; ++i) scanf("%d", &pr[i]);
for (i = 1; i < N; ++i) {
scanf("%d%d", &x, &y);
--x;
--y;
fo[x].push_back(y);
fo[y].push_back(x);
ofo[x].push_back(y);
ofo[y].push_back(x);
}
dfs(0, -1);
parse_dp1(0, N);
cout << dp1[0][N] << '\n';
for (i = 0; i < N; ++i) printf("%d%c", BFS(i) + 1, (i == N - 1) ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
vector<int> g[310];
int n, k, d[310], dp[310][310], dis[310][310], ans[310];
void dfs(int x, int fa = 0) {
for (int i = 1; i <= n; i++) dp[x][i] = d[dis[x][i]];
int nn = g[x].size() - 1;
for (int xx = 0; xx <= nn; xx++) {
int to = g[x][xx];
if (to != fa) {
dfs(to, x);
for (int i = 1; i <= n; i++) {
int mn = 0x3f3f3f3f;
for (int j = 1; j <= n; j++)
if (dis[x][i] <= dis[x][j] && dis[to][j] <= dis[to][i])
mn = min(mn, dp[to][j]);
dp[x][i] += mn;
}
}
}
}
void dfs1(int x, int i, int fa = 0) {
if (x == i) ans[x] = x;
int nn = g[x].size() - 1;
for (int xx = 0; xx <= nn; xx++) {
int to = g[x][xx];
if (to != fa) {
pair<int, int> mn = make_pair(0x3f3f3f3f, 0);
for (int j = 1; j <= n; j++)
if (dis[x][i] <= dis[x][j] && dis[to][j] <= dis[to][i])
mn = min(mn, make_pair(dp[to][j], j));
dfs1(to, mn.second, x);
}
}
}
int main() {
n = read();
k = read();
d[0] = k;
for (int i = 1; i <= n - 1; i++) d[i] = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dis[i][j] = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i <= n - 1; i++) {
int u = read();
int v = read();
g[u].push_back(v);
g[v].push_back(u);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1);
int t = min_element(dp[1] + 1, dp[1] + n + 1) - dp[1];
dfs1(1, t);
printf("%d\n", dp[1][t]);
for (int i = 1; i <= n; i++) {
if (!ans[i])
for (int j = 1; j <= n; j++)
if (ans[j] == j && (!ans[i] || dis[ans[i]][i] > dis[j][i])) ans[i] = j;
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, K, d[190], dis[190][190], m[190][190], dp[190][190], ans[190], path[190];
void dfs(int np, int fa) {
for (int i = 1; i <= n; i++) dp[np][i] = d[dis[np][i]] + K;
for (int i = 1; i <= n; i++) {
if (m[np][i] && i != fa) {
dfs(i, np);
for (int j = 1; j <= n; j++)
dp[np][j] += min(dp[i][ans[i]], dp[i][j] - K);
}
}
ans[np] = 1;
for (int i = 2; i <= n; i++)
if (dp[np][i] < dp[np][ans[np]]) ans[np] = i;
}
void output(int np, int fa, int x) {
path[np] = x;
for (int i = 1; i <= n; i++) {
if (m[np][i] && i != fa) {
if (dp[i][ans[i]] < dp[i][x] - K)
output(i, np, ans[i]);
else
output(i, np, x);
}
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
m[u][v] = m[v][u] = 1;
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
dfs(1, 0);
printf("%d\n", dp[1][ans[1]]);
output(1, 0, ans[1]);
for (int i = 1; i <= n; i++) printf("%d ", path[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, cnt;
int d[200], ans[200], cho[200], head[200], f[200][200], w[200][200],
dp[200][200];
void dfs1(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[f[u][i]] + k;
for (int v = 1; v <= n; v++) {
if (!w[u][v]) continue;
if (v == fa) continue;
dfs1(v, u);
for (int i = 1; i <= n; i++) dp[u][i] += min(dp[v][ans[v]], dp[v][i] - k);
}
ans[u] = 1;
for (int i = 2; i <= n; i++)
if (dp[u][i] < dp[u][ans[u]]) ans[u] = i;
}
void dfs2(int u, int fa, int i) {
cho[u] = i;
for (int v = 1; v <= n; v++) {
if (!w[u][v]) continue;
if (v == fa) continue;
if (dp[v][ans[v]] < dp[v][i] - k)
dfs2(v, u, ans[v]);
else
dfs2(v, u, i);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
int a, b;
memset(f, 0x3f3f3f3f, sizeof(f));
for (int i = 1; i <= n; i++) f[i][i] = 0;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
w[a][b] = w[b][a] = 1;
f[a][b] = f[b][a] = 1;
}
for (int p = 1; p <= n; p++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = min(f[i][p] + f[p][j], f[i][j]);
dfs1(1, 0);
dfs2(1, 0, ans[1]);
printf("%d\n", dp[1][ans[1]]);
for (int i = 1; i <= n; i++) printf("%d ", cho[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 200;
struct Edge {
int v, nxt;
Edge() {}
Edge(int v0, int n0) {
v = v0;
nxt = n0;
}
};
Edge e[Maxn * 2];
int head[Maxn];
int nume;
inline void addEdge(int u, int v) {
e[++nume] = Edge(v, head[u]);
head[u] = nume;
e[++nume] = Edge(u, head[v]);
head[v] = nume;
}
int len[Maxn][Maxn];
int cur;
void dfs_Len(int x, int fa, int lens) {
len[cur][x] = lens;
for (int i = head[x]; i; i = e[i].nxt) {
int v = e[i].v;
if (v != fa) {
dfs_Len(v, x, lens + 1);
}
}
}
int n;
long long dist[Maxn];
long long K;
long long f[Maxn][Maxn];
long long ans[Maxn];
const int Inf = 2100000000;
void DP(int x, int fa) {
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].v != fa) DP(e[i].v, x);
for (int j = 1; j <= n; j++) {
f[x][j] = K + dist[len[x][j]];
for (int i = head[x]; i; i = e[i].nxt) {
int v = e[i].v;
if (v != fa) f[x][j] += min(f[v][j] - K, ans[v]);
}
ans[x] = min(ans[x], f[x][j]);
}
}
int ind[Maxn];
bool dfsg(int x, int fa, int cost, int j);
bool dfs(int x, int fa, int cost) {
for (int j = 1; j <= n; j++) {
if (f[x][j] == cost) {
int tmpInd = ind[x];
ind[x] = j;
bool flag = true;
for (int i = head[x]; i; i = e[i].nxt) {
int v = e[i].v;
if (v != fa) {
if (f[v][j] - K < ans[v]) {
flag = flag && dfsg(v, x, f[v][j], j);
} else {
flag = flag && dfs(v, x, ans[v]);
}
}
}
if (flag) return true;
ind[x] = tmpInd;
}
}
return false;
}
bool dfsg(int x, int fa, int cost, int j) {
int tmpInd = ind[x];
ind[x] = j;
bool flag = true;
for (int i = head[x]; i; i = e[i].nxt) {
int v = e[i].v;
if (v != fa) {
if (f[v][j] - K < ans[v]) {
flag = flag && dfsg(v, x, f[v][j], j);
} else {
flag = flag && dfs(v, x, ans[v]);
}
}
}
if (flag) return true;
ind[x] = tmpInd;
return false;
}
int main() {
scanf("%d%I64d", &n, &K);
for (int i = 1; i < n; i++) scanf("%I64d", &dist[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
addEdge(x, y);
}
for (int i = 1; i <= n; i++) {
cur = i;
dfs_Len(i, 0, 0);
}
for (int i = 1; i <= n; i++) {
ans[i] = Inf;
for (int j = 1; j <= n; j++) {
f[i][j] = Inf;
}
}
DP(1, 0);
dfs(1, 0, ans[1]);
cout << ans[1] << endl;
for (int i = 1; i <= n; i++) cout << ind[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200;
const int INF = 0x3f3f3f3f;
vector<int> e[MAXN];
int w[MAXN][MAXN], d[MAXN];
int center[MAXN], dp[MAXN][MAXN];
int n, k;
void floyd() {
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
if (w[i][k] == INF) {
continue;
}
for (int j = 0; j < n; j++) {
if (w[k][j] == INF) {
continue;
}
w[i][j] = min(w[i][j], w[i][k] + w[k][j]);
}
}
}
}
void dfs(int u, int p) {
for (vector<int>::iterator it = e[u].begin(); it != e[u].end(); it++) {
int v = *it;
if (v != p) {
dfs(v, u);
}
}
center[u] = 0;
for (int f = 0; f < n; f++) {
dp[u][f] = d[w[u][f]];
for (vector<int>::iterator it = e[u].begin(); it != e[u].end(); it++) {
int v = *it;
if (v != p) {
dp[u][f] += min(dp[v][f], dp[v][center[v]] + k);
}
}
if (dp[u][f] < dp[u][center[u]]) {
center[u] = f;
}
}
}
void retrieve(int u, int p) {
for (vector<int>::iterator it = e[u].begin(); it != e[u].end(); it++) {
int v = *it;
if (v != p) {
int f = center[u];
if (dp[v][f] < dp[v][center[v]] + k) {
center[v] = f;
}
retrieve(v, u);
}
}
}
int main() {
for (; ~scanf("%d%d", &n, &k);) {
fill(w[0], w[n], INF);
for (int i = 0; i < n; i++) {
e[i].clear();
w[i][i] = 0;
}
for (int i = 1; i < n; i++) {
scanf("%d", &d[i]);
}
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
e[u].push_back(v);
e[v].push_back(u);
w[u][v] = w[v][u] = 1;
}
floyd();
dfs(0, 0);
retrieve(0, 0);
printf("%d\n", dp[0][center[0]] + k);
for (int i = 0; i < n; i++) {
if (i > 0) {
putchar(' ');
}
printf("%d", center[i] + 1);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int g[555], nxt[555], c[555], nm;
int n;
int v[555], F[555][555], DF[555][555], G[555][555], FM[555], DFM[555];
int fa[555], ans[555];
void addedge(int x, int y) {
g[nm] = y;
nxt[nm] = c[x];
c[x] = nm;
nm++;
}
inline int cmin(int x, int y) { return x < y ? x : y; }
void Fate(int i, int p) {
fa[i] = p;
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j != p) Fate(j, i);
}
for (int j = (0); j <= (n - 1); ++j) {
F[i][j] = 1000000000;
G[i][j] = v[j];
}
G[i][n] = G[i][n + 1] = G[i][0] = 1000000000;
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == p) continue;
for (int e = (1); e <= (n - 1); ++e)
if (cmin(G[j][e + 1], FM[j]) + G[i][e] < 1000000000)
G[i][e] += cmin(G[j][e + 1], FM[j]);
else
G[i][e] = 1000000000;
}
F[i][0] = v[0];
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == p) continue;
for (int e = (1); e <= (n - 1); ++e) {
int res = F[j][e - 1] + v[e];
for (int k2 = c[i]; ~k2; k2 = nxt[k2]) {
int j2 = g[k2];
if (j2 == j || j2 == p) continue;
int rs = FM[j2];
if (e + 1 <= n - 1) rs = cmin(rs, G[j2][e + 1]);
res += rs;
}
if (res < F[i][e]) {
F[i][e] = res;
DF[i][e] = j;
}
}
F[i][0] += cmin(FM[j], G[j][1]);
}
FM[i] = 1000000000;
for (int e = (n - 2); e >= (1); --e)
if (G[i][e] > G[i][e + 1]) puts("CAONIBA");
for (int e = (0); e <= (n - 1); ++e)
if (F[i][e] < FM[i]) {
FM[i] = F[i][e];
DFM[i] = e;
}
}
void output(int i, int e, int t, int pp) {
if (t == 0) {
if (e > 0) {
output(DF[i][e], e - 1, 0, 0);
ans[i] = ans[DF[i][e]];
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == fa[i] || j == DF[i][e]) continue;
if (FM[j] < G[j][e + 1])
output(j, DFM[j], 0, 0);
else
output(j, e + 1, 1, ans[i]);
}
} else {
ans[i] = i;
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == fa[i]) continue;
if (FM[j] < G[j][1])
output(j, DFM[j], 0, 0);
else
output(j, 1, 1, ans[i]);
}
}
} else {
ans[i] = pp;
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == fa[i]) continue;
if (FM[j] < G[j][e + 1])
output(j, DFM[j], 0, 0);
else
output(j, e + 1, 1, ans[i]);
}
}
}
int main() {
memset(c, -1, sizeof c);
scanf("%d%d", &n, &v[0]);
for (int i = (1); i <= (n - 1); ++i) scanf("%d", &v[i]);
for (int i = (1); i <= (n - 1); ++i) {
int x, y;
scanf("%d%d", &x, &y), addedge(x, y), addedge(y, x);
}
Fate(1, -1);
cout << FM[1] << endl;
output(1, DFM[1], 0, 0);
for (int i = 1; i <= n; ++i) printf(i < n ? "%d " : "%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
int st[190], aim[190 << 1], link[190 << 1], ln;
int dis[190][190];
int ansp[190];
int t[190][190];
int tag[190];
int g[190][190], h[190][190];
int stack[190];
int d[190];
int n, m;
void in_edge(int x, int y) {
aim[ln] = y;
link[ln] = st[x];
st[x] = ln++;
}
void dfs(int dep, int x) {
tag[x] = 1;
stack[dep] = x;
int i;
for (i = 0; i < dep; i++) t[stack[i]][x] = 1;
for (i = st[x]; i != -1; i = link[i])
if (!tag[aim[i]]) dfs(dep + 1, aim[i]);
}
void bfs(int sp) {
int i, p, an;
int a[190];
an = 1;
a[0] = sp;
dis[sp][sp] = 0;
for (p = 0; p < an; p++)
for (i = st[a[p]]; i != -1; i = link[i])
if (dis[sp][aim[i]] == -1) {
dis[sp][aim[i]] = dis[sp][a[p]] + 1;
a[an++] = aim[i];
}
}
int f(int x, int y) {
if (g[x][y] == -1) {
int i, j, tot;
if (y == 0) {
g[x][y] = m;
for (i = st[x]; i != -1; i = link[i])
if (t[x][aim[i]]) g[x][y] += f(aim[i], x);
h[x][y] = x;
for (i = 1; i <= n; i++)
if (i != x && t[x][i]) {
tot = d[dis[x][i]];
for (j = st[x]; j != -1; j = link[j])
if (t[x][aim[j]]) tot += f(aim[j], i);
if (tot < g[x][y]) {
g[x][y] = tot;
h[x][y] = i;
}
}
} else if (x == y) {
g[x][y] = m;
for (i = st[x]; i != -1; i = link[i])
if (t[x][aim[i]]) g[x][y] += f(aim[i], x);
h[x][y] = x;
} else if (t[x][y]) {
g[x][y] = d[dis[x][y]];
for (i = st[x]; i != -1; i = link[i])
if (t[x][aim[i]]) g[x][y] += f(aim[i], y);
h[x][y] = y;
} else {
g[x][y] = d[dis[x][y]];
for (i = st[x]; i != -1; i = link[i])
if (t[x][aim[i]]) g[x][y] += f(aim[i], y);
h[x][y] = y;
tot = f(x, 0);
if (tot < g[x][y]) {
g[x][y] = tot;
h[x][y] = h[x][0];
}
}
}
return g[x][y];
}
void Find_ans(int x, int y) {
if (y == 0) {
ansp[x] = h[x][y];
for (int i = st[x]; i != -1; i = link[i])
if (t[x][aim[i]]) Find_ans(aim[i], h[x][y]);
} else if (x == y) {
ansp[x] = x;
for (int i = st[x]; i != -1; i = link[i])
if (t[x][aim[i]]) Find_ans(aim[i], x);
} else if (t[x][y]) {
ansp[x] = y;
for (int i = st[x]; i != -1; i = link[i])
if (t[x][aim[i]]) Find_ans(aim[i], y);
} else {
if (h[x][y] == y) {
ansp[x] = y;
for (int i = st[x]; i != -1; i = link[i])
if (t[x][aim[i]]) Find_ans(aim[i], y);
} else
Find_ans(x, 0);
}
}
int main() {
int i, j, k;
scanf("%d %d", &n, &m);
for (i = 1; i < n; i++) scanf("%d", d + i);
memset(st, -1, sizeof(st));
ln = 0;
for (i = 1; i < n; i++) {
scanf("%d %d", &j, &k);
in_edge(j, k);
in_edge(k, j);
}
memset(t, 0, sizeof(t));
memset(tag, 0, sizeof(tag));
dfs(0, 1);
memset(dis, -1, sizeof(dis));
for (i = 1; i <= n; i++) bfs(i);
memset(g, -1, sizeof(g));
printf("%d\n", f(1, 0));
Find_ans(1, 0);
for (i = 1; i <= n; i++) printf("%d ", ansp[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int f[207][207], best[207], wherebest[207];
int father[207], N, K, W[207], d[207][207], where[207];
vector<int> temp[207], edge[207];
void init_tree(int u, int Fa) {
father[u] = Fa;
if (Fa != -1 && temp[u].size() <= 1) return;
for (typeof(temp[u].begin()) it = temp[u].begin(); it != temp[u].end(); it++)
if (*it != Fa) {
edge[u].push_back(*it);
init_tree(*it, u);
}
}
void calc(int u) {
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end(); it++)
calc(*it);
best[u] = 0x7f7f7f7f;
for (int i = 0; i < N; i++) {
f[u][i] = W[d[u][i]] + K;
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end();
it++)
f[u][i] += min(f[*it][i] - K, best[*it]);
if (f[u][i] < best[u]) {
best[u] = f[u][i];
wherebest[u] = i;
}
}
}
void output(int u, int from) {
where[u] = from;
int i = from;
for (typeof(edge[u].begin()) it = edge[u].begin(); it != edge[u].end(); it++)
if (f[*it][i] - K < best[*it])
output(*it, i);
else
output(*it, wherebest[*it]);
}
queue<int> Q;
void calc_dist(int u, int d[]) {
while (!Q.empty()) Q.pop();
for (int i = 0; i < N; i++) d[i] = 0x7f7f7f7f;
d[u] = 0;
Q.push(u);
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (typeof(temp[now].begin()) it = temp[now].begin();
it != temp[now].end(); it++)
if (d[*it] > d[now] + 1) {
d[*it] = d[now] + 1;
Q.push(*it);
}
}
}
int main() {
cin >> N >> K;
W[0] = 0;
for (int i = 0; i < N - 1; i++) cin >> W[i + 1];
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
--a, --b;
temp[a].push_back(b);
temp[b].push_back(a);
}
init_tree(0, -1);
for (int i = 0; i < N; i++) calc_dist(i, d[i]);
calc(0);
int begin = 0;
for (int i = 0; i < N; i++)
if (f[0][begin] > f[0][i]) begin = i;
output(0, begin);
cout << f[0][begin] << endl;
for (int i = 0; i < N; i++) {
if (i) cout << " ";
cout << where[i] + 1;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 205;
const int INF = 1234567890;
int n, costK;
int D[maxn], dis[maxn][maxn];
vector<int> vec[maxn];
int dp[maxn][maxn], best[maxn];
void dfs(int v, int f) {
for (int i = 0; i < (int)vec[v].size(); i++) {
int x = vec[v][i];
if (x != f) dfs(x, v);
}
int tm = INF;
for (int i = 0; i < n; i++) {
dp[v][i] = D[dis[v][i]];
for (int j = 0; j < (int)vec[v].size(); j++) {
int x = vec[v][j];
if (x == f) continue;
dp[v][i] += min(dp[x][i], dp[x][best[x]] + costK);
}
if (dp[v][i] < tm) {
tm = dp[v][i];
best[v] = i;
}
}
}
int center[maxn];
void getCenter(int v, int f, int b) {
center[v] = b;
for (int i = 0; i < (int)vec[v].size(); i++) {
int x = vec[v][i];
if (x == f) continue;
getCenter(x, v, dp[x][b] > dp[x][best[x]] + costK ? best[x] : b);
}
}
int main() {
scanf("%d%d", &n, &costK);
for (int i = 1; i < n; i++) scanf("%d", &D[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dis[i][j] = (i == j ? 0 : maxn);
}
}
for (int i = 0; i < n - 1; i++) {
int t1, t2;
scanf("%d%d", &t1, &t2);
t1--;
t2--;
vec[t1].push_back(t2);
vec[t2].push_back(t1);
dis[t1][t2] = dis[t2][t1] = 1;
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
dfs(0, -1);
printf("%d\n", dp[0][best[0]] + costK);
getCenter(0, -1, best[0]);
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", center[i] + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200;
const int INF = 1000000007;
int m, x[MAXN];
int d[MAXN][MAXN];
vector<int> c[MAXN], cs[MAXN];
void dfs(int v, int p) {
c[v].erase(remove(c[v].begin(), c[v].end(), p), c[v].end());
cs[v].push_back(v);
for (vector<int>::const_iterator w = c[v].begin(); w != c[v].end(); ++w) {
dfs(*w, v);
cs[v].insert(cs[v].end(), cs[*w].begin(), cs[*w].end());
}
}
pair<int, vector<pair<int, int> > > ans[MAXN], dp[MAXN][MAXN];
int gao(int v);
int gao(int v, int p);
int gao(int v) {
if (ans[v].first != -1) {
return ans[v].first;
}
ans[v].first = INF;
for (vector<int>::const_iterator u = cs[v].begin(); u != cs[v].end(); ++u) {
int tmp = m + x[d[v][*u]];
for (vector<int>::const_iterator w = c[v].begin(); w != c[v].end(); ++w) {
tmp += gao(*w, *u);
}
if (ans[v].first > tmp) {
ans[v].first = tmp;
ans[v].second.clear();
ans[v].second.push_back(make_pair(v, *u));
for (vector<int>::const_iterator w = c[v].begin(); w != c[v].end(); ++w) {
ans[v].second.insert(ans[v].second.end(), dp[*w][*u].second.begin(),
dp[*w][*u].second.end());
}
}
}
return ans[v].first;
}
int gao(int v, int u) {
if (dp[v][u].first != -1) {
return dp[v][u].first;
}
gao(v);
dp[v][u] = ans[v];
int tmp = x[d[v][u]];
for (vector<int>::const_iterator w = c[v].begin(); w != c[v].end(); ++w) {
tmp += gao(*w, u);
}
if (dp[v][u].first > tmp) {
dp[v][u].first = tmp;
dp[v][u].second.clear();
dp[v][u].second.push_back(make_pair(v, u));
for (vector<int>::const_iterator w = c[v].begin(); w != c[v].end(); ++w) {
dp[v][u].second.insert(dp[v][u].second.end(), dp[*w][u].second.begin(),
dp[*w][u].second.end());
}
}
return dp[v][u].first;
}
int main() {
int n, a, b;
scanf("%d%d", &n, &m);
x[0] = 0;
for (int i = 1; i < n; ++i) {
scanf("%d", &x[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
d[i][j] = i == j ? 0 : INF;
}
}
for (int i = 1; i < n; ++i) {
scanf("%d%d", &a, &b);
--a;
--b;
c[a].push_back(b);
c[b].push_back(a);
d[a][b] = d[b][a] = 1;
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
dfs(0, -1);
for (int i = 0; i < n; ++i) {
ans[i].first = -1;
for (int j = 0; j < n; ++j) {
dp[i][j].first = -1;
}
}
printf("%d\n", gao(0));
sort(ans[0].second.begin(), ans[0].second.end());
for (int i = 0; i < n; ++i) {
printf("%d ", ans[0].second[i].second + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 120 + 77;
const int inf = 1000000000 + 77;
int n, k, C[N], A[N];
int dp[N][N][2];
int Par[N][N][2];
vector<int> adj[N];
void dfs(int v, int prev = -1) {
vector<int> Ch;
for (int u : adj[v])
if (u != prev) dfs(u, v), Ch.push_back(u);
dp[v][0][1] = k;
for (int u : Ch) dp[v][0][1] += min(dp[u][0][1], dp[u][1][1]);
dp[v][0][0] = dp[v][0][1];
for (int i = 1; i < n; ++i) {
dp[v][i][1] = C[i];
int tot = 0;
bool good = 1, ff = 1;
for (int u : Ch) {
dp[v][i][1] += min(min(dp[u][i + 1][1], dp[u][i][0]), dp[u][i - 1][0]),
tot += min(min(dp[u][i - 1][0], dp[u][i][0]), dp[u][i + 1][1]);
if (min(min(dp[u][i - 1][0], dp[u][i][0]), dp[u][i + 1][1]) > 1e8)
good = 0;
if (min(min(dp[u][i + 1][1], dp[u][i][0]), dp[u][i - 1][0]) > 1e8) ff = 0;
}
if (!ff) dp[v][i][1] = inf;
if (!good) continue;
for (int u : Ch) {
int val = dp[u][i - 1][0] + tot -
min(min(dp[u][i - 1][0], dp[u][i][0]), dp[u][i + 1][1]);
if (val < dp[v][i][0]) Par[v][i][0] = u, dp[v][i][0] = val;
}
dp[v][i][0] += C[i];
}
}
void Solve(int v, int d, int t, int prev = -1) {
if (d == 0)
A[v] = v;
else if (t == 1)
A[v] = A[prev];
else {
int x = Par[v][d][t];
Solve(x, d - 1, t, v);
A[v] = A[x];
for (int u : adj[v])
if (u != prev && u != x) {
int f = min(min(dp[u][d - 1][0], dp[u][d][0]), dp[u][d + 1][1]);
if (f == dp[u][d - 1][0])
Solve(u, d - 1, 0, v);
else if (f == dp[u][d][0])
Solve(u, d, 0, v);
else
Solve(u, d + 1, 1, v);
}
return;
}
if (t == 1) {
for (int u : adj[v]) {
if (u != prev) {
int f = min(min(dp[u][d + 1][1], dp[u][d][0]), dp[u][d - 1][0]);
if (f == dp[u][d + 1][1])
Solve(u, d + 1, 1, v);
else if (f == dp[u][d][0])
Solve(u, d, 0, v);
else
Solve(u, d - 1, 0, v);
}
}
return;
}
for (int u : adj[v]) {
if (u == prev) continue;
int f = min(dp[u][0][1], dp[u][1][1]);
if (f == dp[u][0][0])
Solve(u, 0, 0, v);
else
Solve(u, 1, 1, v);
}
}
int main() {
memset(dp, 63, sizeof(dp));
scanf("%d %d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", C + i);
for (int v, u, i = 1; i < n; ++i) {
scanf("%d %d", &v, &u);
adj[v].push_back(u);
adj[u].push_back(v);
}
dfs(1);
int best = 0;
int val = dp[1][0][0];
for (int i = 1; i < n; ++i)
if (dp[1][i][0] < val) best = i, val = dp[1][i][0];
printf("%d\n", val);
Solve(1, best, 0);
for (int i = 1; i <= n; ++i) printf("%d ", A[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Tpoint {
double x, y;
Tpoint() {}
Tpoint(double _x, double _y) {
x = _x;
y = _y;
}
inline void read() { scanf("%lf%lf", &x, &y); }
inline void show() { printf("%lf %lf\n", x, y); }
inline double norm() { return sqrt(((x) * (x)) + ((y) * (y))); }
};
inline Tpoint operator+(const Tpoint &a, const Tpoint &b) {
return Tpoint(a.x + b.x, a.y + b.y);
}
inline Tpoint operator-(const Tpoint &a, const Tpoint &b) {
return Tpoint(a.x - b.x, a.y - b.y);
}
inline Tpoint operator*(const Tpoint &a, const double &b) {
return Tpoint(a.x * b, a.y * b);
}
inline Tpoint operator/(const Tpoint &a, const double &b) {
return Tpoint(a.x / b, a.y / b);
}
inline double det(const Tpoint &a, const Tpoint &b) {
return a.x * b.y - a.y * b.x;
}
inline double dot(const Tpoint &a, const Tpoint &b) {
return a.x * b.x + a.y * b.y;
}
const int inf = 1000000000;
int n, build, d[200][200], pay[200];
int f[200][200];
vector<int> Adj[200];
inline int dfs(int u, int to, int fa) {
int &res = f[u][to];
if (res != -1) return res;
res = min(build, pay[d[u][to]]);
for (int i = 0; i < Adj[u].size(); ++i) {
int v = Adj[u][i];
if (v == fa) continue;
int t = inf;
for (int j = 1; j <= n; ++j) {
t = min(t, dfs(v, j, u) +
(j != to || build < pay[d[u][to]] && j == u) * build);
}
res += t;
}
return res;
}
int mark[200];
inline void output(int u, int to, int fa) {
mark[u] = to;
if (build < pay[d[u][to]]) mark[u] = u;
for (int i = 0; i < Adj[u].size(); ++i) {
int v = Adj[u][i];
if (v == fa) continue;
int t = inf;
for (int j = 1; j <= n; ++j) {
t = min(t, dfs(v, j, u) +
(j != to || build < pay[d[u][to]] && j == u) * build);
}
for (int j = 1; j <= n; ++j)
if (t == (dfs(v, j, u) +
(j != to || build < pay[d[u][to]] && j == u) * build)) {
output(v, j, u);
break;
}
}
}
int main() {
scanf("%d%d", &n, &build);
for (int i = 1; i < n; ++i) scanf("%d", &pay[i]);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) d[i][j] = inf;
d[i][i] = 0;
}
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
Adj[a].push_back(b);
Adj[b].push_back(a);
d[a][b] = d[b][a] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
memset(f, -1, sizeof(f));
int ans = inf;
for (int i = 1; i <= n; ++i) ans = min(ans, dfs(1, i, 0) + build);
printf("%d\n", ans);
for (int i = 1; i <= n; ++i) {
if (dfs(1, i, 0) + build == ans) {
output(1, i, 0);
break;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", mark[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d[222], dist[222][222], ans[222], dp[222][222], bf[222];
vector<int> v[222];
void FLOYED() {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
}
void dfs(int x, int y) {
for (int i = 1; i <= n; i++) {
dp[i][x] = d[dist[i][x]] + k;
}
for (int i = 0; i < v[x].size(); i++) {
int z = v[x][i];
if (z == y) {
continue;
}
dfs(z, x);
for (int j = 1; j <= n; j++) {
dp[j][x] += min(dp[bf[z]][z], dp[j][z] - k);
}
}
bf[x] = 1;
for (int i = 2; i <= n; i++) {
if (dp[bf[x]][x] > dp[i][x]) {
bf[x] = i;
}
}
}
void getans(int x, int y) {
for (int i = 0; i < v[x].size(); i++) {
int z = v[x][i];
if (z == y) {
continue;
}
if (dp[bf[z]][z] < dp[ans[x]][z] - k) {
ans[z] = bf[z];
} else {
ans[z] = ans[x];
}
getans(z, x);
}
}
int main() {
for (int i = 0; i < 210; i++) {
for (int j = 0; j < 210; j++) {
if (i == j) {
continue;
}
dist[i][j] = 1e9;
}
}
cin >> n >> k;
for (int i = 1; i < n; i++) {
cin >> d[i];
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
dist[x][y] = 1;
dist[y][x] = 1;
v[x].push_back(y);
v[y].push_back(x);
}
FLOYED();
dfs(1, -1);
cout << dp[bf[1]][1] << endl;
ans[1] = bf[1];
getans(1, -1);
for (int i = 1; i <= n; i++) {
cout << ans[i] << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void gmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void PV(T x) {
for (__typeof__((x).begin()) i = (x).begin(); i != (x).end(); i++)
cout << *i << " ";
cout << endl;
}
template <class T>
void PA(T x[], int n) {
for (int i = 0; i < n; i++) cout << x[i] << " ";
cout << endl;
}
const int N = 180;
vector<int> lnk[N], d;
int n, m;
int p[N][N];
void calc_p(int root, int dep, int now, int fth) {
p[root][now] = d[dep];
for (__typeof__(lnk[now].begin()) _it = lnk[now].begin();
_it != lnk[now].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = lnk[now].end(), --_it) : _it)
for (__typeof__(*_it) &next = *_it; _once && !(_once = 0); _done = 1)
if (next != fth) calc_p(root, dep + 1, next, now);
}
int f[N][N], f2[N];
void dp(int now, int fth) {
for (__typeof__(lnk[now].begin()) _it = lnk[now].begin();
_it != lnk[now].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = lnk[now].end(), --_it) : _it)
for (__typeof__(*_it) &next = *_it; _once && !(_once = 0); _done = 1)
if (next != fth) dp(next, now);
for (int n_ = (n), c = 0; c < n_; ++c) f[now][c] = p[now][c] + m;
for (int n_ = (n), c = 0; c < n_; ++c)
for (__typeof__(lnk[now].begin()) _it = lnk[now].begin();
_it != lnk[now].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = lnk[now].end(), --_it) : _it)
for (__typeof__(*_it) &next = *_it; _once && !(_once = 0); _done = 1)
if (next != fth) f[now][c] += min(f[next][c] - m, f[next][f2[next]]);
f2[now] = 0;
for (int n_ = (n), c = 0; c < n_; ++c)
if (f[now][c] < f[now][f2[now]]) f2[now] = c;
}
vector<int> ans;
void dp2(int now, int fth, int c) {
ans[now] = c + 1;
for (__typeof__(lnk[now].begin()) _it = lnk[now].begin();
_it != lnk[now].end(); ++_it)
for (int _once = 1, _done = 0; _once;
(!_done) ? (_it = lnk[now].end(), --_it) : _it)
for (__typeof__(*_it) &next = *_it; _once && !(_once = 0); _done = 1)
if (next != fth) {
if (f[next][c] - m < f[next][f2[next]])
dp2(next, now, c);
else
dp2(next, now, f2[next]);
}
}
void work() {
for (int n_ = (n), i = 0; i < n_; ++i) calc_p(i, 0, i, -1);
dp(0, -1);
ans.resize(n);
dp2(0, -1, f2[0]);
cout << f[0][f2[0]] << endl;
PV(ans);
}
void myin() {
cin >> n >> m;
d.assign(n, 0);
for (int n_ = (n - 1), i = 0; i < n_; ++i) cin >> d[i + 1];
for (int n_ = (n), i = 0; i < n_; ++i) lnk[i].clear();
for (int n_ = (n - 1), i = 0; i < n_; ++i) {
int u, v;
cin >> u >> v;
u--, v--;
lnk[u].push_back(v);
lnk[v].push_back(u);
}
}
int main() {
myin();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int dp[N][N], ans[N], d[N][N], w[N], f[N];
int n, k;
void dfs(int u, int fa) {
for (int s = 1; s <= n; ++s)
if (d[u][s] == 1 && s != fa) dfs(s, u);
for (int i = 1; i <= n; ++i) {
int pos = w[d[u][i]] + k;
for (int s = 1; s <= n; ++s) {
if (d[u][s] == 1 && s != fa) {
pos += min(dp[s][i] - k, dp[s][ans[s]]);
}
}
dp[u][i] = pos;
}
ans[u] = 1;
for (int i = 2; i <= n; ++i)
if (dp[u][ans[u]] > dp[u][i]) ans[u] = i;
}
void sc(int u, int fa) {
if (dp[u][ans[u]] <= dp[u][f[fa]] - k)
f[u] = ans[u];
else
f[u] = f[fa];
for (int i = 1; i <= n; ++i)
if (d[u][i] == 1 && i != fa) sc(i, u);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n - 1; ++i) scanf("%d", &w[i]);
memset(d, 0x3f, sizeof d);
for (int i = 1, x, y; i < n; ++i) {
scanf("%d%d", &x, &y);
d[x][y] = 1, d[y][x] = 1;
}
for (int i = 1; i <= n; ++i) d[i][i] = 0;
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
dfs(1, 0);
cout << dp[1][ans[1]] << endl;
f[1] = ans[1];
for (int i = 1; i <= n; ++i)
if (d[i][1] == 1) sc(i, 1);
for (int i = 1; i <= n; ++i) printf("%d ", f[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, x, y;
int ans[200], res[200], d[200];
int f[200][200], g[200][200];
void dfs(int x, int fa) {
for (int i = 1; i <= N; i++) f[x][i] = d[g[x][i]] + K;
for (int v = 1; v <= N; v++)
if (g[x][v] == 1 && v != fa) {
dfs(v, x);
for (int i = 1; i <= N; i++) f[x][i] += min(f[v][i] - K, f[v][ans[v]]);
}
ans[x] = 1;
for (int i = 2; i <= N; i++)
if (f[x][i] < f[x][ans[x]]) ans[x] = i;
}
void make(int x, int fa, int cnt) {
res[x] = cnt;
for (int i = 1; i <= N; i++)
if (g[x][i] == 1 && i != fa) {
int t;
if (f[i][cnt] - K < f[i][ans[i]])
t = cnt;
else
t = ans[i];
make(i, x, t);
}
}
int main() {
scanf("%d%d", &N, &K);
for (int i = 1; i < N; i++) scanf("%d", &d[i]);
memset(g, 20, sizeof(g));
for (int i = 1; i < N; i++) {
scanf("%d%d", &x, &y);
g[x][y] = 1;
g[y][x] = 1;
}
for (int i = 1; i <= N; i++) g[i][i] = 0;
for (int k = 1; k <= N; k++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
dfs(1, 0);
printf("%d\n", f[1][ans[1]]);
make(1, 0, ans[1]);
for (int i = 1; i <= N; i++) printf("%d ", res[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N;
int D[185];
int K;
struct E {
int V, Next;
} Edge[405];
int EdgeTop;
int Head[185];
void Add(int U, int V) {
Edge[++EdgeTop] = (E){V, Head[U]};
Head[U] = EdgeTop;
}
int W[185][185];
void Min(int &X, int Y) {
if (X > Y) X = Y;
}
void Init() {
Get(N);
Get(K);
for (int i = 1; i < N; i++) Get(D[i]);
memset(W, 0x2f, sizeof W);
int U, V;
for (int i = 1; i < N; i++) {
Get(U);
Get(V);
Add(U, V);
Add(V, U);
W[U][V] = W[V][U] = 1;
}
for (int i = 1; i <= N; i++) W[i][i] = 0;
for (int k = 1; k <= N; k++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) Min(W[i][j], W[i][k] + W[k][j]);
}
int F[185][185];
int FMin[185];
int Choose[185];
int Choose2[185][185];
void DFS(int X, int Fa) {
for (int i = 1; i <= N; i++) F[X][i] = D[W[X][i]] + K;
for (int j = Head[X]; j; j = Edge[j].Next)
if (Edge[j].V != Fa) {
DFS(Edge[j].V, X);
for (int i = 1; i <= N; i++)
if (FMin[Edge[j].V] < F[Edge[j].V][i] - K) {
F[X][i] += FMin[Edge[j].V];
Choose2[Edge[j].V][i] = Choose[Edge[j].V];
} else {
F[X][i] += F[Edge[j].V][i] - K;
Choose2[Edge[j].V][i] = i;
}
}
FMin[X] = 0x2f2f2f2f;
for (int i = 1; i <= N; i++)
if (FMin[X] > F[X][i]) {
FMin[X] = F[X][i];
Choose[X] = i;
}
}
int Ans2[185];
void DFS2(int X, int Fa, int Choose) {
Ans2[X] = Choose;
for (int j = Head[X]; j; j = Edge[j].Next)
if (Edge[j].V != Fa) {
DFS2(Edge[j].V, X, Choose2[Edge[j].V][Choose]);
}
}
void Work() {
DFS(1, 0);
DFS2(1, 0, Choose[1]);
}
void Output() {
printf("%d\n", FMin[1]);
for (int i = 1; i <= N; i++) printf("%d ", Ans2[i]);
}
int main() {
Init();
Work();
Output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int Max = 256;
const int MaxE = Max * 2;
struct edge {
int to;
edge *s;
};
edge E[MaxE], *hd[Max], *cp;
int n, k, D[Max];
int F[Max][Max];
int G[Max][Max];
int R[Max], A[Max];
int Q[Max], qn;
void addEdge(int x, int y) { cp->to = y, cp->s = hd[x], hd[x] = cp++; }
inline void update(int &r, int d) {
if (d < r) r = d;
}
void dfs(int x, int pf) {
int sn = 0;
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) {
dfs(p->to, x);
++sn;
}
G[x][0] = k;
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) G[x][0] += min(R[p->to], F[p->to][1]);
for (int i = 0; i + 1 < n; i++) {
if (sn == 0) break;
int cs = 0;
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) cs += min(R[p->to], F[p->to][i + 2]);
int &cr = G[x][i + 1];
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) {
int d = min(R[p->to], F[p->to][i + 2]);
update(cr, cs - d + G[p->to][i]);
}
cr += D[i + 1];
}
R[x] = oo;
for (int i = 0; i < n; i++) update(R[x], G[x][i]);
for (int i = 1; i + 1 < n; i++) {
int &cr = F[x][i] = D[i];
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) cr += min(R[p->to], F[p->to][i + 1]);
}
}
void aDfs(int x, int pf, int c, int e) {
if (c == 0) {
int ri = -1;
for (int i = 0; i < n; i++)
if (R[x] == G[x][i]) {
ri = i;
break;
}
aDfs(x, pf, 2, ri);
} else if (c == 1) {
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) {
if (R[p->to] < F[p->to][e + 1])
aDfs(p->to, x, 0, 0);
else
aDfs(p->to, x, 1, e + 1);
}
} else if (c == 2) {
if (e == 0) {
A[x] = x;
Q[qn++] = x;
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) {
if (R[p->to] < F[p->to][1])
aDfs(p->to, x, 0, 0);
else
aDfs(p->to, x, 1, 1);
}
return;
}
int cs = 0;
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) cs += min(R[p->to], F[p->to][e + 1]);
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf) {
int d = min(R[p->to], F[p->to][e + 1]);
if (G[x][e] == cs - d + G[p->to][e - 1] + D[e]) {
int y = p->to;
aDfs(y, x, 2, e - 1);
for (edge *p = hd[x]; p; p = p->s)
if (p->to != pf && p->to != y) {
if (R[p->to] < F[p->to][e + 1])
aDfs(p->to, x, 0, 0);
else
aDfs(p->to, x, 1, e + 1);
}
break;
}
}
}
}
int main() {
while (scanf("%d%d", &n, &k) != EOF && n) {
for (int i = 1; i < n; i++) scanf("%d", &D[i]);
D[n] = oo;
memset(hd + 1, 0, sizeof(hd[0]) * n);
cp = E;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
addEdge(x, y);
addEdge(y, x);
}
memset(F, 0x3f, sizeof(F));
memset(G, 0x3f, sizeof(G));
dfs(1, -1);
printf("%d\n", R[1]);
memset(A, -1, sizeof(A));
qn = 0;
aDfs(1, -1, 0, 0);
for (int cq = 0; cq < qn; cq++) {
int x = Q[cq];
for (edge *p = hd[x]; p; p = p->s)
if (A[p->to] == -1) {
A[p->to] = A[x];
Q[qn++] = p->to;
}
}
for (int i = 1; i <= n; i++) printf("%d%c", A[i], i == n ? '\n' : ' ');
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long cm[400];
vector<vector<int> > adj;
int parent[400];
int height[400];
void treeifization(int node) {
height[node] = 1;
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i)) {
if (adj[node][i] == parent[node]) continue;
parent[adj[node][i]] = node;
treeifization(adj[node][i]);
height[node] = max((height[node]), (1 + height[adj[node][i]]));
}
}
long long newcost;
long long dp[2][405][405];
enum Action {
kFollowFather = 0,
kCreateNew = 1,
kContinue = 2,
kNewAtChild = 3
};
int continue_to[2][405][405];
int new_at[2][405][405];
int new_depth[2][405][405];
Action backtrack[2][405][405];
enum { kNone = 400 };
int center[405];
int Backtrack(int node, int distance, int type, int from) {
Action bt = backtrack[type][node][distance];
int conto = continue_to[type][node][distance];
int newat = new_at[type][node][distance];
int newdepth = new_depth[type][node][distance];
if (bt == kCreateNew) {
center[node] = node;
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
Backtrack(adj[node][i], 1, 1, node);
}
return node;
}
if (bt == kFollowFather) {
center[node] = from;
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
Backtrack(adj[node][i], distance + 1, 1, from);
}
return from;
}
if (bt == kContinue) {
center[node] = Backtrack(conto, distance - 1, 0, -1);
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
if (adj[node][i] == conto) continue;
Backtrack(adj[node][i], distance + 1, 1, center[node]);
}
return center[node];
}
if (bt == kNewAtChild) {
center[node] = Backtrack(newat, newdepth - 1, 0, -1);
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
if (adj[node][i] == newat) continue;
Backtrack(adj[node][i], newdepth + 1, 1, center[node]);
}
return center[node];
}
return -3;
}
long long Solve(int node, long long distance, int type) {
if (dp[type][node][distance] != -1LL) return dp[type][node][distance];
long long& alias = dp[type][node][distance];
Action& backalias = backtrack[type][node][distance];
int& new_depth_alias = new_depth[type][node][distance];
int& new_at_alias = new_at[type][node][distance];
int& continue_to_alias = continue_to[type][node][distance];
if (type == 0) {
if (distance == 0) {
long long totalcost = newcost;
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
totalcost += Solve(adj[node][i], 1, 1);
}
backalias = kCreateNew;
return alias = totalcost;
} else {
long long totalcost = cm[distance];
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
totalcost += Solve(adj[node][i], distance + 1, 1);
}
long long bestcost = (long long)1023123123 * (long long)1023123123;
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
long long newcost = totalcost - Solve(adj[node][i], distance + 1, 1) +
Solve(adj[node][i], distance - 1, 0);
if (newcost < bestcost) {
bestcost = newcost;
backalias = kContinue;
continue_to_alias = adj[node][i];
}
}
return alias = bestcost;
}
} else {
long long bestcost = newcost;
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
bestcost += Solve(adj[node][i], 1, 1);
}
backalias = kCreateNew;
if (distance != kNone) {
long long trycost = cm[distance];
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
trycost += Solve(adj[node][i], distance + 1, 1);
}
if (trycost < bestcost) {
bestcost = trycost;
backalias = kFollowFather;
}
}
for (int z = 1; z < height[node]; ++z) {
long long trycost = cm[z];
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
trycost += Solve(adj[node][i], 1 + z, 1);
}
for (int(i) = 0; (i) < (((int)adj[node].size())); ++(i))
if (parent[adj[node][i]] == node) {
long long newcost = trycost - Solve(adj[node][i], 1 + z, 1) +
Solve(adj[node][i], z - 1, 0);
if (newcost < bestcost) {
bestcost = newcost;
backalias = kNewAtChild;
new_at_alias = adj[node][i];
new_depth_alias = z;
}
}
}
return alias = bestcost;
}
}
int main() {
for (int(i) = 0; (i) < (405); ++(i))
for (int(j) = 0; (j) < (405); ++(j))
for (int(k) = 0; (k) < (2); ++(k)) dp[k][i][j] = -1LL;
int n, k;
cin >> n >> k;
newcost = k;
for (int(i) = 0; (i) < (n - 1); ++(i)) {
cin >> cm[i + 1];
}
adj = vector<vector<int> >(n);
for (int(i) = 0; (i) < (n - 1); ++(i)) {
int a, b;
cin >> a >> b;
--a;
--b;
adj[a].push_back(b);
adj[b].push_back(a);
}
parent[0] = -1;
treeifization(0);
cout << Solve(0, kNone, 1) << endl;
int none = Backtrack(0, kNone, 1, -5);
for (int(i) = 0; (i) < (n); ++(i)) {
if (i) cout << " ";
cout << center[i] + 1;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch != 45 && (ch > '9' || ch < '0')) ch = getchar();
if (ch == 45) {
f = -1, ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
void cmin(int &a, int b) { a = min(a, b); }
void cmax(int &a, int b) { a = max(a, b); }
const int N = 185;
int i, j, k, n, s, t, m;
bitset<N> bst[N][N];
int dp[N][N], dis[N][N], d[N], fa[N], ans[N], dfn[N], size[N];
vector<int> e[N];
int in(int x, int y) { return (dfn[x] >= dfn[y] && dfn[x] < dfn[y] + size[y]); }
void dfs(int u, int f) {
dfn[u] = ++t;
size[u]++;
for (int v : e[u]) {
if (f == v) continue;
fa[v] = u;
dfs(v, u);
size[u] += size[v];
}
}
void dfs(int u) {
dp[u][u] = k;
bst[u][u][u] = 1;
for (int v : e[u]) {
if (v == fa[u]) continue;
dfs(v);
}
for (i = 1; i <= n; i++) {
dp[u][i] += d[dis[u][i]];
for (int v : e[u]) {
if (v == fa[u]) continue;
int tmp = dp[v][i], rk = i;
for (j = 1; j <= n; j++) {
if (in(j, v) && i != v && dis[u][i] <= dis[u][j] &&
dis[v][j] <= dis[v][i])
if (dp[v][j] < tmp) tmp = dp[v][j], rk = j;
}
dp[u][i] += tmp;
bst[u][i] |= bst[v][rk];
}
}
}
void getAns(int x) {
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (bst[1][x][j] == 0) continue;
if (dis[i][j] < dis[i][ans[i]]) ans[i] = j;
}
}
}
signed main() {
memset(dis, 1, sizeof(dis));
read(n), read(k);
for (i = 1; i < n; i++) read(d[i]), dis[i][i] = 0;
dis[n][n] = 0;
for (i = 1; i < n; i++) {
int x, y;
read(x), read(y);
dis[x][y] = dis[y][x] = 1;
e[x].push_back(y), e[y].push_back(x);
}
for (s = 1; s <= n; s++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][s] + dis[s][j]);
dfs(1, 0);
dfs(1);
int opt = 1e9, at;
for (i = 1; i <= n; i++) {
if (dp[1][i] <= opt) at = i, opt = dp[1][i];
}
cout << opt << endl;
getAns(at);
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
int n, k, d[205];
int dp[205][205], dis[205][205], opt[205], way[205];
bool p[205];
vector<int> v[205];
void dfs(int x, int fa) {
if (p[x]) return;
p[x] = 1;
for (int(j) = (0); (j) < (v[x].size()); (j)++) {
int to = v[x][j];
if (to == fa) continue;
dfs(to, x);
}
for (int(i) = (1); (i) <= (n); (i)++) {
dp[x][i] = d[dis[x][i]] + k;
for (int(j) = (0); (j) < (v[x].size()); (j)++) {
int to = v[x][j];
if (to == fa) continue;
int cost1 = dp[to][i] - k;
int cost2 = dp[to][opt[to]];
dp[x][i] += min(cost1, cost2);
}
if (opt[x] == 0 || dp[x][i] < dp[x][opt[x]]) opt[x] = i;
}
}
void rec(int x, int nxt, int fa) {
way[x] = nxt;
for (int(j) = (0); (j) < (v[x].size()); (j)++) {
int to = v[x][j];
if (to == fa) continue;
int cost1 = dp[to][nxt] - k;
int cost2 = dp[to][opt[to]];
if (cost1 < cost2)
rec(to, nxt, x);
else
rec(to, opt[to], x);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int(i) = (1); (i) <= (n - 1); (i)++) scanf("%d", d + i);
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (1); (j) <= (n); (j)++)
if (i != j) dis[i][j] = inf;
for (int(i) = (1); (i) < (n); (i)++) {
int t1, t2;
scanf("%d%d", &t1, &t2);
v[t1].push_back(t2);
v[t2].push_back(t1);
dis[t1][t2] = dis[t2][t1] = 1;
}
for (int(k) = (1); (k) <= (n); (k)++)
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (1); (j) <= (n); (j)++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
int ans = dp[1][opt[1]];
printf("%d\n", ans);
rec(1, opt[1], 0);
for (int(i) = (1); (i) <= (n); (i)++) printf("%d ", way[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Get() {
char c;
while (c = getchar(), c < '0' || c > '9')
;
int X = c - 48;
while (c = getchar(), c >= '0' && c <= '9') X = X * 10 + c - 48;
return X;
}
const int inf = 1000000000;
int N;
int W[180], Parent[180], Best[180], Ans[180];
vector<int> G[180], Child[180];
bool OK[180][180], Flag[180][180], New[180][180];
int F[180][180];
void DFS(int V) {
for (int i = 0; i < G[V].size(); i++)
if (G[V][i] != Parent[V]) {
Child[V].push_back(G[V][i]);
Parent[G[V][i]] = V;
DFS(G[V][i]);
}
}
void Search(int U, int V) {
OK[U][V] = true;
for (int i = 0; i < Child[V].size(); i++) Search(U, Child[V][i]);
}
int DP(int V, int Dist) {
if (Flag[V][Dist]) return F[V][Dist];
Flag[V][Dist] = true;
if (Dist) {
F[V][Dist] = W[Dist];
for (int i = 0; i < Child[V].size(); i++)
F[V][Dist] += DP(Child[V][i], Dist + 1);
int Temp = DP(V, 0);
New[V][Dist] = (Temp < F[V][Dist]);
F[V][Dist] = min(F[V][Dist], Temp);
} else {
F[V][Dist] = inf;
for (int U = 0; U < N; U++) {
if (!OK[V][U]) continue;
int Temp = W[0], P = U, Last = -1, Len = 1;
while (P != Parent[V]) {
for (int i = 0; i < Child[P].size(); i++)
if (Child[P][i] != Last) Temp += DP(Child[P][i], Len);
Last = P;
P = Parent[P];
if (P != Parent[V]) Temp += W[Len++];
}
if (Temp < F[V][Dist]) {
Best[V] = U;
F[V][Dist] = Temp;
}
}
}
return F[V][Dist];
}
void Calc(int V, int Dist, int Color) {
if (Dist && New[V][Dist]) {
Calc(V, 0, -1);
return;
}
if (Dist) {
Ans[V] = Color;
for (int i = 0; i < Child[V].size(); i++)
Calc(Child[V][i], Dist + 1, Color);
} else {
int U = Best[V], Last = -1, Len = 1;
while (U != Parent[V]) {
Ans[U] = Best[V] + 1;
for (int i = 0; i < Child[U].size(); i++)
if (Child[U][i] != Last) Calc(Child[U][i], Len, Best[V] + 1);
Last = U;
U = Parent[U];
Len++;
}
}
}
int main() {
N = Get();
W[0] = Get();
for (int i = 1; i < N; i++) W[i] = Get();
for (int i = 1; i < N; i++) {
int X = Get() - 1, Y = Get() - 1;
G[X].push_back(Y);
G[Y].push_back(X);
}
Parent[0] = -1;
DFS(0);
memset(OK, 0, sizeof(OK));
for (int i = 0; i < N; i++) Search(i, i);
memset(Flag, 0, sizeof(Flag));
printf("%d\n", DP(0, 0));
Calc(0, 0, -1);
for (int i = 0; i < N; i++) {
printf("%d", Ans[i]);
putchar((i == N - 1) ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int g[555], nxt[555], c[555], nm;
int n;
int v[555], F[555][555], DF[555][555], G[555][555], FM[555], DFM[555];
int fa[555], ans[555];
void addedge(int x, int y) {
g[nm] = y;
nxt[nm] = c[x];
c[x] = nm;
nm++;
}
inline int cmin(int x, int y) { return x < y ? x : y; }
void Fate(int i, int p) {
fa[i] = p;
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j != p) Fate(j, i);
}
for (int j = (0); j <= (n - 1); ++j) {
F[i][j] = 1000000000;
G[i][j] = v[j];
}
G[i][n] = G[i][n + 1] = G[i][0] = 1000000000;
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == p) continue;
for (int e = (1); e <= (n - 1); ++e)
if (cmin(G[j][e + 1], FM[j]) + G[i][e] < 1000000000)
G[i][e] += cmin(G[j][e + 1], FM[j]);
else
G[i][e] = 1000000000;
}
F[i][0] = v[0];
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == p) continue;
for (int e = (1); e <= (n - 1); ++e) {
int res = F[j][e - 1] + v[e];
for (int k2 = c[i]; ~k2; k2 = nxt[k2]) {
int j2 = g[k2];
if (j2 == j || j2 == p) continue;
int rs = FM[j2];
if (e + 1 <= n - 1) rs = cmin(rs, G[j2][e + 1]);
res += rs;
}
if (res < F[i][e]) {
F[i][e] = res;
DF[i][e] = j;
}
}
F[i][0] += cmin(FM[j], G[j][1]);
}
FM[i] = 1000000000;
for (int e = (0); e <= (n - 1); ++e)
if (F[i][e] < FM[i]) {
FM[i] = F[i][e];
DFM[i] = e;
}
}
void output(int i, int e, int t, int pp) {
if (t == 0) {
if (e > 0) {
output(DF[i][e], e - 1, 0, 0);
ans[i] = ans[DF[i][e]];
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == fa[i] || j == DF[i][e]) continue;
if (FM[j] < G[j][e + 1])
output(j, DFM[j], 0, 0);
else
output(j, e + 1, 1, ans[i]);
}
} else {
ans[i] = i;
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == fa[i]) continue;
if (FM[j] < G[j][1])
output(j, DFM[j], 0, 0);
else
output(j, 1, 1, ans[i]);
}
}
} else {
ans[i] = pp;
for (int k = c[i]; ~k; k = nxt[k]) {
int j = g[k];
if (j == fa[i]) continue;
if (FM[j] < G[j][e + 1])
output(j, DFM[j], 0, 0);
else
output(j, e + 1, 1, ans[i]);
}
}
}
int main() {
memset(c, -1, sizeof c);
scanf("%d%d", &n, &v[0]);
for (int i = (1); i <= (n - 1); ++i) scanf("%d", &v[i]);
for (int i = (1); i <= (n - 1); ++i) {
int x, y;
scanf("%d%d", &x, &y), addedge(x, y), addedge(y, x);
}
Fate(1, -1);
cout << FM[1] << endl;
output(1, DFM[1], 0, 0);
for (int i = 1; i <= n; ++i) printf(i < n ? "%d " : "%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int d[185];
int u, v, mp[185][185], dp[185][185], road[185][185];
int ans[185], pre[185];
void floyd() {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
mp[i][j] = mp[j][i] = min(mp[i][j], mp[i][k] + mp[k][j]);
}
}
}
}
void dfs(int pos, int fa) {
for (int i = 1; i <= n; i++) {
dp[pos][i] = d[mp[pos][i]] + k;
}
for (int i = 1; i <= n; i++) {
if (road[pos][i] && i != fa) {
dfs(i, pos);
for (int j = 1; j <= n; j++) {
dp[pos][j] += min(dp[i][ans[i]], dp[i][j] - k);
}
}
}
ans[pos] = 1;
for (int i = 2; i <= n; i++) {
if (dp[pos][i] < dp[pos][ans[pos]]) {
ans[pos] = i;
}
}
}
void calc(int pos, int fa, int x) {
pre[pos] = x;
for (int i = 1; i <= n; i++) {
if (road[pos][i] && i != fa) {
if (dp[i][ans[i]] < dp[i][x] - k) {
calc(i, pos, ans[i]);
} else {
calc(i, pos, x);
}
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
scanf("%d", &d[i]);
}
memset(mp, 0x3f, sizeof(mp));
for (int i = 1; i <= n; i++) {
mp[i][i] = 0;
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
mp[u][v] = mp[v][u] = 1;
road[u][v] = road[v][u] = 1;
}
floyd();
dfs(1, 0);
printf("%d\n", dp[1][ans[1]]);
calc(1, 0, ans[1]);
for (int i = 1; i <= n; i++) {
printf("%d ", pre[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int head[188], to[2 * 188], nxt[2 * 188];
int dp[188][188], dis[188][188], d[188], centre[188];
int cnt;
int n, cost;
void init() { memset(head, -1, sizeof(head)), cnt = -1; }
void add_e(int a, int b, bool id) {
nxt[++cnt] = head[a], head[a] = cnt, to[cnt] = b;
if (id) add_e(b, a, 0);
}
bool Min(int &a, int b) { return a > b ? a = b, 1 : 0; }
void dfs(int x, int fa) {
for (int y = (1); y <= (n); y++) dp[x][y] = d[dis[x][y]] + cost;
for (int i = head[x], y; ~i; i = nxt[i]) {
if ((y = to[i]) == fa) continue;
dfs(y, x);
for (int j = (1); j <= (n); j++)
dp[x][j] += min(dp[y][j] - cost, dp[y][centre[y]]);
}
centre[x] = 1;
for (int i = (1); i <= (n); i++)
if (dp[x][i] < dp[x][centre[x]]) centre[x] = i;
}
void solution(int x, int cent, int fa) {
centre[x] = cent;
for (int i = head[x], y; ~i; i = nxt[i]) {
if ((y = to[i]) == fa) continue;
if (dp[y][cent] - cost < dp[y][centre[y]])
solution(y, cent, x);
else
solution(y, centre[y], x);
}
}
int main() {
cin >> n >> cost;
for (int i = (1); i <= (n - 1); i++) cin >> d[i];
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) dis[i][j] = (i != j ? 0x3f3f3f3f : 0);
int u, v;
init();
for (int i = (1); i <= (n - 1); i++) {
cin >> u >> v, add_e(u, v, 1);
dis[u][v] = dis[v][u] = 1;
}
for (int k = (1); k <= (n); k++)
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) Min(dis[i][j], dis[i][k] + dis[j][k]);
dfs(1, 0), solution(1, centre[1], 0);
cout << dp[1][centre[1]] << endl;
for (int i = (1); i <= (n); i++) cout << centre[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200, INF = 1000000000;
int n;
int w[MAXN], center[MAXN], best[MAXN];
int dp[MAXN][MAXN], dis[MAXN][MAXN];
vector<int> g[MAXN];
void flody() {
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
;
}
void dfs(int x, int f) {
for (int i = 0; i < g[x].size(); ++i)
if (g[x][i] != f) dfs(g[x][i], x);
int Min(INF);
for (int k = 1; k <= n; ++k) {
dp[x][k] = (x == k ? 0 : w[dis[x][k]]);
for (int i = 0; i < g[x].size(); ++i) {
int v = g[x][i];
if (v == f) continue;
dp[x][k] += min(dp[v][k], dp[v][best[v]] + w[0]);
}
if (Min > dp[x][k]) {
Min = dp[x][k];
best[x] = k;
}
}
}
void path(int x, int f, int k) {
center[x] = k;
for (int i = 0; i < g[x].size(); ++i) {
int v = g[x][i];
if (v == f) continue;
if (dp[v][best[v]] + w[0] <= dp[v][k])
path(v, x, best[v]);
else
path(v, x, k);
}
}
int main() {
while (scanf("%d%d", &n, &w[0]) != EOF) {
for (int i = 1; i < n; ++i) scanf("%d", &w[i]);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) dis[i][j] = 500;
g[i].clear();
dis[i][i] = 0;
}
for (int i = 1, a, b; i < n; ++i) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
dis[a][b] = dis[b][a] = 1;
}
flody();
dfs(1, -1);
path(1, -1, best[1]);
printf("%d\n", dp[1][best[1]] + w[0]);
for (int i = 1; i <= n; ++i) {
if (i == n)
printf("%d\n", center[i]);
else
printf("%d ", center[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, d[205], f[205][205][205], g[205][205], pa[205], dis[205][205];
struct node {
int i, j, k;
node() {}
node(int a, int b, int c) {
i = a;
j = b;
k = c;
}
};
node ffrom[205][205][205], gfrom[205][205];
vector<int> e[205], vec;
void dfs1(int rt, int u, int fa) {
dis[rt][u] = dis[rt][fa] + 1;
for (auto v : e[u])
if (v != fa) {
dfs1(rt, v, u);
}
}
void dfs(int u, int fa) {
bool flag = 0;
pa[u] = fa;
for (auto v : e[u])
if (v != fa) {
dfs(v, u);
flag = 1;
}
if (flag == 0) {
for (int j = (1); j <= (n); j++) {
f[u][j][0] = K;
ffrom[u][j][0] = node(-1, -1, -1);
f[u][j][n] = d[j];
ffrom[u][j][n] = node(0, 0, 0);
if (f[u][j][0] < g[u][j])
g[u][j] = f[u][j][0], gfrom[u][j] = node(u, j, 0);
if (f[u][j][n] < g[u][j])
g[u][j] = f[u][j][n], gfrom[u][j] = node(u, j, n);
}
return;
}
for (int j = (1); j <= (n); j++)
for (int k = (0); k <= (n); k++) {
long long sum = 0;
int Min = 0x3f3f3f3f;
if (k == 0) {
for (auto v : e[u])
if (v != fa) {
sum += g[v][1];
}
if (sum + K < f[u][j][k])
f[u][j][k] = sum + K, ffrom[u][j][k] = node(-1, -1, -1);
if (f[u][j][k] < 0x3f3f3f3f) {
}
if (f[u][j][k] < g[u][j])
g[u][j] = f[u][j][k], gfrom[u][j] = node(u, j, k);
continue;
}
if (k == n) {
node from = node(0, 0, 0);
for (auto v : e[u])
if (v != fa) {
sum += f[v][j + 1][k];
}
if (sum + d[j] < f[u][j][k])
f[u][j][k] = sum + d[j], ffrom[u][j][k] = from;
if (f[u][j][k] < 0x3f3f3f3f) {
}
if (f[u][j][k] < g[u][j])
g[u][j] = f[u][j][k], gfrom[u][j] = node(u, j, k);
continue;
}
node from;
for (auto v : e[u])
if (v != fa) {
sum += g[v][min(min(j, k) + 1, n)];
if (f[v][min(j + 1, n)][k - 1] - g[v][min(min(j, k) + 1, n)] < Min) {
Min = f[v][min(j + 1, n)][k - 1] - g[v][min(min(j, k) + 1, n)];
from = node(v, min(j + 1, n), k - 1);
}
}
if (sum + Min + d[min(j, k)] < f[u][j][k])
f[u][j][k] = sum + Min + d[min(j, k)], ffrom[u][j][k] = from;
if (f[u][j][k] < 0x3f3f3f3f) {
}
if (f[u][j][k] < g[u][j])
g[u][j] = f[u][j][k], gfrom[u][j] = node(u, j, k);
}
}
void tag(node cur) {
if (ffrom[cur.i][cur.j][cur.k].i == 0) return;
if (ffrom[cur.i][cur.j][cur.k].i == -1) {
vec.push_back(cur.i);
for (auto v : e[cur.i])
if (v != pa[cur.i]) {
tag(gfrom[v][1]);
}
return;
}
tag(ffrom[cur.i][cur.j][cur.k]);
for (auto v : e[cur.i])
if (v != pa[cur.i] && v != ffrom[cur.i][cur.j][cur.k].i) {
tag(gfrom[v][min(min(cur.j, cur.k) + 1, n)]);
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
for (int k = (0); k <= (n); k++) f[i][j][k] = g[i][j] = 0x3f3f3f3f;
for (int i = (1); i <= (n - 1); i++) scanf("%d", &d[i]);
d[n] = 0x3f3f3f3f;
for (int i = (2); i <= (n); i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 0);
int ans = 0x3f3f3f3f;
node from;
for (int i = (0); i <= (n - 1); i++)
if (f[1][n][i] < ans) ans = f[1][n][i], from = node(1, n, i);
printf("%d\n", ans);
tag(from);
for (int i = (1); i <= (n); i++) dfs1(i, i, 0);
for (int i = (1); i <= (n); i++) {
int cur = vec[0];
for (auto v : vec)
if (dis[i][v] < dis[i][cur]) cur = v;
printf("%d ", cur);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
const long long inf = 1e18;
vector<int> g[N], st[N];
int dist[N][N], ans[N];
long long d[N], dp[N], dp2[N][N], dp3[N][N][N];
void predfs(int v, int p) {
st[v].push_back(v);
for (int u : g[v]) {
if (u != p) {
predfs(u, v);
for (int x : st[u]) {
st[v].push_back(x);
}
}
}
}
long long compute(int v, int p, int r, int rt) {
if (dp3[v][r][rt] != -1) return dp3[v][r][rt];
if (dist[rt][v] + dist[v][r] == dist[rt][r]) {
long long ret = d[dist[v][r]];
for (int u : g[v]) {
if (u != p) ret += compute(u, v, r, rt);
}
return dp3[v][r][rt] = ret;
} else {
long long ret = d[dist[v][r]];
for (int u : g[v]) {
if (u != p) ret += compute(u, v, r, rt);
}
ret = min(ret, dp[v]);
return dp3[v][r][rt] = ret;
}
}
void dfs(int v, int p) {
for (int u : g[v]) {
if (u != p) dfs(u, v);
}
dp[v] = inf;
for (int r : st[v]) {
dp2[v][r] = compute(v, p, r, v);
dp[v] = min(dp[v], dp2[v][r]);
}
}
void backtrack(int v, int p, int r, int rt) {
if (v == 1) {
for (int r : st[v]) {
if (dp2[v][r] == dp[v]) {
ans[v] = r;
break;
}
}
for (int u : g[v]) {
if (u != p) {
backtrack(u, v, ans[v], v);
}
}
return;
}
if (dist[rt][v] + dist[v][r] == dist[rt][r]) {
ans[v] = r;
for (int u : g[v]) {
if (u != p) {
backtrack(u, v, r, rt);
}
}
} else {
if (dp[v] == compute(v, p, r, rt)) {
for (int r : st[v]) {
if (dp2[v][r] == dp[v]) {
ans[v] = r;
break;
}
}
for (int u : g[v]) {
if (u != p) {
backtrack(u, v, ans[v], v);
}
}
} else {
ans[v] = r;
for (int u : g[v]) {
if (u != p) {
backtrack(u, v, r, rt);
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> d[i];
}
memset(dist, 0x3f, sizeof(dist));
memset(dp3, -1, sizeof(dp3));
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
dist[u][v] = dist[v][u] = 1;
}
for (int i = 1; i <= n; i++) {
dist[i][i] = 0;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
predfs(1, -1);
dfs(1, -1);
backtrack(1, -1, -1, -1);
cout << dp[1] << '\n';
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 514;
vector<int> v[N];
int n, k, w[N], as[N], g[N], f[N][N], d[N][N];
void dfs(int x, int fa) {
for (int i = (1); i <= (n); i++) f[x][i] = w[d[x][i]] + k;
for (int y : v[x])
if (y != fa) {
dfs(y, x);
for (int i = (1); i <= (n); i++) f[x][i] += min(f[y][i] - k, f[y][g[y]]);
}
for (int i = (1); i <= (n); i++)
if (f[x][i] < f[x][g[x]] || !g[x]) g[x] = i;
}
void get(int x, int fa, int nw) {
as[x] = nw;
for (int y : v[x])
if (y != fa) get(y, x, f[y][nw] - k < f[y][g[y]] ? nw : g[y]);
}
int main() {
int x, y;
scanf("%d%d", &n, &k);
memset(d, 0x3f, sizeof(d));
for (int i = (1); i <= (n); i++) d[i][i] = 0;
for (int i = (1); i <= (n - 1); i++) scanf("%d", &w[i]);
for (int i = (1); i <= (n - 1); i++)
scanf("%d%d", &x, &y), d[x][y] = d[y][x] = 1, v[x].push_back(y),
v[y].push_back(x);
for (int k = (1); k <= (n); k++)
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
dfs(1, 0);
printf("%d\n", f[1][g[1]]);
get(1, 0, g[1]);
for (int i = (1); i <= (n); i++) printf("%d ", as[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[200 + 5][200 + 5], best[200 + 5];
int dis[200 + 5][200 + 5];
int w[200 + 5];
vector<int> e[200 + 5];
void caldis(int now, int fa, int rt) {
for (auto v : e[now])
if (v != fa) {
dis[rt][v] = dis[rt][now] + 1;
caldis(v, now, rt);
}
}
int n, k;
void dfs(int now, int fa) {
for (auto v : e[now])
if (v != fa) dfs(v, now);
for (int i = 1; i <= n; i++) dp[now][i] = w[dis[now][i]];
for (auto v : e[now])
if (v != fa) {
for (int i = 1; i <= n; i++)
dp[now][i] += min(dp[v][i], dp[v][best[v]] + k);
}
best[now] = 1;
for (int i = 2; i <= n; i++)
if (dp[now][i] < dp[now][best[now]]) best[now] = i;
}
int ans[200 + 5];
void solve(int now, int fa, int chosen) {
ans[now] = chosen;
for (auto v : e[now])
if (v != fa) {
if (dp[v][chosen] < dp[v][best[v]] + k)
solve(v, now, chosen);
else
solve(v, now, best[v]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n - 1; i++) scanf("%d", &w[i]);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; i++) caldis(i, 0, i);
dfs(1, 0);
printf("%d\n", dp[1][best[1]] + k);
solve(1, 0, best[1]);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200, INF = 1e9;
int dp[N][N], dis[N][N], dpd[N][N], st[N], en[N], d[N], n, k, cur_time;
int ans[N][N], out[N];
vector<int> g[N];
void dfs_dis(int root, int v, int par = -1) {
dis[root][v] = (v == root ? 0 : dis[root][par] + 1);
for (auto u : g[v])
if (u != par) dfs_dis(root, u, v);
}
void dfs_prep(int v = 0, int par = -1) {
st[v] = cur_time++;
for (auto u : g[v])
if (u != par) dfs_prep(u, v);
en[v] = cur_time;
}
bool isPar(int v, int u) { return (st[v] <= st[u] && en[u] <= en[v]); }
void dfs(int v = 0, int par = -1) {
for (auto u : g[v])
if (u != par) dfs(u, v);
for (int i = 0; i <= n - 1; i++) dpd[v][i] = INF;
for (int from = 0; from < n; from++) {
dp[v][from] = d[dis[v][from]];
for (auto u : g[v]) {
if (u == par) continue;
if (isPar(u, from))
dp[v][from] += dp[u][from];
else {
int cur = dpd[u][max(dis[from][v] - 1, 0)];
if (cur > dp[u][from]) cur = dp[u][from];
dp[v][from] += cur;
}
}
int len = dis[v][from];
if (isPar(v, from) && dpd[v][len] > dp[v][from]) {
dpd[v][len] = dp[v][from];
ans[v][len] = from;
}
}
for (int i = n - 2; i >= 0; i--)
if (dpd[v][i] > dpd[v][i + 1]) {
dpd[v][i] = dpd[v][i + 1];
ans[v][i] = ans[v][i + 1];
}
}
void solve(int v, int par, int from) {
out[v] = from;
for (auto u : g[v]) {
if (u == par) continue;
if (isPar(u, from))
solve(u, v, from);
else {
int len = max(0, dis[v][from] - 1);
solve(u, v, (dpd[u][len] <= dp[u][from] ? ans[u][len] : from));
}
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n - 1; i++) cin >> d[i];
d[0] = k;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; i++) dfs_dis(i, i);
dfs_prep();
dfs();
cout << dpd[0][0] << "\n";
solve(0, -1, ans[0][0]);
for (int i = 0; i < n; i++) cout << out[i] + 1 << " \n"[i == n - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
struct rec {
int x;
rec *next;
};
rec a[200];
int c[200];
int d[200][200][2];
int pp[200];
int used[200];
int price[200];
int center[200];
int cc[200][200][2];
int n;
int solve(int i, int j, int k, int up) {
int ni, nj, nk, tmp, min, skip;
rec *p;
if (j == 0) {
center[i] = i;
up = i;
} else if (k == 0)
center[i] = up;
else
center[i] = -1;
if ((k == 0) || (cc[i][j][k] == -1)) {
} else {
ni = cc[i][j][k];
nj = j - 1;
nk = 1;
tmp = solve(ni, nj, nk, up);
center[i] = tmp;
up = center[i];
}
p = a[i].next;
while (p != NULL) {
if (pp[p->x] == i) {
min = d[p->x][j][1];
ni = p->x;
nj = j;
nk = 1;
if ((j + 1 < n) && (d[p->x][j + 1][1] < min)) {
min = d[p->x][j + 1][1];
ni = p->x;
nj = j + 1;
nk = 1;
}
if ((j + 1 < n) && (d[p->x][j + 1][0] < min)) {
min = d[p->x][j + 1][0];
ni = p->x;
nj = j + 1;
nk = 0;
}
if ((j - 1 >= 0) && (d[p->x][j - 1][1] <= min)) {
min = d[p->x][j - 1][1];
ni = p->x;
nj = j - 1;
nk = 1;
}
skip = 0;
if ((k == 0) || (cc[i][j][k] == -1)) {
} else {
if (p->x == cc[i][j][k]) {
skip = 1;
}
}
if (skip == 0) {
tmp = solve(ni, nj, nk, up);
if ((nk == 1) && (nj == j - 1) && (center[i] == -1)) center[i] = tmp;
}
}
p = p->next;
}
return center[i];
}
int main() {
int i, j, ii, k, tot, min, x, y, delta, ans, top, bottom, iszero, allzero, bi;
rec *p;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) a[i].next = NULL;
for (i = 1; i < n; i++) scanf("%d", &price[i]);
price[0] = k;
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
p = new rec();
p->x = y;
p->next = a[x].next;
a[x].next = p;
p = new rec();
p->x = x;
p->next = a[y].next;
a[y].next = p;
}
memset(used, 0, sizeof(used));
c[0] = 0;
pp[0] = -1;
used[0] = 1;
top = 0;
bottom = 1;
while (top < bottom) {
p = a[c[top]].next;
while (p != NULL) {
if (used[p->x] == 0) {
pp[p->x] = c[top];
used[p->x] = 1;
c[bottom] = p->x;
bottom++;
}
p = p->next;
}
top++;
}
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
d[i][j][0] = 2000000000;
d[i][j][1] = 2000000000;
}
for (ii = bottom - 1; ii >= 0; ii--) {
i = c[ii];
for (j = 0; j < n; j++) {
allzero = 1;
p = a[i].next;
tot = 0;
while (p != NULL) {
if (pp[p->x] == i) {
min = d[p->x][j][1];
if ((j + 1 < n) && (d[p->x][j + 1][1] < min)) min = d[p->x][j + 1][1];
if ((j + 1 < n) && (d[p->x][j + 1][0] < min)) min = d[p->x][j + 1][0];
iszero = 1;
if ((j - 1 >= 0) && (d[p->x][j - 1][1] <= min)) {
min = d[p->x][j - 1][1];
bi = p->x;
iszero = 0;
}
if (min == 2000000000) {
tot = 2000000000;
break;
}
tot += min;
if (iszero == 0) allzero = 0;
}
p = p->next;
}
if (tot == 2000000000) continue;
d[i][j][0] = tot + price[j];
if ((allzero == 0) || (j == 0)) {
d[i][j][1] = tot + price[j];
if (allzero == 0)
cc[i][j][1] = bi;
else
cc[i][j][1] = -1;
} else {
delta = 2000000000;
p = a[i].next;
while (p != NULL) {
if (pp[p->x] == i) {
min = d[p->x][j][1];
if ((j + 1 < n) && (d[p->x][j + 1][1] < min))
min = d[p->x][j + 1][1];
if ((j + 1 < n) && (d[p->x][j + 1][0] < min))
min = d[p->x][j + 1][0];
if ((j - 1 >= 0) && (d[p->x][j - 1][1] != 2000000000)) {
if (d[p->x][j - 1][1] - min < delta) {
delta = d[p->x][j - 1][1] - min;
bi = p->x;
}
}
}
p = p->next;
}
if (delta != 2000000000) {
d[i][j][1] = tot + delta + price[j];
cc[i][j][1] = bi;
}
}
}
}
ans = 2000000000;
for (i = 0; i < n; i++)
if (d[0][i][1] < ans) {
ans = d[0][i][1];
bi = i;
}
printf("%d\n", ans);
solve(0, bi, 1, -1);
for (i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", center[i] + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1007, maxnum = 1000000000;
int n, K, tot, root;
int D[maxn], dist[maxn];
int now[maxn], pre[maxn * 2], y[maxn * 2], cost[maxn * 2];
int f[maxn][maxn], best[maxn], ans[maxn];
void cnt(int fir, int lst, int val) {
pre[++tot] = now[fir];
now[fir] = tot;
y[tot] = lst;
cost[tot] = val;
}
void init() {
scanf("%d %d", &n, &K);
for (int i = 1; i < n; i++) scanf("%d", &D[i]);
tot = 0;
memset(now, 0, sizeof(now));
for (int i = 1; i < n; i++) {
int fir, lst;
scanf("%d %d", &fir, &lst);
cnt(fir, lst, 1);
cnt(lst, fir, 1);
}
}
void sortpath(int x) {
for (int mark = now[x]; mark; mark = pre[mark])
if (dist[y[mark]] == maxnum)
dist[y[mark]] = dist[x] + cost[mark], sortpath(y[mark]);
}
void dfs(int x, int father) {
for (int mark = now[x]; mark; mark = pre[mark])
if (y[mark] != father) dfs(y[mark], x);
for (int i = 1; i <= n; i++) dist[i] = maxnum;
dist[x] = 0;
sortpath(x);
best[x] = maxnum;
for (int j = 1; j <= n; j++) {
f[x][j] = 0;
for (int mark = now[x]; mark; mark = pre[mark])
if (y[mark] != father) f[x][j] += min(f[y[mark]][j] - K, best[y[mark]]);
f[x][j] += K + D[dist[j]];
if (f[x][j] < best[x]) best[x] = f[x][j], ans[x] = j;
}
}
void output(int x, int father) {
for (int mark = now[x]; mark; mark = pre[mark])
if (y[mark] != father) {
if (f[y[mark]][ans[x]] - K < best[y[mark]]) ans[y[mark]] = ans[x];
output(y[mark], x);
}
}
void work() {
init();
root = 1;
dfs(root, 0);
output(root, 0);
printf("%d\n", best[root]);
for (int i = 1; i <= n; i++)
if (i < n)
printf("%d ", ans[i]);
else
printf("%d\n", ans[i]);
}
int main() { work(); }
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int d[188];
int par[188];
vector<int> g[188];
int dp[188][188];
int pos[188];
int ans[188];
void build(int x, int pre) {
par[x] = pre;
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
if (to == pre) {
g[x].erase(g[x].begin() + i, g[x].begin() + i + 1);
i--;
continue;
}
build(to, x);
}
}
void dfs(int x) {
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
dfs(to);
}
for (int y = (0); y < (n); ++y) {
int z = y;
while (z != x && z != -1) z = par[z];
if (z == -1) continue;
z = y;
int cur = 0, lst = -1, dis = 0;
while (1) {
cur += (dis ? d[dis] : k);
dis++;
for (int i = (0); i < (g[z].size()); ++i) {
int to = g[z][i];
if (to == lst) continue;
cur += dp[to][dis];
}
if (z == x) break;
lst = z;
z = par[z];
}
if (cur < dp[x][0]) {
dp[x][0] = cur;
pos[x] = y;
}
}
for (int dis = (1); dis < (n); ++dis) {
dp[x][dis] = dp[x][0];
int cur = d[dis];
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
cur += dp[to][dis + 1];
}
if (cur < dp[x][dis]) {
dp[x][dis] = cur;
}
}
}
void getans(int x, int dis, int lst) {
if (dp[x][dis] != dp[x][0]) {
ans[x] = lst;
for (int i = (0); i < (g[x].size()); ++i) {
int to = g[x][i];
getans(to, dis + 1, lst);
}
return;
}
int y = pos[x];
int z = y;
dis = 0;
lst = -1;
while (1) {
ans[z] = y;
dis++;
for (int i = (0); i < (g[z].size()); ++i) {
int to = g[z][i];
if (to == lst) continue;
getans(to, dis, y);
}
if (z == x) break;
lst = z;
z = par[z];
}
}
int main() {
memset(dp, 0x3f, sizeof(dp));
cin >> n >> k;
for (int i = (1); i < (n); ++i) cin >> d[i];
for (int i = (1); i < (n); ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
build(0, -1);
dfs(0);
cout << dp[0][0] << endl;
getans(0, 0, -1);
for (int i = (0); i < (n); ++i) {
cout << ans[i] + 1 << (i == n - 1 ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
const long long N = 188;
vector<pair<long long, long long> > pr[N][N];
long long dp[N][N];
vector<long long> G[N];
long long d[N], len[N][N];
void outt(long long x) {
if (x >= 1000)
cout << "* ";
else
cout << x << ' ';
}
void dfs1(long long x, long long F) {
for (long long i = 0; i < G[x].size(); i++) {
long long tmp = G[x][i];
if (tmp == F) continue;
dfs1(tmp, x);
}
if ((G[x].size() == 1 && G[x][0] == F) || !G[x].size()) {
for (long long j = 1; j <= n; j++)
dp[x][j] = d[len[x][j]] + (x == j ? 1 : 0) * k;
}
for (long long j = 1; j <= n; j++) {
pr[x][j].resize(G[x].size());
for (long long p = 0; p < G[x].size(); p++) pr[x][j][p] = make_pair(0, 0);
long long s = 0;
for (long long p = 0; p < G[x].size(); p++) {
long long tmp = G[x][p];
if (tmp == F) continue;
long long minv = 1e9;
for (long long u = 1; u <= n; u++) {
if (len[tmp][u] > len[tmp][j] || len[x][u] < len[x][j]) continue;
if (dp[tmp][u] < minv) {
minv = dp[tmp][u];
pr[x][j][p] = make_pair(tmp, u);
}
}
s += minv;
}
dp[x][j] = s + d[len[x][j]] + (x == j) * k;
}
}
long long ans[N], b[N];
void dfs2(long long x, long long j, long long F) {
if (x == j) b[x] = x;
if (!x) return;
for (long long i = 0; i < G[x].size(); i++) {
long long tmp = G[x][i];
if (tmp == F) continue;
dfs2(pr[x][j][i].first, pr[x][j][i].second, x);
}
}
signed main() {
cin >> n >> k;
for (long long i = 1; i < n; i++) cin >> d[i];
memset(len, 10, sizeof(len));
for (long long i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
len[u][v] = len[v][u] = 1;
}
for (long long i = 1; i <= n; i++) len[i][i] = 0;
memset(dp, 10, sizeof(dp));
for (long long p = 1; p <= n; p++)
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++) {
if (i != j && i != p && j != p)
len[i][j] = min(len[i][j], len[i][p] + len[p][j]);
}
dfs1(1, 0);
pair<long long, long long> res = make_pair(1e9, 0);
for (long long i = 1; i <= n; i++) res = min(res, make_pair(dp[1][i], i));
dfs2(1, res.second, 0);
for (long long i = 1; i <= n; i++)
if (!ans[i]) {
pair<long long, long long> mi = make_pair(1e9, 0);
for (long long j = 1; j <= n; j++)
if (b[j]) mi = min(mi, make_pair(len[i][j], j));
ans[i] = mi.second;
}
cout << res.first << endl;
for (long long i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, f[190][190], a[190], d[190][190], ans[190], pre[190];
vector<long long> edge[190];
inline void floyd() {
for (long long k = 1; k <= n; k++) {
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
d[i][j] = d[j][i] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
void dfs(long long m, long long before) {
for (long long i = 1; i <= n; i++) f[m][i] = a[d[m][i]] + k;
for (long long i = 0; i < edge[m].size(); i++) {
long long Next = edge[m][i];
if (Next != before) {
dfs(Next, m);
for (long long j = 1; j <= n; j++)
f[m][j] += min(f[Next][ans[Next]], f[Next][j] - k);
}
}
ans[m] = 1;
for (long long i = 2; i <= n; i++) {
if (f[m][i] < f[m][ans[m]]) ans[m] = i;
}
}
void print(long long m, long long before, long long x) {
pre[m] = x;
for (long long i = 0; i < edge[m].size(); i++) {
long long Next = edge[m][i];
if (Next != before) {
if (f[Next][ans[Next]] < f[Next][x] - k)
print(Next, m, ans[Next]);
else
print(Next, m, x);
}
}
}
int main() {
cin >> n >> k;
for (long long i = 1; i < n; i++) scanf("%lld", &a[i]);
memset(d, 0x3f, sizeof(d));
for (long long i = 1; i <= n; i++) d[i][i] = 0;
for (long long i = 1; i < n; i++) {
long long x, y;
scanf("%lld %lld", &x, &y);
d[x][y] = d[y][x] = 1;
edge[x].push_back(y);
edge[y].push_back(x);
}
floyd();
dfs(1, 0);
printf("%lld\n", f[1][ans[1]]);
print(1, 0, ans[1]);
for (long long i = 1; i <= n; i++) printf("%lld ", pre[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
const int inf = 1e9 + 10;
int dp[maxn][maxn], d[maxn], dist[maxn][maxn];
vector<pair<int, int> > from[maxn][maxn];
pair<int, int> f[maxn];
vector<int> g[maxn];
int n, k;
void getdist(int root, int x, int fa) {
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (to == fa) continue;
dist[root][to] = dist[root][x] + 1;
getdist(root, to, x);
}
}
void getdp(int x, int fa) {
if (g[x].size() == 1 && fa != -1) {
for (int i = 0; i < n; i++) {
dp[x][i] = d[dist[x][i]] + k;
}
f[x] = make_pair(inf, -1);
for (int i = 0; i < n; i++) {
if (f[x].first > dp[x][i]) {
f[x].first = dp[x][i];
f[x].second = i;
}
}
return;
}
for (int i = 0; i < n; i++) dp[x][i] = 0;
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (to == fa) continue;
getdp(to, x);
for (int j = 0; j < n; j++) {
if (dp[to][j] - k <= f[to].first) {
dp[x][j] += dp[to][j] - k;
from[x][j].push_back(make_pair(to, j));
} else {
dp[x][j] += f[to].first;
from[x][j].push_back(make_pair(to, f[to].second));
}
}
}
f[x] = make_pair(inf, -1);
for (int i = 0; i < n; i++) {
dp[x][i] += d[dist[x][i]] + k;
if (dp[x][i] < f[x].first) {
f[x].first = dp[x][i];
f[x].second = i;
}
}
}
bool station[maxn];
void getans(int x, int t) {
station[t] = 1;
if (from[x][t].size() == 0) return;
for (int i = 0; i < from[x][t].size(); i++) {
int to = from[x][t][i].first, id = from[x][t][i].second;
getans(to, id);
}
}
int main() {
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxn; j++) dp[i][j] = inf;
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++) getdist(i, i, -1);
getdp(0, -1);
int ans = inf, id = -1;
for (int i = 0; i < n; i++) {
if (dp[0][i] < ans) {
ans = dp[0][i];
id = i;
}
}
getans(0, id);
printf("%d\n", ans);
for (int i = 0; i < n; i++) {
int dis = inf, id = -1;
for (int j = 0; j < n; j++)
if (station[j]) {
if (dist[i][j] < dis) {
dis = dist[i][j];
id = j;
}
}
printf("%d ", id + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 185, INF = 1e9;
int n, K, cost[N], dist[N][N], dp[N][N], opt[N], belong[N];
vector<int> T[N];
inline void Min(int &a, int b) {
if (b < a) a = b;
}
void Floyd() {
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) Min(dist[i][j], dist[i][k] + dist[k][j]);
}
void DP(int cur, int par) {
for (int i = 1; i <= n; ++i) dp[cur][i] = cost[dist[cur][i]];
for (int i = 0; i < T[cur].size(); ++i) {
int son = T[cur][i];
if (son == par) continue;
DP(son, cur);
for (int i = 1; i <= n; ++i)
dp[cur][i] += min(dp[son][i], dp[son][opt[son]] + K);
}
opt[cur] = -1;
for (int i = 1; i <= n; ++i)
if (opt[cur] == -1 || dp[cur][i] < dp[cur][opt[cur]]) opt[cur] = i;
}
void assign(int cur, int par, int tar) {
belong[cur] = tar;
for (int i = 0; i < T[cur].size(); ++i) {
int son = T[cur][i];
if (son == par) continue;
assign(son, cur, dp[son][opt[son]] + K < dp[son][tar] ? opt[son] : tar);
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) T[i].clear();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dist[i][j] = (i != j) * INF;
cost[0] = 0;
for (int i = 1; i < n; ++i) scanf("%d", &cost[i]);
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
dist[u][v] = dist[v][u] = 1;
T[u].push_back(v);
T[v].push_back(u);
}
Floyd();
DP(1, 0);
assign(1, 0, opt[1]);
printf("%d\n", dp[1][opt[1]] + K);
for (int i = 1; i <= n; ++i) printf("%d%c", belong[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 210;
int n, k;
int d[MaxN];
int v[MaxN][MaxN];
void init() {
cin >> n >> k;
for (int i = 1; i < n; ++i) cin >> d[i];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) v[i][j] = MaxN;
v[i][i] = 0;
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
v[x][y] = v[y][x] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) v[i][j] = min(v[i][j], v[i][k] + v[k][j]);
}
int F[MaxN][MaxN];
int c[MaxN];
void solve(int x, int p) {
for (int i = 1; i <= n; ++i) F[x][i] = d[v[x][i]] + k;
for (int i = 1; i <= n; ++i)
if (v[x][i] == 1 && i != p) {
solve(i, x);
for (int j = 1; j <= n; ++j) F[x][j] += min(F[i][j] - k, F[i][c[i]]);
}
c[x] = 1;
for (int i = 1; i <= n; ++i)
if (F[x][c[x]] > F[x][i]) c[x] = i;
}
int ans[MaxN];
void get(int x, int p, int cx) {
ans[x] = cx;
for (int i = 1; i <= n; ++i)
if (v[x][i] == 1 && i != p)
get(i, x, (F[i][cx] - k < F[i][c[i]]) ? cx : c[i]);
}
void work() {
solve(1, 0);
cout << F[1][c[1]] << endl;
get(1, 0, c[1]);
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
int dis[N][N], dp[N][N], pre[N], d[N], ans[N], n, m;
vector<int> v[N];
void dfs(int now, int fa) {
for (int i = 0; i < n; i++) dp[now][i] = d[dis[now][i]] + m;
for (int i = 0; i < v[now].size(); i++) {
int to = v[now][i];
if (fa != to) {
dfs(to, now);
for (int k = 0; k < n; k++)
dp[now][k] += min(dp[to][pre[to]], dp[to][k] - m);
}
}
for (int k = 0; k < n; k++)
if (dp[now][k] < dp[now][pre[now]]) pre[now] = k;
return;
}
void print(int now, int f, int a) {
ans[now] = a;
for (int i = 0; i < v[now].size(); i++) {
int to = v[now][i];
if (to != f)
if (dp[to][pre[to]] > dp[to][a] - m)
print(to, now, a);
else
print(to, now, pre[to]);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i < n; i++) cin >> d[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j) dis[i][j] = 1e9;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--, b--;
v[a].push_back(b);
v[b].push_back(a);
dis[a][b] = dis[b][a] = 1;
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(0, 0);
cout << dp[0][pre[0]] << "\n";
print(0, 0, pre[0]);
for (int i = 0; i < n; i++) cout << ans[i] + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200 + 5;
int n, K;
int d[MX];
int dis[MX][MX];
vector<int> G[MX];
int dp[MX][MX], ans[MX], path[MX];
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[dis[u][i]] + K;
for (auto v : G[u]) {
if (v == fa) continue;
dfs(v, u);
for (int i = 1; i <= n; i++) dp[u][i] += min(dp[v][ans[v]], dp[v][i] - K);
}
ans[u] = 1;
for (int i = 2; i <= n; i++) {
if (dp[u][i] < dp[u][ans[u]]) ans[u] = i;
}
}
void get_ans(int u, int fa, int i) {
path[u] = i;
for (auto v : G[u]) {
if (v == fa) continue;
if (dp[v][ans[v]] < dp[v][i] - K)
get_ans(v, u, ans[v]);
else
get_ans(v, u, i);
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dis[i][j] = i == j ? 0 : 1e9;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
dfs(1, 0);
get_ans(1, 0, ans[1]);
printf("%d\n", dp[1][ans[1]]);
for (int i = 1; i <= n; i++) printf("%d%c", path[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)(1) << 50;
int n, price;
int w[205];
long long mat[205][205];
int near[205][205];
long long F[205][205];
int belong[205];
void Floyed() {
int i, j, k;
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (mat[i][k] + mat[k][j] < mat[i][j])
mat[i][j] = mat[i][k] + mat[k][j];
}
void Make_Near() {
int i, j, k;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i != j) {
for (k = 1; k <= n; k++)
if (mat[k][j] == mat[i][j] - 1 && mat[i][k] == 1) near[i][j] = k;
}
}
void dfs(int p, int fa) {
int i, j, k, l;
for (i = 1; i <= n; i++)
if (mat[p][i] == 1 && i != fa) dfs(i, p);
for (j = 1; j <= n; j++)
if (p == j)
F[p][j] = price;
else
F[p][j] = w[mat[p][j]];
for (i = 1; i <= n; i++)
if (mat[p][i] == 1 && i != fa)
for (j = 1; j <= n; j++) {
long long Min = INF;
for (k = 1; k <= n; k++) {
if (near[i][k] == p && k != j) continue;
if (near[p][j] == i && k != j) continue;
if (F[i][k] < Min) Min = F[i][k];
}
F[p][j] += Min;
}
}
void Out(int p, int j, int fa) {
belong[p] = j;
for (int i = 1; i <= n; i++)
if (mat[p][i] == 1 && i != fa) {
long long Min = INF;
int Mini = 0;
for (int k = 1; k <= n; k++) {
if (near[i][k] == p && k != j) continue;
if (near[p][j] == i && k != j) continue;
if (F[i][k] < Min) {
Min = F[i][k];
Mini = k;
}
}
Out(i, Mini, p);
}
}
void output() {
long long Min = INF, Mini = 0;
for (int i = 1; i <= n; i++)
if (F[1][i] < Min) {
Min = F[1][i];
Mini = i;
}
cout << Min << endl;
memset(belong, 0, sizeof(belong));
Out(1, Mini, 0);
for (int i = 1; i <= n; i++) cout << belong[i] << " ";
cout << endl;
}
int main() {
scanf("%d%d", &n, &price);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i == j)
mat[i][j] = 0;
else
mat[i][j] = INF;
w[0] = 0;
for (int i = 1; i < n; i++) scanf("%d", &w[i]);
for (int x, y, i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
mat[x][y] = mat[y][x] = 1;
}
Floyed();
Make_Near();
dfs(1, 0);
output();
}
|
#include <bits/stdc++.h>
const int inf = 1000000000;
int n, bcost;
int dcost[205];
int deg[205] = {0}, adj[205][205];
int pred[205];
bool subof[205][205] = {0};
int len[205][205];
int dp[205][205], self[205], subr[205];
int order[205], oid = 0;
int root[205];
inline int min(int a, int b) { return a < b ? a : b; }
inline void relax(int &x, int val) {
if (val < x) x = val;
}
void dfs(int v, int p, int s, int l, bool ss = 0) {
len[s][v] = l;
if (ss) subof[s][v] = 1;
if (s == 1) pred[v] = p;
for (int i = 0; i < deg[v]; i++) {
int u = adj[v][i];
if (u == p) continue;
dfs(u, v, s, l + 1, ss);
}
if (!ss && s == 1) order[oid++] = v;
}
inline void pre() {
for (int v = 1; v <= n; v++) dfs(v, 0, v, 0);
for (int v = 1; v <= n; v++) dfs(v, pred[v], v, 0, 1);
for (int v = 1; v <= n; v++) {
for (int i = 0; i < deg[v]; i++) {
int u = adj[v][i];
if (u == pred[v]) {
adj[v][i] = adj[v][--deg[v]];
break;
}
}
}
}
inline void process(int v) {
for (int r = 1; r <= n; r++) {
int c = dcost[len[v][r]] + (r == v ? bcost : 0);
for (int i = 0; i < deg[v]; i++) {
int u = adj[v][i];
if (subof[u][r])
c += dp[u][r];
else
c += min(self[u], dp[u][r]);
}
dp[v][r] = c;
}
self[v] = inf;
subr[v] = 0;
for (int u = 1; u <= n; u++) {
if (subof[v][u]) {
if (dp[v][u] < self[v]) {
self[v] = dp[v][u];
subr[v] = u;
}
}
}
}
inline void recover(int v, int r) {
if (subof[v][r] || dp[v][r] <= self[v])
root[v] = r;
else
root[v] = subr[v];
}
inline void solve() {
pre();
for (int i = 0; i < n; i++) process(order[i]);
dp[1][0] = inf;
for (int i = n - 1; i >= 0; i--) {
int v = order[i];
recover(v, v == 1 ? 0 : root[pred[v]]);
}
printf("%d\n", self[1]);
for (int v = 1; v <= n; v++) printf("%d%c", root[v], v < n ? ' ' : '\n');
}
int main(void) {
scanf("%d %d", &n, &bcost);
dcost[0] = 0;
for (int i = 1; i < n; i++) scanf("%d", dcost + i);
for (int i = 1; i < n; i++) {
int v, u;
scanf("%d %d", &v, &u);
adj[v][deg[v]++] = u;
adj[u][deg[u]++] = v;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
int N, K;
int D[185], C[185];
int d[185][185], f[185][185];
void dfs(int x, int fa) {
for (int i = 1; i <= N; ++i) f[x][i] = D[d[x][i]] + K;
for (int i = 1; i <= N; ++i)
if (d[x][i] == 1 && i != fa) {
dfs(i, x);
for (int j = 1; j <= N; ++j) {
if (f[i][C[i]] < f[i][j] - K)
f[x][j] += f[i][C[i]];
else
f[x][j] += f[i][j] - K;
}
}
C[x] = 1;
for (int i = 2; i <= N; ++i)
if (f[x][i] < f[x][C[x]]) C[x] = i;
}
void get(int x, int fa, int c) {
for (int i = 1; i <= N; ++i)
if (d[x][i] == 1 && i != fa)
if (f[i][C[i]] > f[i][c] - K) C[i] = c;
for (int i = 1; i <= N; ++i)
if (d[x][i] == 1 && i != fa) get(i, x, C[i]);
}
int main() {
N = read(), K = read();
for (int i = 1; i < N; ++i) D[i] = read();
memset(d, 6, sizeof(d));
for (int i = 1; i < N; ++i) {
int X = read(), Y = read();
d[X][Y] = d[Y][X] = 1;
}
for (int i = 1; i <= N; ++i) d[i][i] = 0;
for (int k = 1; k <= N; ++k)
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j)
if (d[i][j] > d[i][k] + d[k][j]) d[i][j] = d[i][k] + d[k][j];
dfs(1, 0);
printf("%d\n", f[1][C[1]]);
get(1, 0, C[1]);
for (int i = 1; i < N; ++i) printf("%d ", C[i]);
printf("%d\n", C[N]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 10;
int n, k;
int d[200], dist[200][200];
int dp[200][200], mp[200];
int l[200], r[200], id = 0;
bool edge[200][200];
int p[200];
void floyd() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j) dist[i][j] = inf;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (edge[i][j]) dist[i][j] = 1;
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
void get_lr(int x, int fa) {
l[x] = id++;
for (int i = 0; i < n; i++) {
if (i == fa || !edge[x][i]) continue;
get_lr(i, x);
}
r[x] = id++;
}
void dfs(int x, int fa) {
for (int i = 0; i < n; i++) {
if (i == fa || !edge[x][i]) continue;
dfs(i, x);
int mv = inf;
for (int j = 0; j < n; j++) {
if (l[i] <= l[j] && r[j] <= r[i]) {
if (mv > dp[i][j]) {
mv = dp[i][j];
mp[i] = j;
}
}
}
}
for (int pos = 0; pos < n; pos++) {
for (int i = 0; i < n; i++) {
if (i == fa || !edge[x][i]) continue;
if (dp[i][mp[i]] <= dp[i][pos] - k)
dp[x][pos] += dp[i][mp[i]];
else
dp[x][pos] += dp[i][pos] - k;
}
dp[x][pos] += d[dist[x][pos]] + k;
}
}
void get_ans(int x, int pos, int fa) {
for (int i = 0; i < n; i++) {
if (i == fa || !edge[x][i]) continue;
if (dp[i][mp[i]] <= dp[i][pos] - k)
p[i] = mp[i];
else
p[i] = pos;
get_ans(i, p[i], x);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i < n; i++) cin >> d[i];
for (int i = 0; i + 1 < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
edge[u][v] = edge[v][u] = true;
}
floyd();
memset(mp, -1, sizeof(mp));
get_lr(0, -1);
dfs(0, -1);
int pos = -1, ans = inf;
for (int i = 0; i < n; i++) {
if (dp[0][i] < ans) {
ans = dp[0][i];
pos = i;
}
}
p[0] = pos;
get_ans(0, pos, -1);
cout << ans << endl;
for (int i = 0; i < n; i++) cout << p[i] + 1 << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[233];
int n, k, dis[233][233], dp[233][233], cst[233], res[233], realans[233];
void dfs(int x, int p) {
for (int i = 0; i < n; i++) dp[x][i] = cst[dis[x][i]] + k;
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] != p) {
dfs(v[x][i], x);
for (int j = 0; j < n; j++)
dp[x][j] += min(dp[v[x][i]][res[v[x][i]]], dp[v[x][i]][j] - k);
}
pair<int, int> ans = make_pair(233333333, 233333333);
for (int i = 0; i < n; i++) ans = min(ans, make_pair(dp[x][i], i));
res[x] = ans.second;
}
void pth(int x, int p, int nw) {
realans[x] = nw;
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] != p)
if (dp[v[x][i]][res[v[x][i]]] < dp[v[x][i]][nw] - k)
pth(v[x][i], x, res[v[x][i]]);
else
pth(v[x][i], x, nw);
}
int main() {
cin >> n >> k;
for (int i = 1; i < n; i++) cin >> cst[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dis[i][j] = 2333;
for (int i = 0; i < n; i++) dis[i][i] = 0;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
dis[a][b] = 1;
dis[b][a] = 1;
v[a].push_back(b);
v[b].push_back(a);
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(0, -1);
cout << dp[0][res[0]] << endl;
pth(0, -1, res[0]);
for (int i = 0; i < n; i++) cout << realans[i] + 1 << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int limite = 200;
const int infinito = 1000000000;
int n, k;
vector<int> g[limite];
int d[limite];
long long int coste[limite][limite][limite];
long long int costemayor[limite][limite][limite];
int eleccion[limite][limite][limite];
int padre[limite];
int sol[limite];
void generasolinf(int u, int d1, int d2inf);
void generasol(int u, int d1, int d2) {
int vistoelegido = 0;
int nextd1 = min(n, min(d1 + 1, d2 + 1));
int nextd2 = d2 - 1;
if (d2 == 0) nextd2 = 0;
if (d2 == n) nextd2 = n;
if (d2 == 0)
sol[u] = u;
else if (d1 <= d2)
sol[u] = sol[padre[u]];
else {
generasol(eleccion[u][d1][d2], nextd1, nextd2);
sol[u] = sol[eleccion[u][d1][d2]];
vistoelegido = 1;
}
if (eleccion[u][d1][d2] != 0 and not vistoelegido)
generasol(eleccion[u][d1][d2], nextd1, nextd2);
vector<int> &ar = g[u];
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i];
if (v != eleccion[u][d1][d2]) generasolinf(v, nextd1, nextd2);
}
}
void generasolinf(int u, int d1, int d2inf) {
long long int c = costemayor[u][d1][d2inf];
for (int d2 = d2inf; d2 <= n; d2++)
if (coste[u][d1][d2] == c) generasol(u, d1, d2);
}
void calcula(int u) {
vector<int> &ar = g[u];
for (int i = 0; i < int(ar.size()); i++) calcula(ar[i]);
for (int d1 = 1; d1 <= n; d1++) {
coste[u][d1][0] = k;
for (int i = 0; i < int(ar.size()); i++)
coste[u][d1][0] += costemayor[ar[i]][1][0];
for (int d2 = 1; d2 <= n; d2++) {
coste[u][d1][d2] = infinito;
if (int(ar.size()) == 0) {
if (d2 < n)
coste[u][d1][d2] = infinito;
else
coste[u][d1][d2] = d[d1];
} else {
long long int suma = 0;
int nextd1 = min(n, min(d1 + 1, d2 + 1));
int nextd2 = d2 - 1;
if (d2 == n) nextd2 = n;
for (int i = 0; i < int(ar.size()); i++)
suma += costemayor[ar[i]][nextd1][nextd2];
for (int i = 0; i < int(ar.size()); i++) {
long long int nextcoste = d[min(d1, d2)] + suma -
costemayor[ar[i]][nextd1][nextd2] +
coste[ar[i]][nextd1][nextd2];
if (coste[u][d1][d2] > nextcoste) {
coste[u][d1][d2] = nextcoste;
eleccion[u][d1][d2] = ar[i];
}
}
}
}
costemayor[u][d1][n] = coste[u][d1][n];
for (int d2 = n - 1; d2 >= 0; d2--)
costemayor[u][d1][d2] = min(coste[u][d1][d2], costemayor[u][d1][d2 + 1]);
}
}
void liquidapadre(int u, int p) {
padre[u] = p;
vector<int> &ar = g[u];
vector<int> nextar;
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i];
if (v != p) {
nextar.push_back(v);
liquidapadre(v, u);
}
}
ar = nextar;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n - 1; i++) cin >> d[i];
d[n] = infinito;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
liquidapadre(1, 0);
calcula(1);
cout << costemayor[1][n][0] << endl;
generasolinf(1, n, 0);
for (int u = 1; u <= n; u++) {
if (u > 1) cout << " ";
cout << sol[u];
}
cout << endl;
}
|
#include <bits/stdc++.h>
const int N = 205, M = 405;
int n, k, tot, lnk[N], ter[M], nxt[M], d[N], dis[N][N], f[N][N], p[N], ans[N];
void add(int u, int v) { ter[++tot] = v, nxt[tot] = lnk[u], lnk[u] = tot; }
void Floyd() {
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
dis[i][j] = std::min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
}
void dfs(int u, int fa) {
for (int i = 1; i <= n; ++i) f[i][u] = d[dis[i][u]] + k;
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (v == fa) continue;
dfs(v, u);
for (int i = 1; i <= n; ++i) {
f[i][u] += std::min(f[p[v]][v], f[i][v] - k);
}
}
p[u] = 1;
for (int i = 1; i <= n; ++i)
if (f[i][u] < f[p[u]][u]) p[u] = i;
}
void getPath(int u, int fa, int pos) {
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (v == fa) continue;
if (f[p[v]][v] > f[pos][v] - k)
ans[v] = pos;
else
ans[v] = p[v];
getPath(v, u, ans[v]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", &d[i]);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
dis[u][v] = dis[v][u] = 1, add(u, v), add(v, u);
}
Floyd();
dfs(1, 0);
printf("%d\n", f[p[1]][1]);
ans[1] = p[1];
getPath(1, 0, ans[1]);
for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200;
const int INF = 1e9;
long long n, k;
long long d[maxn], dis[maxn][maxn];
long long id, first[maxn];
long long f[maxn][maxn], ans[maxn], out[maxn];
struct edge {
long long to, next;
} e[maxn * 2];
void addE(long long from, long long to) {
e[++id].to = to;
e[id].next = first[from];
first[from] = id;
}
void dfs(long long p, long long fa) {
for (long long i = 1; i <= n; i++) f[p][i] = d[dis[p][i]] + k;
for (long long i = first[p]; i; i = e[i].next) {
long long to = e[i].to;
if (to == fa) continue;
dfs(to, p);
for (long long j = 1; j <= n; j++)
f[p][j] += min(f[to][j] - k, f[to][ans[to]]);
}
ans[p] = 1;
for (long long i = 2; i <= n; i++)
if (f[p][i] < f[p][ans[p]]) ans[p] = i;
}
void init(long long p, long long fa, long long x) {
out[p] = x;
for (long long i = first[p]; i; i = e[i].next) {
long long to = e[i].to;
if (to == fa) continue;
init(to, p, f[to][ans[to]] < f[to][x] - k ? ans[to] : x);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 1; i < n; i++) cin >> d[i];
memset(dis, 0x3f3f, sizeof dis);
for (long long i = 1; i <= n; i++) dis[i][i] = 0;
for (long long i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
dis[u][v] = dis[v][u] = 1;
addE(u, v), addE(v, u);
}
for (long long k = 1; k <= n; k++)
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
cout << f[1][ans[1]] << endl;
init(1, 0, ans[1]);
for (long long i = 1; i <= n; i++) cout << out[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d[205], dis[205][205], dp[205][205];
int p[205];
int ans[205];
vector<int> v[205];
void aux() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int r = 1; r <= n; r++)
dis[i][r] = min(dis[i][r], dis[i][k] + dis[k][r]);
}
void solve(int x, int fa) {
for (int i = 1; i <= n; i++) dp[i][x] = d[dis[i][x]] + k;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (to == fa) continue;
solve(to, x);
for (int r = 1; r <= n; r++) dp[r][x] += min(dp[p[to]][to], dp[r][to] - k);
}
p[x] = 1;
for (int i = 2; i <= n; i++)
if (dp[p[x]][x] > dp[i][x]) p[x] = i;
}
void getans(int x, int fa) {
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (to == fa) continue;
ans[to] = (dp[p[to]][to] < dp[ans[x]][to] - k) ? p[to] : ans[x];
getans(to, x);
}
}
signed main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", d + i);
memset(dis, 0X3f, sizeof dis);
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
dis[a][b] = dis[b][a] = 1;
v[a].push_back(b);
v[b].push_back(a);
}
aux();
solve(1, 0);
printf("%d\n", dp[p[1]][1]);
ans[1] = p[1];
getans(1, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next;
} e[183 << 1];
int head[183], cnte;
void add(int u, int v) {
e[++cnte].to = v;
e[cnte].next = head[u];
head[u] = cnte;
}
int n, k, d[183], dis[183][183], dp[183][183], mi[183], ANS[183];
void dfs(int u, int last) {
for (int i = 1; i <= n; i++) dp[u][i] = d[dis[u][i]] + k;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == last) continue;
dfs(v, u);
for (int j = 1; j <= n; j++) {
dp[u][j] += min(dp[v][j] - k, dp[v][mi[v]]);
}
}
mi[u] = 1;
for (int i = 2; i <= n; i++) {
if (dp[u][i] < dp[u][mi[u]]) mi[u] = i;
}
}
void init(int u, int last, int A) {
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == last) continue;
dis[A][v] = dis[A][u] + 1;
init(v, u, A);
}
}
void output(int u, int last, int Mi) {
ANS[u] = Mi;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == last) continue;
if (dp[v][mi[v]] < dp[v][Mi] - k)
output(v, u, mi[v]);
else
output(v, u, Mi);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", d + i);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++) init(i, 0, i);
dfs(1, 0);
printf("%d\n", dp[1][mi[1]]);
output(1, 0, mi[1]);
for (int i = 1; i <= n; i++) printf("%d ", ANS[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) ans = ans * 10 + ch - '0', ch = getchar();
return ans;
}
const int N = 200;
int n, k;
int d[N];
int p[N];
int ans[N];
int f[N][N];
int dis[N][N];
vector<int> e[N];
void dfs(int u, int fa) {
for (int i = 1; i <= n; ++i) f[i][u] = d[dis[i][u]] + k;
for (int t = 0; t < e[u].size(); ++t) {
int v = e[u][t];
if (v == fa) continue;
dfs(v, u);
for (int i = 1; i <= n; ++i) f[i][u] += min(f[p[v]][v], f[i][v] - k);
}
p[u] = 1;
for (int i = 2; i <= n; ++i)
if (f[i][u] < f[p[u]][u]) p[u] = i;
}
void findans(int u, int fa, int lst) {
for (int t = 0; t < e[u].size(); ++t) {
int v = e[u][t];
if (v == fa) continue;
if (f[lst][v] - k < f[p[v]][v])
ans[v] = lst;
else
ans[v] = p[v];
findans(v, u, ans[v]);
}
}
int main() {
memset(dis, 0x3f, sizeof dis);
n = read();
k = read();
for (int i = 1; i < n; ++i) d[i] = read();
for (int i = 1; i < n; ++i) {
int u, v;
u = read();
v = read();
dis[u][v] = dis[v][u] = 1;
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int _ = 1; _ <= n; ++_) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][_] + dis[_][j]);
}
}
dfs(1, -1);
ans[1] = p[1];
findans(1, -1, ans[1]);
printf("%d\n", f[p[1]][1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, l, r, st[400500], ct, bel[400500], pw[400500], su[400500], lb[400500],
rb[400500], as[400500], v1[400500], sl[400500], sr[400500], tp[400500],
vl[400500];
char s[400500];
struct qu1 {
int l, r, id;
};
vector<qu1> qu[400500];
int calc(int l, int r) {
return (su[r] - 1ll * su[l - 1] * pw[r - l + 1] % 1000000007 + 1000000007) %
1000000007;
}
struct sth {
int fg, v1, v2, v3;
};
struct node {
int l, r;
sth tp;
} e[400500 * 4];
sth doit(sth s1, sth s2, int fg) {
sth s3;
if (s1.fg && s2.fg && fg) {
s3.v1 = s3.v2 = 1ll * s1.v1 * s2.v2 % 1000000007;
s3.v3 = 0;
s3.fg = 1;
return s3;
}
s3.fg = 0;
if (s1.fg && fg)
s3.v1 = 1ll * s1.v1 * s2.v1 % 1000000007;
else
s3.v1 = s1.v1;
if (s2.fg && fg)
s3.v2 = 1ll * s1.v2 * s2.v2 % 1000000007;
else
s3.v2 = s2.v2;
s3.v3 = (s1.v3 + s2.v3) % 1000000007;
if (!s1.fg && !s2.fg && fg)
s3.v3 = (s3.v3 + 1ll * s1.v2 * s2.v1) % 1000000007;
else {
if (!s1.fg && (!s2.fg || !fg)) s3.v3 = (s3.v3 + s1.v2) % 1000000007;
if (!s2.fg && (!s1.fg || !fg)) s3.v3 = (s3.v3 + s2.v1) % 1000000007;
}
return s3;
}
void pushup(int x) {
int mid = (e[x].l + e[x].r) >> 1;
e[x].tp = doit(e[x << 1].tp, e[x << 1 | 1].tp, s[tp[mid + 1]] == '*');
}
void build(int x, int l, int r) {
e[x].l = l;
e[x].r = r;
if (l == r) {
e[x].tp = (sth){1, vl[l], vl[l], 0};
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pushup(x);
}
sth query(int x, int l, int r) {
if (e[x].l == l && e[x].r == r) return e[x].tp;
int mid = (e[x].l + e[x].r) >> 1;
if (mid >= r)
return query(x << 1, l, r);
else if (mid < l)
return query(x << 1 | 1, l, r);
else
return doit(query(x << 1, l, mid), query(x << 1 | 1, mid + 1, r),
s[tp[mid + 1]] == '*');
}
void solve(int l, int r) {
int ct = 0, ls = r;
for (int i = r - 1; i >= l; i--)
if (s[i] == ')')
solve(lb[i], i), i = lb[i];
else if (s[i] == '+' && s[i] == '-')
ls = i;
else
sr[i] = ls;
ls = l;
for (int i = l + 1; i <= r; i++)
if (s[i] == '(')
i = rb[i];
else if (s[i] == '+' || s[i] == '*')
tp[++ct] = i, ls = i;
else
sl[i] = ls;
tp[0] = l;
tp[ct + 1] = r;
for (int i = 0; i <= ct; i++)
if (s[tp[i] + 1] == '(')
vl[i] = v1[tp[i] + 1];
else
vl[i] = calc(tp[i] + 1, tp[i + 1] - 1);
build(1, 0, ct);
for (int i = 0; i < qu[l].size(); i++) {
int l1 = qu[l][i].l, r1 = qu[l][i].r, id = qu[l][i].id;
int l2 = lower_bound(tp, tp + ct + 1, l1) - tp,
r2 = lower_bound(tp, tp + ct + 1, r1) - tp;
if (l2 == r2) {
as[id] = calc(l1, r1);
if (s[tp[l2 - 1] + 1] == '(') as[id] = vl[l2 - 1];
continue;
}
int lv = calc(l1, tp[l2] - 1), rv = calc(tp[r2 - 1] + 1, r1);
if (s[tp[l2 - 1] + 1] == '(') lv = vl[l2 - 1];
if (s[tp[r2 - 1] + 1] == '(') rv = vl[r2 - 1];
if (l2 + 1 == r2) {
int fg = s[tp[l2]] == '*';
if (fg)
as[id] = 1ll * lv * rv % 1000000007;
else
as[id] = (lv + rv) % 1000000007;
continue;
}
sth v0 = query(1, l2, r2 - 2);
v0 = doit((sth){1, lv, lv, 0}, v0, s[tp[l2]] == '*');
v0 = doit(v0, (sth){1, rv, rv, 0}, s[tp[r2 - 1]] == '*');
as[id] =
v0.fg ? v0.v1 : (1ll * v0.v1 + (!v0.fg) * v0.v2 + v0.v3) % 1000000007;
}
sth v0 = query(1, 0, ct);
v1[l] = (1ll * v0.v1 + (!v0.fg) * v0.v2 + v0.v3) % 1000000007;
}
int main() {
scanf("%s", s + 2);
s[1] = '(';
n = strlen(s + 1) + 1;
s[n] = ')';
pw[0] = 1;
for (int i = 1; i <= n; i++) {
pw[i] = 10ll * pw[i - 1] % 1000000007;
su[i] = 10ll * su[i - 1] % 1000000007;
bel[i] = st[ct];
if (s[i] == '(')
st[++ct] = i;
else if (s[i] == ')')
rb[st[ct]] = i, lb[i] = st[ct], ct--, bel[i] = st[ct];
else if (s[i] >= '0' && s[i] <= '9')
su[i] = (su[i] + s[i] - '0') % 1000000007;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
l++;
r++;
if (bel[l] != bel[r] || s[l] == '*' || s[l] == '+' || s[r] == '*' ||
s[r] == '+' || s[l] == ')' || s[r] == '(')
as[i] = -1;
else
qu[bel[l]].push_back((qu1){l, r, i});
}
solve(1, n);
for (int i = 1; i <= q; i++) printf("%d\n", as[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int rd() {
char c = getchar();
int x = 0;
while (!(c >= '0' && c <= '9')) c = getchar();
while (c >= '0' && c <= '9') {
x = x * 10 + (c - '0');
c = getchar();
}
return x;
}
const int N = 500005, mod = 1e9 + 7;
char s[N];
int n, m, q, tp, x = -1, las;
int tr[N << 2], ans[N], pc[N], pr[N], sf[N], ps[N], lp[N], rp[N], val[N], b[N],
lb[N], rb[N], sc[N], pw[N], ql[N], qr[N], st[N], rm[N][19];
struct sg {
int l, r, d;
bool operator<(const sg k) const {
if (r - l != k.r - k.l)
return r - l > k.r - k.l;
else
return d < k.d;
}
};
vector<sg> v;
struct nd {
int l, r, v;
vector<int> s, q;
} a[N];
void pd(int k) {
if (tr[k]) {
tr[k << 1] = tr[k];
tr[k << 1 | 1] = tr[k];
tr[k] = 0;
}
}
void upd(int k, int l, int r, int a, int b, int v) {
if (a > b) return;
if (l == a && r == b) {
tr[k] = v;
return;
}
pd(k);
int mid = l + r >> 1;
if (b <= mid)
upd(k << 1, l, mid, a, b, v);
else if (a > mid)
upd(k << 1 | 1, mid + 1, r, a, b, v);
else
upd(k << 1, l, mid, a, mid, v), upd(k << 1 | 1, mid + 1, r, mid + 1, b, v);
}
int ask(int k, int l, int r, int x) {
if (l == r) return tr[k];
pd(k);
int mid = l + r >> 1;
if (x <= mid)
return ask(k << 1, l, mid, x);
else
return ask(k << 1 | 1, mid + 1, r, x);
}
inline int getv(int l, int r) {
int ans = pc[r];
ans = (ans + mod - 1ll * pc[l - 1] * pw[r - l + 1] % mod) % mod;
return ans;
}
int rmq(int l, int r) {
int ans = 1;
for (int i = 18; i >= 0; i--) {
if (l + (1 << i) - 1 <= r) {
ans = 1ll * ans * rm[l][i] % mod;
l += (1 << i);
}
}
return ans;
}
void cal(int u) {
if (!a[u].s.size()) return;
sort(a[u].s.begin(), a[u].s.end(),
[&](int u, int v) { return a[u].l < a[v].l; });
int k = a[u].s.size(), kb;
for (int i = 0; i < k; i++) {
int v = a[u].s[i];
cal(v);
}
for (int i = 0; i < k; i++) {
int v = a[u].s[i];
lp[i] = a[v].l, rp[i] = a[v].r;
val[i] = a[v].v;
}
b[0] = 0;
for (int i = 1; i < k; i++) {
b[i] = b[i - 1];
int v = a[u].s[i];
if (s[a[v].l - 1] == '+') b[i]++;
}
kb = b[k - 1];
pr[0] = val[0];
for (int i = 1; i < k; i++) {
if (b[i] == b[i - 1])
pr[i] = 1ll * pr[i - 1] * val[i] % mod;
else
pr[i] = val[i];
}
sf[k - 1] = val[k - 1];
for (int i = k - 2; i >= 0; i--) {
if (b[i] == b[i + 1])
sf[i] = 1ll * sf[i + 1] * val[i] % mod;
else
sf[i] = val[i];
}
for (int i = 0; i < k; i++) rb[b[i]] = i;
for (int i = k - 1; i >= 0; i--) lb[b[i]] = i;
ps[0] = pr[rb[0]];
for (int i = 1; i <= kb; i++) ps[i] = (ps[i - 1] + pr[rb[i]]) % mod;
a[u].v = ps[kb];
for (int i = 0; i < k; i++) rm[i][0] = val[i];
for (int j = 1; (1 << j) <= k; j++)
for (int i = 0; i + (1 << j) <= k; i++)
rm[i][j] = 1ll * rm[i][j - 1] * rm[i + (1 << (j - 1))][j - 1] % mod;
lp[k] = rp[k] = a[u].r + 1;
for (auto d : a[u].q) {
int dl = ql[d], dr = qr[d], p, sum = 0, bl, br, ml = 1, mr = 1;
p = lower_bound(lp, lp + k + 1, dl) - lp;
if (lp[p] == dl)
bl = p;
else {
if ((lp[p] - 2 >= 0 ? sc[lp[p] - 2] : 0) - (dl ? sc[dl - 1] : 0)) {
ans[d] = -1;
continue;
}
if (s[lp[p] - 1] == '+') {
sum = (sum + getv(dl, lp[p] - 2)) % mod;
bl = p;
} else {
ml = getv(dl, lp[p] - 2);
bl = p;
}
}
p = upper_bound(rp, rp + k + 1, dr) - rp - 1;
if (p < 0) {
ans[d] = -1;
continue;
}
if (rp[p] == dr)
br = p;
else {
if (sc[dr] - sc[rp[p] + 1]) {
ans[d] = -1;
continue;
}
if (s[rp[p] + 1] == '+') {
sum = (sum + getv(rp[p] + 2, dr)) % mod;
br = p;
} else {
mr = getv(rp[p] + 2, dr);
br = p;
}
}
if (bl > br)
ans[d] = (s[rp[p] + 1] == '+' ? sum : 1ll * ml * mr % mod);
else if (b[bl] == b[br]) {
ans[d] = rmq(bl, br);
ans[d] = 1ll * ans[d] * ml % mod * mr % mod;
ans[d] = (ans[d] + sum) % mod;
} else {
ans[d] = sum;
ans[d] = (ans[d] + 1ll * sf[bl] * ml % mod) % mod;
ans[d] = (ans[d] + 1ll * pr[br] * mr % mod) % mod;
bl = b[bl], br = b[br];
bl++, br--;
if (bl <= br) {
int sy = (ps[br] - (bl ? ps[bl - 1] : 0) + mod) % mod;
ans[d] = (ans[d] + sy) % mod;
}
}
}
}
int main() {
scanf("%s", s + 1);
scanf("%d", &q);
m = strlen(s + 1);
n = 1;
a[1] = {1, m, 0};
v.push_back({1, m, 1});
for (int i = 1; i <= m; i++) {
if (x != -1 && (s[i] < '0' || s[i] > '9')) {
n++;
a[n] = {las, i - 1, x};
v.push_back({las, i - 1, n});
x = -1;
}
if (s[i] >= '0' && s[i] <= '9') {
if (x == -1) {
x = s[i] - '0';
las = i;
} else
x = (10ll * x + s[i] - '0') % mod;
}
if (s[i] == '(') {
tp++;
st[tp] = i;
}
if (s[i] == ')') {
n++;
a[n] = {st[tp], i, 0};
v.push_back({st[tp], i, n});
tp--;
}
}
if (x != -1) {
n++;
a[n] = {las, m, x};
v.push_back({las, m, n});
x = -1;
}
pw[0] = 1;
for (int i = 1; i <= m; i++) pw[i] = 10ll * pw[i - 1] % mod;
for (int i = 1; i <= m; i++)
if (s[i] >= '0' && s[i] <= '9')
pc[i] = (10ll * pc[i - 1] + s[i] - '0') % mod;
for (int i = 1; i <= m; i++)
sc[i] =
sc[i - 1] + (s[i] == '(' || s[i] == ')' || s[i] == '+' || s[i] == '*');
for (int i = 1; i <= q; i++) {
ql[i] = rd(), qr[i] = rd();
if (s[ql[i]] == '+' || s[ql[i]] == '*' || s[qr[i]] == '+' ||
s[qr[i]] == '*' || s[ql[i]] == ')' || s[qr[i]] == '(') {
ans[i] = -1;
continue;
}
if (sc[qr[i]] - sc[ql[i] - 1] == 0) {
ans[i] = getv(ql[i], qr[i]);
continue;
}
v.push_back({ql[i], qr[i], -i});
}
sort(v.begin(), v.end());
upd(1, 1, m, 1, m, 1);
for (auto x : v) {
if (x.d > 0) {
if (x.d != 1) {
int f = ask(1, 1, m, x.l);
a[f].s.push_back(x.d);
}
if (!a[x.d].v) upd(1, 1, m, x.l + 1, x.r - 1, x.d);
} else {
x.d = -x.d;
int fl = ask(1, 1, m, x.l), fr = ask(1, 1, m, x.r);
if (fl != fr)
ans[x.d] = -1;
else
a[fl].q.push_back(x.d);
}
}
cal(1);
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::copy;
using std::cout;
using std::deque;
using std::endl;
using std::fill;
using std::fixed;
using std::function;
using std::greater;
using std::ifstream;
using std::iota;
using std::istream;
using std::iter_swap;
using std::lower_bound;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::multiset;
using std::next_permutation;
using std::nth_element;
using std::ofstream;
using std::ostream;
using std::pair;
using std::priority_queue;
using std::queue;
using std::reverse;
using std::rotate;
using std::set;
using std::shuffle;
using std::sort;
using std::string;
using std::swap;
using std::tie;
using std::tuple;
using std::unique;
using std::unordered_map;
using std::unordered_set;
using std::upper_bound;
using std::vector;
int const INF = 100 + (int)1e9;
long long const INFL = 100 + (long long)1e18;
long double const PI = 3.141592653589793238462643L;
const int MOD = 1000000007;
std::mt19937 mt19937(960172);
long long rnd(long long x, long long y) {
static auto gen =
std::bind(std::uniform_int_distribution<long long>(), mt19937);
return gen() % (y - x + 1) + x;
}
bool is_prime(long long x) {
if (x <= 1) return 0;
for (long long y = 2; y * y <= x; ++y)
if (x % y == 0) return 0;
return 1;
}
long long sqr(int a) { return (long long)a * a; }
long double sqr(long double a) { return a * a; }
long long sqr(long long a) { return a * a; }
long long gcd(long long a, long long b) {
while (b > 0) {
long long t = a % b;
a = b;
b = t;
}
return a;
}
const int N = 1 << 19;
void add(int& a, int b) {
if ((a += b) >= MOD) a -= MOD;
}
int sum(int a, int b) {
if ((a += b) >= MOD) a -= MOD;
return a;
}
int prod(int a, int b) { return (long long)a * b % MOD; }
class SegTreeMin {
int t[N * 2 - 1];
public:
void init(int n, int* a) {
for (int i = 0; i < n; ++i) t[N - 1 + i] = a[i];
for (int i = N - 2; i >= 0; --i) t[i] = min(t[i * 2 + 1], t[i * 2 + 2]);
}
int getMin(int l, int r, int c = 0, int cl = 0, int cr = N - 1) {
if (l > cr || cl > r) return INF;
if (l <= cl && cr <= r) return t[c];
return min(getMin(l, r, c * 2 + 1, cl, (cl + cr) / 2),
getMin(l, r, c * 2 + 2, (cl + cr) / 2 + 1, cr));
}
} balanceST;
struct Adr {
int l, r, v;
};
struct Mlr {
int l, r, v;
};
struct Level {
vector<Adr> adrs;
vector<int> adrsum;
vector<Mlr> mlrs;
vector<int> mlrprd, mlr0;
} lv[N];
int lvc = 0;
int n;
string s;
int balance[N];
int brpair[N];
int pval[N];
int go(int cl, int cr, int d) {
lvc = max(lvc, d + 1);
int cans = 0;
while (cl < cr) {
Adr cv = {cl, 0, 1};
while (true) {
if (cl >= cr || s[cl] == '+') break;
if (s[cl] == '*') ++cl;
if (s[cl] == '(') {
pval[cl] = go(cl + 1, brpair[cl], d + 1);
cv.v = prod(cv.v, pval[cl]);
lv[d].mlrs.push_back({cl, brpair[cl] + 1, pval[cl]});
cl = brpair[cl] + 1;
} else {
int x = 0;
int ccl = cl;
while (ccl < cr && '0' <= s[ccl] && s[ccl] <= '9')
x = ((long long)x * 10 + (s[ccl++] - '0')) % MOD;
pval[cl] = x;
lv[d].mlrs.push_back({cl, ccl, x});
cv.v = prod(cv.v, pval[cl]);
cl = ccl;
}
}
cv.r = cl;
lv[d].adrs.push_back(cv);
add(cans, cv.v);
++cl;
}
return cans;
}
vector<int> allND;
int p10[N];
int s10[N];
int inv(long long a) {
long long r = 1, b = MOD - 2;
while (b) {
if (b & 1) (r *= a) %= MOD;
b >>= 1;
(a *= a) %= MOD;
}
return r;
}
int getProd(int d, int s1, int s2) {
if (lv[d].mlr0[s2] != lv[d].mlr0[s1]) return 0;
return prod(lv[d].mlrprd[s2], inv(lv[d].mlrprd[s1]));
}
int eval2(int ql, int qr) {
if (s[ql] == '(') return pval[ql];
return sum(s10[qr], MOD - prod(s10[ql], p10[qr - ql]));
}
int eval1(int ql, int qr, int d) {
int s1 = lower_bound(lv[d].mlrs.begin(), lv[d].mlrs.end(), Mlr({ql, 0, 0}),
[](const Mlr& a, const Mlr& b) { return a.l < b.l; }) -
lv[d].mlrs.begin();
int s2 = upper_bound(lv[d].mlrs.begin(), lv[d].mlrs.end(), Mlr({0, qr, 0}),
[](const Mlr& a, const Mlr& b) { return a.r < b.r; }) -
lv[d].mlrs.begin() - 1;
int ans = 1;
if (s1 - 1 == s2 + 1) {
return eval2(ql, qr);
} else {
if (s2 >= s1) {
ans = getProd(d, s1, s2 + 1);
}
if (s1 > 0 && ql < lv[d].mlrs[s1 - 1].r) {
ans = prod(ans, eval2(ql, lv[d].mlrs[s1 - 1].r));
}
if (s2 + 1 < (int)lv[d].mlrs.size() && qr > lv[d].mlrs[s2 + 1].l) {
ans = prod(ans, eval2(lv[d].mlrs[s2 + 1].l, qr));
}
}
return ans;
}
void solve() {
p10[0] = 1;
for (int i = 1; i < N; ++i) p10[i] = prod(p10[i - 1], 10);
cin >> s;
n = (int)s.size();
vector<int> st;
for (int i = 0; i < n; ++i) {
if (s[i] == '(')
st.push_back(i);
else if (s[i] == ')') {
brpair[i] = st.back();
brpair[st.back()] = i;
st.pop_back();
}
balance[i + 1] = (int)st.size();
}
balanceST.init(n + 1, balance);
s10[0] = 0;
for (int i = 0; i < n; ++i) {
int cc = ('0' <= s[i] && s[i] <= '9' ? s[i] - '0' : 0);
s10[i + 1] = (10LL * s10[i] + cc) % MOD;
}
go(0, n, 0);
for (int i = 0; i < lvc; ++i) {
lv[i].adrsum.push_back(0);
for (auto a : lv[i].adrs)
lv[i].adrsum.push_back((lv[i].adrsum.back() + a.v) % MOD);
lv[i].mlrprd.push_back(1);
lv[i].mlr0.push_back(0);
for (auto a : lv[i].mlrs) {
if (a.v != 0) lv[i].mlrprd.push_back(prod(lv[i].mlrprd.back(), a.v));
lv[i].mlr0.push_back(lv[i].mlr0.back() + (a.v == 0 ? 1 : 0));
}
}
allND.push_back(-1);
for (int i = 0; i < n; ++i)
if (s[i] > '9' || s[i] < '0') allND.push_back(i);
allND.push_back(n);
int qq;
cin >> qq;
while (qq--) {
int ql, qr;
scanf("%d%d", &ql, &qr);
--ql;
if (balance[ql] != balance[qr] || balanceST.getMin(ql, qr) != balance[ql] ||
s[ql] == '+' || s[ql] == '*' || s[qr - 1] == '+' || s[qr - 1] == '*') {
cout << "-1\n";
continue;
}
int d = balance[ql];
int s1 = lower_bound(lv[d].adrs.begin(), lv[d].adrs.end(), Adr({ql, 0, 0}),
[](const Adr& a, const Adr& b) { return a.l < b.l; }) -
lv[d].adrs.begin();
int s2 = upper_bound(lv[d].adrs.begin(), lv[d].adrs.end(), Adr({0, qr, 0}),
[](const Adr& a, const Adr& b) { return a.r < b.r; }) -
lv[d].adrs.begin() - 1;
int ans = 0;
if (s1 - 1 == s2 + 1)
ans = eval1(ql, qr, d);
else {
if (s2 >= s1) ans = sum(lv[d].adrsum[s2 + 1], MOD - lv[d].adrsum[s1]);
if (s1 > 0 && ql < lv[d].adrs[s1 - 1].r)
add(ans, eval1(ql, lv[d].adrs[s1 - 1].r, d));
if (s2 + 1 < (int)lv[d].adrs.size() && qr > lv[d].adrs[s2 + 1].l)
add(ans, eval1(lv[d].adrs[s2 + 1].l, qr, d));
}
cout << ans << "\n";
}
}
int main() {
cout.precision(15);
cout << fixed;
int tcn = 1;
for (int tn = 1; tn <= tcn; ++tn) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 400000;
const int MOD = 1000000007;
enum { ADD, MUL, NUM, BRC };
struct Elm {
int t, v, l, r;
Elm *c0, *c1;
Elm() {}
void set(int _t, int _v, int _l, int _r, Elm *_c0, Elm *_c1) {
t = _t, v = _v, l = _l, r = _r;
c0 = _c0, c1 = _c1;
}
void set(int _t, int _v, int _l, int _r) {
set(_t, _v, _l, _r, (Elm *)NULL, (Elm *)NULL);
}
void print() {
switch (t) {
case BRC:
for (int i = 0; i < c0->l - l; i++) putchar('(');
c0->print();
for (int i = 0; i < c0->l - l; i++) putchar(')');
break;
case NUM:
printf("[%d]", v);
break;
default:
c0->print();
putchar(t == MUL ? '*' : '+');
c1->print();
break;
}
}
};
typedef vector<Elm *> vept;
Elm buf[MAX_N * 2], *bpt = buf;
char s[MAX_N + 4];
int dss[MAX_N + 1], ts[MAX_N + 1], invts[MAX_N + 1];
int powmod(int a, int n) {
int pm = 1;
while (n > 0) {
if (n & 1) pm = (long long)pm * a % MOD;
a = (long long)a * a % MOD;
n >>= 1;
}
return pm;
}
inline int num(int i, int j) {
return (long long)(dss[i] + MOD - dss[j]) % MOD * invts[j] % MOD;
}
Elm *expr(int &pt);
Elm *coef(int &pt) {
if (s[pt] == '(') {
pt++;
Elm *ept0 = expr(pt);
pt++;
if (ept0->t == BRC) {
ept0->l--, ept0->r++;
return ept0;
}
Elm *ept = bpt++;
ept->set(BRC, ept0->v, ept0->l - 1, ept0->r + 1, ept0, (Elm *)NULL);
return ept;
}
int pt0 = pt;
while (s[pt] >= '0' && s[pt] <= '9') pt++;
Elm *ept = bpt++;
ept->set(NUM, num(pt0, pt), pt0, pt);
return ept;
}
Elm *makemul(vept &cs, int i0, int i1) {
if (i0 >= i1) return NULL;
if (i0 + 1 == i1) return cs[i0];
int im = (i0 + i1) / 2;
Elm *c0 = makemul(cs, i0, im);
Elm *c1 = makemul(cs, im, i1);
Elm *ept = bpt++;
ept->set(MUL, (long long)c0->v * c1->v % MOD, c0->l, c1->r, c0, c1);
return ept;
}
Elm *term(int &pt) {
vept cs;
cs.push_back(coef(pt));
while (s[pt] == '*') {
pt++;
cs.push_back(coef(pt));
}
return makemul(cs, 0, cs.size());
}
Elm *makeadd(vept &cs, int i0, int i1) {
if (i0 >= i1) return NULL;
if (i0 + 1 == i1) return cs[i0];
int im = (i0 + i1) / 2;
Elm *c0 = makeadd(cs, i0, im);
Elm *c1 = makeadd(cs, im, i1);
Elm *ept = bpt++;
ept->set(ADD, (c0->v + c1->v) % MOD, c0->l, c1->r, c0, c1);
return ept;
}
Elm *expr(int &pt) {
vept cs;
cs.push_back(term(pt));
while (s[pt] == '+') {
pt++;
cs.push_back(term(pt));
}
return makeadd(cs, 0, cs.size());
}
int calcv(Elm *ept, int l, int r) {
if (ept->l >= r || ept->r <= l) return -2;
if (l <= ept->l && ept->r <= r) return ept->v;
if (ept->t == BRC) {
int b = ept->r - ept->c0->r;
int lb = min(max(ept->c0->l - l, 0), b);
int rb = min(max(r - ept->c0->r, 0), b);
if (lb != rb) return -1;
return calcv(ept->c0, l, r);
}
if (ept->t == MUL || ept->t == ADD) {
if (l == ept->c0->r || r == ept->c1->l) return -1;
int v0 = calcv(ept->c0, l, r);
if (v0 == -1) return -1;
int v1 = calcv(ept->c1, l, r);
if (v1 == -1) return -1;
if (v0 == -2) return v1;
if (v1 == -2) return v0;
return (ept->t == MUL) ? (long long)v0 * v1 % MOD : (v0 + v1) % MOD;
}
return num(max(l, ept->l), min(ept->r, r));
}
int main() {
scanf("%s", s);
int n = strlen(s);
dss[n] = 0, ts[n] = invts[n] = 1;
int inv10 = powmod(10, MOD - 2);
for (int i = n - 1; i >= 0; i--) {
int di = (s[i] >= '0' && s[i] <= '9') ? s[i] - '0' : 0;
dss[i] = (dss[i + 1] + (long long)di * ts[i + 1] % MOD) % MOD;
ts[i] = (long long)ts[i + 1] * 10 % MOD;
invts[i] = (long long)invts[i + 1] * inv10 % MOD;
}
int pt = 0;
Elm *root = expr(pt);
int m;
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
l--;
int v = calcv(root, l, r);
printf("%d\n", v);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
void ADD(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void MUL(int &x, int y) { x = 1ll * x * y % mod; }
char s[500010];
int hei[500010];
vector<int> son[500010];
vector<int> pos[2][500010];
vector<int> sum[500010];
vector<int> inv[500010];
vector<int> pre[500010];
int ql[500010], qr[500010];
int val[500010], Type[500010], B[500010], L[500010], R[500010];
int ans[500010];
long long pw[500010];
vector<pair<int, int> > all, qry;
set<pair<int, int> > S;
int TOT;
long long power(long long a, int b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1, a = a * a % mod;
}
return ans;
}
void Calc(int now) {
if (Type[now] == 0) {
int S = 0;
sum[now].push_back(S);
for (auto x : son[now]) ADD(S, val[x]), sum[now].push_back(S);
val[now] = S;
} else if (Type[now] == 1) {
int r = 1, f = 1, zero = 0;
sum[now].push_back(f), inv[now].push_back(power(f, mod - 2)),
pre[now].push_back(zero);
for (auto x : son[now]) {
MUL(r, val[x]);
if (val[x])
MUL(f, val[x]);
else
zero++;
sum[now].push_back(f);
inv[now].push_back(power(f, mod - 2));
pre[now].push_back(zero);
}
val[now] = r;
} else if (Type[now] == 2) {
int S = 0;
sum[now].push_back(S);
for (int i = L[now]; i <= R[now]; i++) {
S = (S * 10ll + (int)(s[i] - '0')) % mod;
sum[now].push_back(S);
}
val[now] = S;
}
}
int Solve(int l, int r) {
int H = hei[l - 1];
auto it = (lower_bound((pos[0][H]).begin(), (pos[0][H]).end(), (l)));
if (it != pos[0][H].end() && *it <= r) {
int lst = l, now = ++TOT;
Type[TOT] = 0;
L[now] = l, R[now] = r;
while (it != pos[0][H].end() && *it <= r) {
son[now].push_back(Solve(lst, *it - 1));
lst = *it + 1,
it = (lower_bound((pos[0][H]).begin(), (pos[0][H]).end(), (*it + 1)));
}
son[now].push_back(Solve(lst, r));
Calc(now);
return now;
}
it = (lower_bound((pos[1][H]).begin(), (pos[1][H]).end(), (l)));
if (it != pos[1][H].end() && *it <= r) {
int lst = l, now = ++TOT;
Type[TOT] = 1;
L[now] = l, R[now] = r;
while (it != pos[1][H].end() && *it <= r) {
son[now].push_back(Solve(lst, *it - 1));
lst = *it + 1,
it = (lower_bound((pos[1][H]).begin(), (pos[1][H]).end(), (*it + 1)));
}
son[now].push_back(Solve(lst, r));
Calc(now);
return now;
}
if (s[l] == '(') {
assert(s[r] == ')');
int now = Solve(l + 1, r - 1);
B[now]++, L[now]--, R[now]++;
return now;
}
int now = ++TOT;
Type[TOT] = 2;
L[now] = l, R[now] = r;
Calc(now);
return now;
}
int GetSon(int now, int x) {
int l = 0, r = son[now].size() - 1;
while (l < r) {
int mid = l + r >> 1;
if (R[son[now][mid]] < x)
l = mid + 1;
else
r = mid;
}
if (x < L[son[now][l]] || x > R[son[now][l]]) return -1;
return l;
}
int Merge(int x, int y, int Type) {
if (x == -1 || y == -1) return -1;
if (Type == 0) return (x + y) % mod;
return 1ll * x * y % mod;
}
int GetSum(int now, int l, int r) {
if (Type[now] == 0) return (sum[now][r] - sum[now][l] + mod) % mod;
if (pre[now][r] != pre[now][l]) return 0;
return 1ll * sum[now][r] * inv[now][l] % mod;
}
int Query(int now, int ql, int qr) {
int l = L[now], r = R[now];
if (ql < l) ql = l;
if (qr > r) qr = r;
int lh = max(0, B[now] - (ql - l)), rh = max(0, B[now] - (r - qr));
if (lh != rh) return -1;
ql += lh, qr -= rh;
if (ql == l + B[now] && qr == r - B[now]) return val[now];
if (Type[now] == 2) {
int Base = l + B[now];
return (sum[now][qr - Base + 1] -
1ll * sum[now][ql - Base] * pw[qr - ql + 1] % mod + mod) %
mod;
}
int lp = GetSon(now, ql), rp = GetSon(now, qr);
if (lp == -1 || rp == -1) return -1;
if (lp == rp) return Query(son[now][lp], ql, qr);
int ans = Merge(Query(son[now][lp], ql, qr), Query(son[now][rp], ql, qr),
Type[now]);
lp++;
ans = Merge(ans, GetSum(now, lp, rp), Type[now]);
return ans;
}
int main() {
pw[0] = 1;
for (int i = 1; i <= 500005; i++) pw[i] = pw[i - 1] * 10 % mod;
scanf("%s", s + 1);
int n = strlen(s + 1);
int q;
scanf("%d", &q);
for (int i = 1; i <= n; i++)
hei[i] = hei[i - 1] + (s[i] == '(' ? 1 : s[i] == ')' ? -1 : 0);
for (int i = 1; i <= n; i++) {
if (s[i] == '+')
pos[0][hei[i]].push_back(i);
else if (s[i] == '*')
pos[1][hei[i]].push_back(i);
}
Solve(1, n);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
ql[i] = l, qr[i] = r;
qry.push_back(make_pair(l, i));
}
for (int i = 1; i <= TOT; i++) all.push_back(make_pair(L[i], i));
sort(all.begin(), all.end()), sort(qry.begin(), qry.end());
int pos = 0;
for (auto it : qry) {
int l = it.first, id = it.second, r = qr[id];
while (pos < all.size() && all[pos].first <= l)
S.insert(make_pair(R[all[pos].second], -all[pos].second)), pos++;
auto jt = S.lower_bound(make_pair(r, -0x3f3f3f3f));
ans[id] = Query(-jt->second, l, r);
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
std::ostream& operator<<(std::ostream& os, const pair<T1, T2>& p) {
os << "[" << p.first << ", " << p.second << "]";
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
os << "[";
bool first = true;
for (typename std::vector<T>::const_iterator it = v.begin(); it != v.end();
++it) {
if (!first) os << ", ";
first = false;
os << *it;
}
os << "]";
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::vector<vector<T>>& v) {
os << "[" << endl;
bool first = true;
for (typename std::vector<vector<T>>::const_iterator it = v.begin();
it != v.end(); ++it) {
os << *it << endl;
}
os << "]" << endl;
return os;
}
const int N = (int)4e5 + 100;
const int LOGN = 20;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const int PLUS = 0;
const int MUL = 1;
const int NUMBER = 2;
int mod_add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
int mod_sub(int a, int b) {
a -= b;
if (a < 0) a += mod;
return a;
}
int mod_mul(int a, int b) { return (long long int)a * b % mod; }
struct SparseTable {
int min_val[N][LOGN];
int max_pow2[N];
SparseTable() {}
void init(int n, int arr[]) {
fill(max_pow2, max_pow2 + N, 0);
for (int i = 2; i < N; i *= 2) max_pow2[i] = 1;
for (int i = 1; i < N; i++) max_pow2[i] += max_pow2[i - 1];
for (int i = 0; i < N; i++) {
if (i < n)
min_val[i][0] = arr[i];
else
min_val[i][0] = INF;
}
for (int st = 1; st < LOGN; st++) {
for (int i = 0; i + (1 << (st - 1)) < N; i++) {
min_val[i][st] =
min(min_val[i][st - 1], min_val[i + (1 << (st - 1))][st - 1]);
}
}
}
int get_min(int a, int b) {
assert(0 <= a);
assert(a <= b);
assert(b < N);
int len = b - a + 1;
int p = max_pow2[len];
return min(min_val[a][p], min_val[b - (1 << p) + 1][p]);
}
};
bool not_inter(int l, int r, int a, int b) { return l > b || r < a; }
bool is_in(int l, int r, int a, int b) { return a <= l && r <= b; }
struct SumTree {
int pow2;
vector<int> sum;
SumTree() {}
void init(int n) {
pow2 = 1;
while (pow2 < n) pow2 *= 2;
sum.resize(pow2 * 2);
}
void set(int pos, int val) {
pos += pow2;
sum[pos] = val;
pos /= 2;
while (pos >= 1) {
sum[pos] = mod_add(sum[pos * 2], sum[pos * 2 + 1]);
pos /= 2;
}
}
int get_sum(int a, int b) {
assert(0 <= a);
assert(a <= b);
assert(b < N);
return get_sum(1, 0, pow2 - 1, a, b);
}
int get_sum(int v, int l, int r, int a, int b) {
if (not_inter(l, r, a, b)) return 0;
if (is_in(l, r, a, b)) return sum[v];
int m = (l + r) / 2;
return mod_add(get_sum(v * 2, l, m, a, b),
get_sum(v * 2 + 1, m + 1, r, a, b));
}
};
struct MulTree {
int pow2;
vector<int> mul;
MulTree() {}
void init(int n) {
pow2 = 1;
while (pow2 < n) pow2 *= 2;
mul.resize(pow2 * 2, 1);
}
void set(int pos, int val) {
pos += pow2;
mul[pos] = val;
pos /= 2;
while (pos >= 1) {
mul[pos] = mod_mul(mul[pos * 2], mul[pos * 2 + 1]);
pos /= 2;
}
}
int get_mul(int a, int b) {
assert(0 <= a);
assert(a <= b);
assert(b < N);
return get_mul(1, 0, pow2 - 1, a, b);
}
int get_mul(int v, int l, int r, int a, int b) {
if (not_inter(l, r, a, b)) return 1;
if (is_in(l, r, a, b)) return mul[v];
int m = (l + r) / 2;
return mod_mul(get_mul(v * 2, l, m, a, b),
get_mul(v * 2 + 1, m + 1, r, a, b));
}
};
struct BracketsChecker {
int n;
int bal[N];
SparseTable sparse_table;
BracketsChecker() {}
void init(string exp) {
n = (int)exp.length();
int cur_bal = 0;
for (int i = 0; i < n; i++) {
if (exp[i] == '(') cur_bal++;
if (exp[i] == ')') cur_bal--;
bal[i] = cur_bal;
}
sparse_table.init(n, bal);
}
bool is_correct(int a, int b) {
assert(0 <= a);
assert(a <= b);
assert(b < N);
int a_bal = 0;
if (a != 0) a_bal = bal[a - 1];
int min_bal = sparse_table.get_min(a, b);
int b_bal = bal[b];
return a_bal == min_bal && min_bal == b_bal;
}
};
struct DigitItem {
int value;
int pow10;
DigitItem() : value(), pow10() {}
DigitItem(int _value, int _pow10) : value(_value), pow10(_pow10) {}
DigitItem merge(const DigitItem& other) const {
int new_value = mod_add(other.value, mod_mul(value, other.pow10));
int new_pow10 = mod_mul(pow10, other.pow10);
return DigitItem(new_value, new_pow10);
}
};
struct DigitTree {
int pow2;
vector<DigitItem> tree;
DigitTree() {}
void init(string expr) {
int n = (int)expr.size();
pow2 = 1;
while (pow2 < n) pow2 *= 2;
tree.resize(pow2 * 2);
for (int i = 0; i < pow2; i++) {
if (i < n && isdigit(expr[i]))
tree[pow2 + i] = DigitItem(expr[i] - '0', 10);
else
tree[pow2 + i] = DigitItem(0, 1);
}
for (int i = pow2 - 1; i >= 1; i--)
tree[i] = tree[i * 2].merge(tree[i * 2 + 1]);
}
DigitItem get(int a, int b) { return get(1, 0, pow2 - 1, a, b); }
DigitItem get(int v, int l, int r, int a, int b) {
if (not_inter(l, r, a, b)) return DigitItem(0, 1);
if (is_in(l, r, a, b)) return tree[v];
int m = (l + r) / 2;
return get(v * 2, l, m, a, b).merge(get(v * 2 + 1, m + 1, r, a, b));
}
};
DigitTree digit_tree;
struct Token {
int type;
int value;
int real_a, real_b;
Token() : type(), value(), real_a(), real_b() {}
Token(int _type, int _value, int _real_a, int _real_b)
: type(_type), value(_value), real_a(_real_a), real_b(_real_b) {}
int solve(int a, int b) {
if (a == real_a && b == real_b) return value;
DigitItem digit_item = digit_tree.get(a, b);
return digit_item.value;
}
};
int get_pos(const vector<int>& real_a_list, int a) {
return upper_bound(real_a_list.begin(), real_a_list.end(), a) -
real_a_list.begin() - 1;
}
struct PlusItem {
int value;
int real_a, real_b;
MulTree mul_tree;
vector<Token> tokens;
vector<int> real_a_list;
PlusItem() {}
PlusItem(vector<Token> _tokens) {
assert(!_tokens.empty());
assert(_tokens[0].type == NUMBER);
assert(_tokens.back().type == NUMBER);
real_a = _tokens[0].real_a;
real_b = _tokens.back().real_b;
tokens = vector<Token>();
real_a_list = vector<int>();
value = 1;
for (Token token : _tokens) {
if (token.type == NUMBER) {
real_a_list.push_back(token.real_a);
tokens.push_back(token);
value = mod_mul(value, token.value);
} else
assert(token.type == MUL);
}
mul_tree.init((int)tokens.size());
for (int i = 0; i < (int)tokens.size(); i++)
mul_tree.set(i, tokens[i].value);
}
int solve(int a, int b) {
int block_a = get_pos(real_a_list, a);
int block_b = get_pos(real_a_list, b);
if (block_a == block_b) return tokens[block_a].solve(a, b);
int mid = 1;
if (block_a + 1 <= block_b - 1)
mid = mul_tree.get_mul(block_a + 1, block_b - 1);
int val_a = tokens[block_a].solve(a, tokens[block_a].real_b);
int val_b = tokens[block_b].solve(tokens[block_b].real_a, b);
int ans = mod_mul(mid, mod_mul(val_a, val_b));
return ans;
}
};
struct BracketItem {
int value;
int real_a, real_b;
SumTree sum_tree;
vector<PlusItem> plus_items;
vector<int> real_a_list;
BracketItem() {}
BracketItem(vector<Token> _tokens) {
assert(!_tokens.empty());
assert(_tokens[0].type == NUMBER);
assert(_tokens.back().type == NUMBER);
real_a = _tokens[0].real_a;
real_b = _tokens.back().real_b;
value = 0;
plus_items = vector<PlusItem>();
real_a_list = vector<int>();
_tokens.push_back(Token(PLUS, 0, 0, 0));
vector<Token> cur_tokens;
for (Token token : _tokens) {
if (token.type == PLUS) {
PlusItem plus_item = PlusItem(cur_tokens);
cur_tokens.clear();
plus_items.push_back(plus_item);
value = mod_add(value, plus_item.value);
real_a_list.push_back(plus_item.real_a);
} else {
cur_tokens.push_back(token);
}
}
sum_tree.init(plus_items.size());
for (int i = 0; i < (int)plus_items.size(); i++)
sum_tree.set(i, plus_items[i].value);
}
int solve(int a, int b) {
int block_a = get_pos(real_a_list, a);
int block_b = get_pos(real_a_list, b);
if (block_a == block_b) return plus_items[block_a].solve(a, b);
int mid = 0;
if (block_a + 1 <= block_b - 1)
mid = sum_tree.get_sum(block_a + 1, block_b - 1);
int val_a = plus_items[block_a].solve(a, plus_items[block_a].real_b);
int val_b = plus_items[block_b].solve(plus_items[block_b].real_a, b);
int ans = mod_add(mid, mod_add(val_a, val_b));
return ans;
}
};
string read_string() {
char buf[N];
scanf("%s", buf);
return string(buf);
}
string expr;
BracketsChecker brackets_checker;
int r_bracket[N];
int cover_bracket[N];
BracketItem bracket_items[N];
void match_brackets() {
vector<int> open_brackets;
for (int i = 0; i < (int)expr.length(); i++) {
char c = expr[i];
if (c == '(') open_brackets.push_back(i);
if (c == ')') {
assert(!open_brackets.empty());
r_bracket[open_brackets.back()] = i;
open_brackets.pop_back();
}
}
assert(open_brackets.empty());
}
Token parse(int l, int r) {
assert(expr[l] == '(');
assert(expr[r] == ')');
vector<Token> token_list;
int ptr = l + 1;
while (ptr < r) {
if (expr[ptr] == '+') {
cover_bracket[ptr] = l;
token_list.push_back(Token(PLUS, 0, ptr, ptr));
ptr++;
} else if (expr[ptr] == '*') {
cover_bracket[ptr] = l;
token_list.push_back(Token(MUL, 0, ptr, ptr));
ptr++;
} else if (expr[ptr] == '(') {
int to_l = ptr;
int to_r = r_bracket[ptr];
Token token = parse(to_l, to_r);
token_list.push_back(token);
ptr = to_r + 1;
cover_bracket[to_l] = l;
cover_bracket[to_r] = l;
} else {
assert(isdigit(expr[ptr]));
int value = 0;
int old_ptr = ptr;
while (ptr < r && isdigit(expr[ptr])) {
cover_bracket[ptr] = l;
value = mod_mul(value, 10);
value = mod_add(value, expr[ptr] - '0');
ptr++;
}
token_list.push_back(Token(NUMBER, value, old_ptr, ptr - 1));
}
}
BracketItem bracket_item = BracketItem(token_list);
bracket_item.real_a = l;
bracket_item.real_b = r;
bracket_items[l] = bracket_item;
return Token(NUMBER, bracket_item.value, bracket_item.real_a,
bracket_item.real_b);
}
int solve(int a, int b) {
if (!brackets_checker.is_correct(a, b)) return -1;
if (expr[a] == '+' || expr[a] == '*') return -1;
if (expr[b] == '+' || expr[b] == '*') return -1;
int l_br = cover_bracket[a];
int r_br = cover_bracket[b];
assert(l_br == r_br);
int ans = bracket_items[l_br].solve(a, b);
return ans;
}
void solve() {
expr = read_string();
expr = "(" + expr + ")";
brackets_checker.init(expr);
match_brackets();
digit_tree.init(expr);
parse(0, (int)expr.length() - 1);
int q;
scanf("%d", &q);
for (int it = 0; it < q; it++) {
int a, b;
scanf("%d%d", &a, &b);
int ans = solve(a, b);
printf("%d\n", ans);
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1.01e9;
const double eps = 1e-9;
const int N = 4e5 + 10;
const int mod = 1e9 + 7;
int rev(int a, int m) {
if (a == 1) return 1;
return (1 - rev(m % a, a) * (long long)m) / a + m;
}
struct number {
int val, len;
int st, en;
vector<int> pref, suf;
};
char s[N];
int pos = 0;
inline number parse_number() {
int en = pos;
while ('0' <= s[en] && s[en] <= '9') en++;
assert(pos < en);
number res;
res.len = en - pos;
res.pref = vector<int>(res.len + 1);
res.suf = vector<int>(res.len + 1);
for (int i = 0; (i) < (res.len); ++i)
res.pref[i + 1] = (res.pref[i] * 10LL + s[pos + i] - '0') % mod;
int pn = 1;
for (int i = res.len - 1; i >= 0; --i) {
res.suf[i] = (res.suf[i + 1] + pn * (long long)(s[pos + i] - '0')) % mod;
pn = pn * 10LL % mod;
}
res.st = pos, res.en = en;
res.val = res.pref[res.len];
pos = en;
return res;
}
struct brackets {
int val;
int st, en;
brackets() {}
brackets(int vval, int sst, int een) : val(vval), st(sst), en(een) {}
};
inline int getVal(pair<brackets, number> &a) {
if (a.first.val != -1) return a.first.val;
return a.second.val;
}
struct mul {
vector<pair<brackets, number>> v;
vector<int> pref, suf;
vector<int> mid, cnt;
int val;
int st, en;
void calc() {
int len = ((int)(v).size());
pref = vector<int>(len + 1);
suf = vector<int>(len + 1);
pref[0] = 1;
for (int i = 0; i < len; ++i)
pref[i + 1] = pref[i] * (long long)getVal(v[i]) % mod;
suf[len] = 1;
for (int i = len - 1; i >= 0; --i)
suf[i] = suf[i + 1] * (long long)getVal(v[i]) % mod;
val = pref[len];
mid = vector<int>(len + 1);
cnt = vector<int>(len + 1);
mid[0] = 1;
for (int i = 0; i < len; ++i) {
int VAL = getVal(v[i]);
mid[i + 1] = mid[i];
cnt[i + 1] = cnt[i];
if (VAL == 0)
cnt[i + 1]++;
else
mid[i + 1] = mid[i + 1] * (long long)VAL % mod;
}
}
int getMid(int l, int r) {
if (l >= r) return 1;
int dcnt = cnt[r] - cnt[l];
if (dcnt) return 0;
return mid[r] * (long long)rev(mid[l], mod) % mod;
}
};
struct add {
vector<mul> v;
vector<int> pref, suf;
int val;
int st, en;
void calc() {
int len = ((int)(v).size());
pref = vector<int>(len + 1);
suf = vector<int>(len + 1);
pref[0] = 0;
for (int i = 0; i < len; ++i) pref[i + 1] = (pref[i] + v[i].val) % mod;
suf[len] = 0;
for (int i = len - 1; i >= 0; --i) suf[i] = (suf[i + 1] + v[i].val) % mod;
val = pref[len];
}
};
add parse_add();
brackets parse_brackets() {
brackets b;
b.st = pos;
assert(s[pos] == '(');
pos++;
b.val = parse_add().val;
assert(s[pos] == ')');
pos++;
b.en = pos;
return b;
}
pair<brackets, number> parse_brackets_or_number() {
pair<brackets, number> a;
if (s[pos] == '(') {
a.first = parse_brackets();
return a;
}
a.first = brackets(-1, -1, -1);
a.second = parse_number();
return a;
}
mul parse_mul() {
mul m;
m.st = pos;
while (1) {
m.v.push_back(parse_brackets_or_number());
if (s[pos] == ')' || s[pos] == 0 || s[pos] == '+') {
break;
}
assert(s[pos] == '*');
pos++;
}
m.en = pos;
m.calc();
return m;
}
int res[N];
vector<pair<int, int>> q[N];
int u[N];
int uc = 0;
pair<int, int> POS[N];
int p10[N];
int GIMME_PREF(pair<brackets, number> &a, int k) {
if (a.first.val == -1) {
return a.second.pref[k - a.second.st];
} else {
return a.first.val;
}
}
int GIMME_SUF(pair<brackets, number> &a, int k) {
if (a.first.val == -1) {
return a.second.suf[k - a.second.st];
} else {
return a.first.val;
}
}
int GET_ME_PREF(mul &M, int j, int k) {
int X = GIMME_PREF(M.v[j], k);
return X * (long long)M.pref[j] % mod;
}
int GET_ME_SUF(mul &M, int j, int k) {
int X = GIMME_SUF(M.v[j], k);
return X * (long long)M.suf[j + 1] % mod;
}
add parse_add() {
add a;
a.st = pos;
while (1) {
a.v.push_back(parse_mul());
if (s[pos] == ')' || s[pos] == 0) break;
assert(s[pos] == '+');
pos++;
}
a.en = pos;
a.calc();
uc++;
for (int i = 0; i < ((int)(a.v).size()); ++i) {
for (int j = 0; j < ((int)(a.v[i].v).size()); ++j) {
pair<brackets, number> z = a.v[i].v[j];
if (z.first.val == -1) {
for (int k = z.second.st + 1; k <= z.second.en; ++k) {
u[k] = uc;
POS[k] = {i, j};
}
} else {
int k = z.first.en;
u[k] = uc;
POS[k] = {i, j};
}
}
}
for (int i = 0; i < ((int)(a.v).size()); ++i) {
for (int j = 0; j < ((int)(a.v[i].v).size()); ++j) {
pair<brackets, number> z = a.v[i].v[j];
if (z.first.val == -1) {
for (int k = z.second.st; k < z.second.en; ++k) {
for (pair<int, int> w : q[k]) {
int y = w.first;
if (u[y] != uc) {
res[w.second] = -1;
continue;
}
int i2 = POS[y].first;
int j2 = POS[y].second;
int k2 = y;
if (i == i2) {
if (j == j2) {
number &E = a.v[i].v[j].second;
res[w.second] =
(E.pref[y - E.st] -
E.pref[k - E.st] * (long long)p10[y - k] % mod + mod) %
mod;
} else {
int L = GIMME_SUF(a.v[i].v[j], k);
int M = a.v[i].getMid(j + 1, j2);
int R = GIMME_PREF(a.v[i].v[j2], y);
res[w.second] = (L * (long long)M % mod * R) % mod;
}
} else {
int L = GET_ME_SUF(a.v[i], j, k);
int M = (a.pref[i2] - a.pref[i + 1] + mod) % mod;
int R = GET_ME_PREF(a.v[i2], j2, k2);
res[w.second] = (L + (long long)M + R) % mod;
}
}
}
} else {
int k = z.first.st;
for (pair<int, int> w : q[k]) {
int y = w.first;
if (u[y] != uc) {
res[w.second] = -1;
continue;
}
int i2 = POS[y].first;
int j2 = POS[y].second;
int k2 = y;
if (i == i2) {
if (j == j2) {
brackets &B = a.v[i].v[j].first;
res[w.second] = B.val;
} else {
int L = GIMME_SUF(a.v[i].v[j], k);
int M = a.v[i].getMid(j + 1, j2);
int R = GIMME_PREF(a.v[i].v[j2], y);
res[w.second] = (L * (long long)M % mod * R) % mod;
}
} else {
int L = GET_ME_SUF(a.v[i], j, k);
int M = (a.pref[i2] - a.pref[i + 1] + mod) % mod;
int R = GET_ME_PREF(a.v[i2], j2, k2);
res[w.second] = (L + (long long)M + R) % mod;
}
}
}
}
}
return a;
}
int main() {
p10[0] = 1;
for (int i = 1; i < N; ++i) p10[i] = p10[i - 1] * 10LL % mod;
scanf("%s", s);
int n;
scanf("%d", &n);
for (int i = 0; (i) < (n); ++i) {
int l, r;
scanf("%d%d", &l, &r);
--l;
q[l].push_back({r, i});
}
for (int i = 0; (i) < (n); ++i) res[i] = -1;
parse_add();
for (int i = 0; (i) < (n); ++i) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
using std::sort;
using std::swap;
using std::vector;
const int maxn = 400007;
const int mod = 1e9 + 7;
long long fast_pow(long long b, int k) {
long long s = 1;
while (k) {
if (k & 1) s = s * b % mod;
b = b * b % mod;
k >>= 1;
}
return s;
}
char s[maxn];
int N, Q;
int lef[maxn], rig[maxn];
long long val[maxn];
int stk[maxn], top;
int pid[maxn], pcnt, pl[maxn], pr[maxn];
long long psum[maxn];
int nid[maxn], ncnt, z[maxn];
long long pre[maxn], nval[maxn], prod[maxn];
long long p10[maxn];
long long getnum(int l, int r) {
if (s[r] == ')')
return val[r];
else
return (pre[r] - pre[l - 1] * p10[r - l + 1] % mod + mod) % mod;
}
long long getp(int l, int r) {
if (nid[l] == nid[r]) return getnum(l, r);
long long re = getnum(l, rig[l]) * getnum(lef[r], r) % mod;
l = rig[l] + 2;
r = lef[r] - 2;
if (l > r) return re;
l = nid[l];
r = nid[r];
if (z[r] - z[l - 1] > 0) return 0;
return prod[r] * fast_pow(prod[l - 1], mod - 2) % mod * re % mod;
}
int build(int l, int r) {
vector<int> p, v;
for (int i = l; i <= r; i = rig[i] + 2) {
p.push_back(i);
if (s[i] == '(') val[i] = val[rig[i]] = build(i + 1, rig[i] - 1);
v.push_back(getnum(i, rig[i]));
}
int tl, tr;
for (int i = 0; i < p.size(); i++) {
tl = p[i];
tr = rig[tl];
nval[++ncnt] = v[i];
if (s[tl] == '(')
nid[tl] = nid[tr] = ncnt;
else
for (int k = tl; k <= tr; k++) nid[k] = ncnt;
}
vector<int> a;
a.push_back(0);
for (int i = 1; i < p.size(); i++)
if (s[p[i] - 1] == '+') a.push_back(i);
a.push_back(p.size());
long long pro, re = 0;
for (int i = 0; i + 1 < a.size(); i++) {
tl = a[i], tr = a[i + 1] - 1;
pro = 1;
++pcnt;
pl[pcnt] = p[tl];
pr[pcnt] = rig[p[tr]];
for (int k = tl; k <= tr; k++) {
pro = pro * v[k] % mod;
if (s[p[k]] == '(')
pid[p[k]] = pid[rig[p[k]]] = pcnt;
else
for (int j = p[k]; j <= rig[p[k]]; j++) pid[j] = pcnt;
}
psum[pcnt] = (psum[pcnt - 1] + pro) % mod;
re = (re + pro) % mod;
}
return re;
}
int sum[maxn], st[21][maxn], lg[maxn];
void Pre() {
for (int i = 1; i <= N; i++) {
sum[i] = sum[i - 1];
if (s[i] == '(')
sum[i]++;
else if (s[i] == ')')
sum[i]--;
}
for (int i = 2; i <= N; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= N; i++) st[0][i] = sum[i];
for (int k = 1; k <= lg[N]; k++)
for (int i = 1; i <= N - (1 << k) + 1; i++)
st[k][i] = min(st[k - 1][i], st[k - 1][i + (1 << k - 1)]);
return;
}
int query(int l, int r) {
int k = lg[r - l + 1];
return min(st[k][l], st[k][r - (1 << k) + 1]);
}
int judge(int l, int r) {
return s[l] == '+' || s[l] == '*' || s[r] == '+' || s[r] == '*' ||
query(l, r) != sum[r] || sum[r] != sum[l - 1];
}
int main() {
scanf("%s", s + 2);
N = strlen(s + 2);
scanf("%d", &Q);
Pre();
s[1] = '(';
s[N + 2] = ')';
N += 2;
for (int i = 1; i <= N; i++) {
if (isdigit(s[i])) {
if (isdigit(s[i - 1]))
lef[i] = lef[i - 1];
else
lef[i] = i;
} else if (s[i] == ')')
lef[i] = stk[top--];
else if (s[i] == '(')
stk[++top] = i, lef[i] = i;
}
for (int i = N; i > 0; i--) {
if (isdigit(s[i])) {
if (isdigit(s[i + 1]))
rig[i] = rig[i + 1];
else
rig[i] = i;
} else if (s[i] == '(')
rig[i] = stk[top--];
else if (s[i] == ')')
stk[++top] = i, rig[i] = i;
}
for (int i = 1; i <= N; i++)
if (isdigit(s[i])) pre[i] = (pre[i - 1] * 10 + s[i] - '0') % mod;
for (int i = p10[0] = 1; i <= N; i++) p10[i] = p10[i - 1] * 10 % mod;
val[1] = val[N] = build(2, N - 1);
for (int i = prod[0] = 1; i <= ncnt; i++) {
z[i] = z[i - 1] + (nval[i] == 0);
prod[i] = prod[i - 1];
if (nval[i]) (prod[i] *= nval[i]) %= mod;
}
int l, r;
long long ans;
while (Q--) {
scanf("%d%d", &l, &r);
l++;
r++;
if (judge(l, r)) {
puts("-1");
continue;
}
if (nid[l] == nid[r])
printf("%lld\n", getnum(l, r));
else if (pid[l] == pid[r])
printf("%lld\n", getp(l, r));
else {
ans = (getp(l, pr[pid[l]]) + getp(pl[pid[r]], r)) % mod;
l = pid[l] + 1;
r = pid[r] - 1;
if (l <= r) ans = (ans + psum[r] - psum[l - 1] + mod) % mod;
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400500;
const int LOG_N = 19;
const int MOD = (int)1e9 + 7;
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
int mul(int a, int b) { return (long long)a * b % MOD; }
int n;
char s[N];
struct BracketManager {
int pref[N];
int st[LOG_N][N];
int pw2[N];
int open_pair[N], close_pair[N];
BracketManager() : pref(), st(), pw2(), open_pair(), close_pair() {}
void init(char s[], int n) {
vector<int> stack;
int bal = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
bal++;
stack.push_back(i);
} else if (s[i] == ')') {
bal--;
open_pair[stack.back()] = i;
close_pair[i] = stack.back();
stack.pop_back();
}
pref[i] = bal;
st[0][i] = bal;
}
pw2[1] = 0;
for (int i = 2; i <= n; i++) {
pw2[i] = pw2[i - 1];
if ((1 << (pw2[i] + 1)) <= i) pw2[i]++;
}
for (int s = 1; s < LOG_N; s++)
for (int i = 0; i + (1 << s) <= n; i++)
st[s][i] = min(st[s - 1][i], st[s - 1][i + (1 << (s - 1))]);
}
bool is_good(int l, int r) {
int k = pw2[r - l + 1];
int min_bal = min(st[k][l], st[k][r - (1 << k) + 1]);
int last = 0;
if (l > 0) last = pref[l - 1];
if (min_bal < last) return false;
int s = pref[r];
if (l > 0) s -= pref[l - 1];
return s == 0;
}
};
struct NumSegTree {
int sz;
vector<int> pw10;
vector<int> t;
int combine(int a, int b, int suf) { return add(mul(a, pw10[suf]), b); }
void build(int l, int r) {
int len = r - l + 1;
sz = 1;
while (sz < len) sz *= 2;
t.resize(2 * sz);
pw10.resize(2 * sz);
pw10[0] = 1;
for (int i = 1; i < 2 * sz; i++) pw10[i] = mul(pw10[i - 1], 10);
for (int i = 0; i < len; i++) t[sz + i] = s[i + l] - '0';
int suf = 1;
for (int i = sz - 1; i > 0; i--) {
int j = i + 1;
if (i != sz - 1 && !(j & (j - 1))) suf *= 2;
t[i] = combine(t[2 * i], t[2 * i + 1], suf);
}
}
int get(int v, int l, int r, int a, int b) {
if (a > r || b < l) return 0;
if (a <= l && r <= b) return t[v];
int m = (l + r) / 2;
int suf = max(0, min(r, b) - max(m + 1, a) + 1);
return combine(get(2 * v, l, m, a, b), get(2 * v + 1, m + 1, r, a, b), suf);
}
int get(int a, int b) { return get(1, 0, sz - 1, a, b); }
};
struct NumBlock {
int l, r, val;
NumSegTree tree;
NumBlock() : l(), r(), val() {}
int eval(int ql, int qr) {
ql = max(ql, l);
qr = min(qr, r);
if (l == ql && r == qr) return val;
return tree.get(ql - l, qr - l);
}
};
struct MultSegTree {
int sz;
vector<int> t;
void build(const vector<NumBlock> &seq) {
sz = 1;
while (sz < (int)seq.size()) sz *= 2;
t.resize(2 * sz);
for (int i = 0; i < (int)seq.size(); i++) t[sz + i] = seq[i].val;
for (int i = sz - 1; i > 0; i--) t[i] = mul(t[2 * i], t[2 * i + 1]);
}
int get(int v, int l, int r, int a, int b) {
if (a > r || b < l) return 1;
if (a <= l && r <= b) return t[v];
int m = (l + r) / 2;
return mul(get(2 * v, l, m, a, b), get(2 * v + 1, m + 1, r, a, b));
}
int get(int a, int b) { return get(1, 0, sz - 1, a, b); }
};
struct MultBlock {
int l, r, val;
MultSegTree tree;
vector<NumBlock> nums;
MultBlock() : l(), r(), val() {}
int eval(int ql, int qr) {
ql = max(ql, l);
qr = min(qr, r);
NumBlock me;
me.l = ql;
int left = upper_bound(nums.begin(), nums.end(), me,
[&](const NumBlock &a, const NumBlock &b) {
return a.l < b.l;
}) -
nums.begin() - 1;
me.l = qr;
int right = upper_bound(nums.begin(), nums.end(), me,
[&](const NumBlock &a, const NumBlock &b) {
return a.l < b.l;
}) -
nums.begin() - 1;
if (left == right) return nums[left].eval(ql, qr);
int res = nums[left].eval(ql, qr);
res = mul(res, nums[right].eval(ql, qr));
left++;
right--;
res = mul(res, tree.get(left, right));
return res;
}
};
struct SumBlock {
int l, r;
vector<int> pref_sum;
vector<MultBlock> mults;
SumBlock() : l(), r() {}
int eval(int ql, int qr) {
MultBlock me;
me.l = ql;
int left = upper_bound(mults.begin(), mults.end(), me,
[&](const MultBlock &a, const MultBlock &b) {
return a.l < b.l;
}) -
mults.begin() - 1;
me.l = qr;
int right = upper_bound(mults.begin(), mults.end(), me,
[&](const MultBlock &a, const MultBlock &b) {
return a.l < b.l;
}) -
mults.begin() - 1;
if (left == right) return mults[left].eval(ql, qr);
int res = mults[left].eval(ql, qr);
res = add(res, mults[right].eval(ql, qr));
left++;
right--;
res = add(res, pref_sum[right]);
res = sub(res, pref_sum[left - 1]);
return res;
}
};
BracketManager brackets;
vector<SumBlock> blocks[N];
int max_depth;
int parse_sum(int, int, int);
NumBlock parse_num(int l, int r, int d) {
NumBlock block;
block.l = l;
block.r = r;
if (s[l] == '(') {
int res = parse_sum(l + 1, r - 1, d + 1);
block.val = res;
} else {
block.tree.build(l, r);
block.val = block.tree.get(0, r - l);
}
return block;
}
MultBlock parse_mult(int l, int r, int d) {
MultBlock block;
block.l = l;
block.r = r;
int p = l - 1;
for (int i = l; i <= r + 1; i++) {
if (i <= r && s[i] == '(') {
i = brackets.open_pair[i];
continue;
}
if (i <= r && s[i] != '*') continue;
NumBlock inner = parse_num(p + 1, i - 1, d);
block.nums.push_back(inner);
p = i;
}
block.tree.build(block.nums);
block.val = block.tree.get(0, (int)block.nums.size() - 1);
return block;
}
int parse_sum(int l, int r, int d) {
max_depth = max(max_depth, d);
SumBlock block;
block.l = l;
block.r = r;
int p = l - 1;
for (int i = l; i <= r + 1; i++) {
if (i <= r && s[i] == '(') {
i = brackets.open_pair[i];
continue;
}
if (i <= r && s[i] != '+') continue;
MultBlock inner = parse_mult(p + 1, i - 1, d);
block.pref_sum.push_back(inner.val);
block.mults.push_back(inner);
p = i;
}
for (int i = 1; i < (int)block.pref_sum.size(); i++)
block.pref_sum[i] = add(block.pref_sum[i], block.pref_sum[i - 1]);
blocks[d].push_back(block);
return block.pref_sum.back();
}
int find_in_depth(int l, int r, int d) {
SumBlock me;
me.l = l;
int pos = upper_bound(blocks[d].begin(), blocks[d].end(), me,
[&](const SumBlock &a, const SumBlock &b) {
return a.l < b.l;
}) -
blocks[d].begin() - 1;
if (pos >= 0 && r <= blocks[d][pos].r) return pos;
return -1;
}
SumBlock &find_deepest_block(int l, int r) {
int left = 0, right = max_depth + 1;
while (right - left > 1) {
int mid = (left + right) / 2;
if (find_in_depth(l, r, mid) != -1)
left = mid;
else
right = mid;
}
return blocks[left][find_in_depth(l, r, left)];
}
void solve() {
scanf("%s", s);
n = strlen(s);
brackets.init(s, n);
parse_sum(0, n - 1, 0);
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
if (!brackets.is_good(l, r) || s[l] == '+' || s[l] == '*' || s[r] == '+' ||
s[r] == '*') {
puts("-1");
continue;
}
SumBlock &block = find_deepest_block(l, r);
printf("%d\n", block.eval(l, r));
}
}
int main() {
solve();
(void)0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int iv10;
int ip10[500006];
int n, q;
int Pow(int x, int a) {
int ret = 1;
while (a) {
if (a & 1) ret = ret * 1ll * x % P;
x = x * 1ll * x % P, a >>= 1;
}
return ret;
}
int rd() {
char ch = getchar();
int ret = 0;
while (ch > '9' || ch < '0') ch = getchar();
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret;
}
char S[500006];
int bel[500006], lk[500006];
struct sgt {
struct node {
int l, r;
node operator+(const node a) {
return (node){a.l - min(a.l, r) + l, r - min(a.l, r) + a.r};
}
} T[500006 << 2];
void build(int rt, int l, int r) {
if (l == r) {
if (S[l] == '(')
T[rt].r = 1;
else if (S[l] == ')')
T[rt].l = 1;
return;
}
int m = l + r >> 1;
build(rt << 1, l, m), build(rt << 1 | 1, m + 1, r);
T[rt] = T[rt << 1] + T[rt << 1 | 1];
}
node que(int rt, int l, int r, int L, int R) {
if (L <= l && R >= r) return T[rt];
int m = l + r >> 1;
node re = (node){0, 0};
if (L <= m) re = re + que(rt << 1, l, m, L, R);
if (R > m) re = re + que(rt << 1 | 1, m + 1, r, L, R);
return re;
}
bool que(int l, int r) {
node re = que(1, 1, n, l, r);
return !re.l && !re.r;
}
} T;
int solve(int l, int r);
int cnn, bn[500006];
struct segnum {
int l, r, v, dx;
vector<int> s;
int build() {
if (S[l] == '(') {
bn[l] = bn[r] = cnn;
return v = solve(l + 1, r - 1);
}
int pw = 1;
for (int j = (1), jend = (r - l + 1); j <= jend; ++j) pw = pw * 10ll % P;
for (int i = (l), iend = (r); i <= iend; ++i) bn[i] = dx;
for (int i = (0), iend = (r - l); i <= iend; ++i) {
pw = pw * 1ll * iv10 % P;
s.push_back((S[i + l] - '0') * 1ll * pw % P);
if (s.size() > 1) s[s.size() - 1] = (s.back() + s[s.size() - 2]) % P;
}
return v = s.back();
}
int gv(int L, int R) {
if (L == l && R == r) return v;
int x = (s[R - l] + P - (L == l ? 0 : s[L - 1 - l])) % P;
return x * 1ll * ip10[r - R] % P;
}
} N[500006];
int bm[500006], cnm;
struct segmul {
int l, r, v, dx;
vector<int> nums, pm, c0;
int build() {
int pl = l;
for (int i = (l), iend = (r); i <= iend; ++i) {
if (S[i] == '*') {
++cnn;
N[cnn].l = pl, N[cnn].r = i - 1, N[cnn].dx = cnn;
nums.push_back(cnn);
int v = N[cnn].build();
pm.push_back(v == 0 ? 1 : v), c0.push_back(v == 0);
pl = i + 1;
}
bm[i] = dx;
if (S[i] == '(') i = lk[i] - 1;
}
++cnn, N[cnn].l = pl, N[cnn].r = r, N[cnn].dx = cnn;
nums.push_back(cnn);
int v = N[cnn].build();
pm.push_back(v == 0 ? 1 : v), c0.push_back(v == 0);
for (int i = (1), iend = (pm.size() - 1); i <= iend; ++i) {
pm[i] = pm[i - 1] * 1ll * pm[i] % P;
c0[i] += c0[i - 1];
}
return c0.back() ? 0 : pm.back();
}
int gv(int L, int R) {
int tl = bn[L], tr = bn[R];
if (tl == tr) return N[tl].gv(L, R);
int re = N[tl].gv(L, N[tl].r) * 1ll * N[tr].gv(N[tr].l, R) % P;
tl = upper_bound((nums).begin(), (nums).end(), tl) - nums.begin(),
tr = lower_bound((nums).begin(), (nums).end(), tr) - nums.begin() - 1;
if (tr >= tl && c0[tr] - (tl == 0 ? 0 : c0[tl - 1])) return 0;
return pm[tr] * 1ll * (tl == 0 ? 1 : Pow(pm[tl - 1], P - 2)) % P * re % P;
}
} M[500006];
int cna;
struct segadd {
int l, r, v;
vector<int> ms, ps;
int build() {
int pl = l;
for (int i = (l), iend = (r); i <= iend; ++i) {
if (S[i] == '+') {
++cnm;
M[cnm].l = pl, M[cnm].r = i - 1, M[cnm].dx = cnm;
ms.push_back(cnm), ps.push_back(M[cnm].build());
pl = i + 1;
}
if (S[i] == '(') i = lk[i] - 1;
}
++cnm, M[cnm].l = pl, M[cnm].r = r, M[cnm].dx = cnm;
ms.push_back(cnm), ps.push_back(M[cnm].build());
for (int i = (1), iend = (ps.size() - 1); i <= iend; ++i)
ps[i] = (ps[i - 1] + ps[i]) % P;
return ps.back();
}
int gv(int L, int R) {
int tl = bm[L], tr = bm[R];
if (tl == tr) return M[tl].gv(L, R);
int res = M[tl].gv(L, M[tl].r) + M[tr].gv(M[tr].l, R);
tl = upper_bound((ms).begin(), (ms).end(), tl) - ms.begin(),
tr = lower_bound((ms).begin(), (ms).end(), tr) - ms.begin() - 1;
return (1ll * res + ps[tr] + P - ps[tl - 1]) % P;
}
} W[500006];
int solve(int l, int r) {
W[l - 1].l = l, W[l - 1].r = r;
return W[l - 1].build();
}
void solve() {
scanf("%s", S + 1);
n = strlen(S + 1);
iv10 = Pow(10, P - 2);
ip10[0] = 1;
for (int i = (1), iend = (n); i <= iend; ++i)
ip10[i] = ip10[i - 1] * 1ll * iv10 % P;
cin >> q;
vector<int> pt;
pt.push_back(0);
for (int i = (1), iend = (n); i <= iend; ++i) {
if (S[i] == '(')
bel[i] = pt.back(), pt.push_back(i);
else {
if (S[i] == ')') lk[pt.back()] = i, pt.pop_back();
bel[i] = pt.back();
}
}
T.build(1, 1, n);
solve(1, n);
for (int i = (1), iend = (q); i <= iend; ++i) {
int l, r;
l = rd(), r = rd();
if (S[l] == '+' || S[l] == '*' || S[r] == '+' || S[r] == '*') {
puts("-1");
continue;
}
if (!T.que(l, r)) {
puts("-1");
continue;
}
int x = bel[l];
printf("%d\n", W[x].gv(l, r));
}
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int add(int x, int y) { return (x += y) < 1000000007 ? x : x - 1000000007; }
int mul(int x, int y) { return (int)((long long int)x * y % 1000000007); }
int len;
char s[444444];
int p10[444444];
int chk_id[444444];
int nex_para[444444];
int pre_para[444444];
int nex_add[444444], nex_mul[444444];
int pre_add[444444], pre_mul[444444];
int st_pos[444444], st_chk_id[444444];
int top;
int CHK;
int id[444444];
int typ[444444], T;
vector<int> op[444444];
int szz[444444];
int pos[444444];
int val[444444];
vector<int> seg[444444];
int CUR;
void build(int i, int s, int e) {
if (s == e) {
seg[CUR][i] = op[CUR][s];
return;
}
int m = (s + e) / 2;
build(i * 2, s, m);
build(i * 2 + 1, m + 1, e);
if (typ[CUR] == 2)
seg[CUR][i] = add(seg[CUR][i * 2], seg[CUR][i * 2 + 1]);
else if (typ[CUR] == 3)
seg[CUR][i] = mul(seg[CUR][i * 2], seg[CUR][i * 2 + 1]);
else
seg[CUR][i] = add(mul(seg[CUR][i * 2], p10[e - m]), seg[CUR][i * 2 + 1]);
}
int query(int i, int s, int e, int l, int r) {
if (s == l && e == r) return seg[CUR][i];
int m = (s + e) / 2;
if (r <= m) return query(i * 2, s, m, l, r);
if (l > m) return query(i * 2 + 1, m + 1, e, l, r);
int res1 = query(i * 2, s, m, l, m);
int res2 = query(i * 2 + 1, m + 1, e, m + 1, r);
if (typ[CUR] == 2)
return add(res1, res2);
else if (typ[CUR] == 3)
return mul(res1, res2);
else
return add(mul(res1, p10[r - m]), res2);
}
int analysis(int from, int to) {
int cur = ++T;
if (s[from] == '(' && nex_para[from] == to) {
id[from] = id[to] = cur;
typ[cur] = 1;
return val[cur] = analysis(from + 1, to - 1);
}
if (nex_add[from] != -1 && nex_add[from] <= to) {
typ[cur] = 2;
while (1) {
int nx = nex_add[from];
if (nx == -1 || nx > to) break;
op[cur].push_back(analysis(from, nx - 1));
id[nx] = cur;
pos[nx] = op[cur].size();
from = nx + 1;
}
op[cur].push_back(analysis(from, to));
int sz = szz[cur] = op[cur].size();
seg[cur].resize(sz * 4);
CUR = cur;
build(1, 0, sz - 1);
return seg[cur][1];
}
if (nex_mul[from] != -1 && nex_mul[from] <= to) {
typ[cur] = 3;
while (1) {
int nx = nex_mul[from];
if (nx == -1 || nx > to) break;
op[cur].push_back(analysis(from, nx - 1));
pos[nx] = op[cur].size();
id[nx] = cur;
from = nx + 1;
}
op[cur].push_back(analysis(from, to));
int sz = szz[cur] = op[cur].size();
seg[cur].resize(sz * 4);
CUR = cur;
build(1, 0, sz - 1);
return seg[cur][1];
}
typ[cur] = 4;
for (int i = from; i <= to; i++) {
id[i] = cur;
op[cur].push_back(s[i] - '0');
pos[i] = op[cur].size();
}
int sz = szz[cur] = op[cur].size();
seg[cur].resize(sz * 4);
CUR = cur;
build(1, 0, sz - 1);
return seg[cur][1];
}
int process(int from, int to) {
if (s[from] == '(' && nex_para[from] == to) {
return val[id[from]];
}
if (nex_add[from] != -1 && nex_add[from] <= to) {
int A = nex_add[from];
int B = pre_add[to];
int cur = id[A];
int A_id = pos[A], B_id = pos[B];
CUR = cur;
int zz = A_id != B_id ? query(1, 0, szz[cur] - 1, A_id, B_id - 1) : 0;
zz = add(zz, process(from, A - 1));
zz = add(zz, process(B + 1, to));
return zz;
}
if (nex_mul[from] != -1 && nex_mul[from] <= to) {
int A = nex_mul[from];
int B = pre_mul[to];
int cur = id[A];
int A_id = pos[A], B_id = pos[B];
CUR = cur;
int zz = A_id != B_id ? query(1, 0, szz[cur] - 1, A_id, B_id - 1) : 1;
zz = mul(zz, process(from, A - 1));
zz = mul(zz, process(B + 1, to));
return zz;
}
int cur = id[from];
CUR = cur;
return query(1, 0, szz[cur] - 1, pos[from] - 1, pos[to] - 1);
}
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
s[0] = '(';
s[len + 1] = ')';
len += 2;
top = 0;
for (int i = 0; i < len; i++)
if (s[i] == '(') {
st_pos[top] = i;
st_chk_id[top] = ++CHK;
top++;
} else if (s[i] == ')') {
int from = st_pos[top - 1] + 1, to = i - 1, chk = st_chk_id[top - 1];
int add = -1, mul = -1;
for (int j = from; j <= to; j++) {
pre_add[j] = add;
pre_mul[j] = mul;
chk_id[j] = chk;
if (s[j] == '(') {
j = nex_para[j];
pre_add[j] = add;
pre_mul[j] = mul;
chk_id[j] = chk;
} else if (s[j] == '+')
add = j;
else if (s[j] == '*')
mul = j;
}
add = mul = -1;
for (int j = to; j >= from; j--) {
nex_add[j] = add;
nex_mul[j] = mul;
if (s[j] == ')') {
j = pre_para[j];
nex_add[j] = add;
nex_mul[j] = mul;
} else if (s[j] == '+')
add = j;
else if (s[j] == '*')
mul = j;
}
nex_para[st_pos[top - 1]] = i;
pre_para[i] = st_pos[top - 1];
--top;
}
p10[0] = 1;
for (int i = 1; i <= len; i++) p10[i] = mul(p10[i - 1], 10);
analysis(0, len - 1);
int q, from, to;
for (scanf("%d", &q); q--;) {
scanf("%d%d", &from, &to);
if (chk_id[from] == chk_id[to] && (isdigit(s[from]) || s[from] == '(') &&
(isdigit(s[to]) || s[to] == ')')) {
printf("%d\n", process(from, to));
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
namespace fastio {
char rbuf[1 << 23], *p1 = rbuf, *p2 = rbuf, wbuf[1 << 23], *p3 = wbuf;
inline char getc() {
return p1 == p2 &&
(p2 = (p1 = rbuf) + fread(rbuf, 1, 1 << 23, stdin), p1 == p2)
? -1
: *p1++;
}
inline void putc(char x) { (*p3++ = x); }
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
T neg = 0;
while (!isdigit(c)) neg |= !(c ^ '-'), c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (neg) x = (~x) + 1;
}
template <typename T>
void recursive_print(T x) {
return (!x) ? void() : (recursive_print(x / 10), putc(x % 10 ^ 48), void());
}
template <typename T>
void print(T x) {
(!x) && (putc('0'), 0);
(x < 0) && (putc('-'), x = ~x + 1);
recursive_print(x);
}
template <typename T>
void print(T x, char c) {
(!x) && (putc('0'), 0);
(x < 0) && (putc('-'), x = ~x + 1);
recursive_print(x);
putc(c);
}
void print_final() { fwrite(wbuf, 1, p3 - wbuf, stdout); }
} // namespace fastio
const int MAXN = 5e5;
const int LOG_N = 20;
const int MOD = 1e9 + 7;
int qpow(int x, int e) {
int ret = 1;
for (; e; e >>= 1, x = 1ll * x * x % MOD)
if (e & 1) ret = 1ll * ret * x % MOD;
return ret;
}
int n, qu, ncnt, sum[MAXN + 5], dep[MAXN + 5];
char s[MAXN + 5];
int nt[MAXN + 5], pr[MAXN + 5];
vector<int> son[MAXN + 5];
vector<pair<int, int> > itvl[MAXN + 5];
int mch[MAXN + 5], rt, bel[MAXN + 5], op[MAXN + 5], val[MAXN + 5];
int pre[MAXN + 5], pw10[MAXN + 5];
int getnum(int l, int r) {
return (pre[r] - 1ll * pre[l - 1] * pw10[r - l + 1] % MOD + MOD) % MOD;
}
int build(int l, int r) {
if (s[l] == '(' && mch[l] == r) return bel[l] = bel[r] = build(l + 1, r - 1);
int opt = -1, id = ++ncnt;
for (int i = l; i <= r;) {
if (s[i] == '+')
opt = 0;
else if (s[i] == '*' && !~opt)
opt = 1;
if (s[i] == '(')
i = mch[i] + 1;
else
i++;
}
op[id] = opt;
if (!~opt) {
for (int i = l; i <= r; i++) {
bel[i] = id;
val[id] = (10ll * val[id] + s[i] - '0') % MOD;
}
return id;
}
int pre = l - 1;
for (int i = l; i <= r;) {
if ((s[i] == '+' && !opt) || (s[i] == '*' && opt)) {
son[id].push_back(build(pre + 1, i - 1));
itvl[id].push_back(make_pair(pre + 1, i - 1));
pre = i;
bel[i] = id;
}
if (s[i] == '(')
i = mch[i] + 1;
else
i++;
}
son[id].push_back(build(pre + 1, r));
itvl[id].push_back(make_pair(pre + 1, r));
return id;
}
struct num0 {
int x, y;
num0(int _x = 0) { (_x) ? (x = _x, y = 0) : (x = y = 1); }
int val() { return (y) ? 0 : x; }
num0 operator+(const int &rhs) {
int sum = (val() + rhs) % MOD;
return (sum) ? num0(sum) : num0(0);
}
num0 operator*(const int &rhs) {
num0 res = *this;
(rhs) ? (res.x = 1ll * res.x * rhs % MOD) : (res.y++);
return res;
}
num0 operator/(const num0 &rhs) {
num0 res;
res.x = 1ll * x * qpow(rhs.x, MOD - 2) % MOD;
res.y = y - rhs.y;
return res;
}
};
vector<num0> ss[MAXN + 5];
void calc(int x) {
if (~op[x]) val[x] = op[x];
ss[x].resize(son[x].size());
for (int i = 0; i < son[x].size(); i++) {
int y = son[x][i];
dep[y] = dep[x] + 1;
calc(y);
if (!i) ss[x][i] = val[y];
if (op[x] == 0) {
val[x] = (val[x] + val[y]) % MOD;
if (i) ss[x][i] = ss[x][i - 1] + val[y];
} else {
val[x] = 1ll * val[x] * val[y] % MOD;
if (i) ss[x][i] = ss[x][i - 1] * val[y];
}
}
}
int st_sum[MAXN + 5][LOG_N + 2];
pair<int, int> st_dep[MAXN + 5][LOG_N + 2];
void buildst() {
for (int i = 1; i <= LOG_N; i++)
for (int j = 1; j + (1 << i) - 1 <= n; j++) {
st_sum[j][i] = min(st_sum[j][i - 1], st_sum[j + (1 << i - 1)][i - 1]);
st_dep[j][i] = min(st_dep[j][i - 1], st_dep[j + (1 << i - 1)][i - 1]);
}
}
int query_sum(int l, int r) {
int k = 31 - __builtin_clz(r - l + 1);
return min(st_sum[l][k], st_sum[r - (1 << k) + 1][k]);
}
pair<int, int> query_dep(int l, int r) {
int k = 31 - __builtin_clz(r - l + 1);
return min(st_dep[l][k], st_dep[r - (1 << k) + 1][k]);
}
int main() {
scanf("%s%d", s + 1, &qu);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
if (isdigit(s[i]))
pre[i] = (10ll * pre[i - 1] + s[i] - '0') % MOD;
else
pre[i] = pre[i - 1];
}
for (int i = (pw10[0] = 1); i <= n; i++) pw10[i] = 10ll * pw10[i - 1] % MOD;
stack<int> stk;
for (int i = 1; i <= n; i++) {
if (s[i] == '(')
stk.push(i), sum[i] = sum[i - 1] + 1;
else if (s[i] == ')') {
mch[i] = stk.top();
mch[stk.top()] = i;
stk.pop();
sum[i] = sum[i - 1] - 1;
} else
sum[i] = sum[i - 1];
}
int pp = n + 1;
for (int i = n; i; i--) {
if (!isdigit(s[i]))
pp = i;
else
nt[i] = pp - 1;
}
pp = 0;
for (int i = 1; i <= n; i++) {
if (!isdigit(s[i]))
pp = i;
else
pr[i] = pp + 1;
}
rt = build(1, n);
calc(rt);
for (int i = 1; i <= n; i++)
st_sum[i][0] = sum[i], st_dep[i][0] = make_pair(dep[bel[i]], i);
buildst();
while (qu--) {
int l, r;
scanf("%d%d", &l, &r);
if (sum[l - 1] != sum[r]) {
puts("-1");
continue;
}
if (query_sum(l, r) < sum[l - 1]) {
puts("-1");
continue;
}
if (s[l] == '+' || s[l] == '*') {
puts("-1");
continue;
}
if (s[r] == '+' || s[r] == '*') {
puts("-1");
continue;
}
pair<int, int> p = query_dep(l, r);
int x = bel[p.second];
if (!~op[x]) {
if (isdigit(s[l]) && isdigit(s[r]))
printf("%d\n", getnum(l, r));
else
printf("%d\n", val[x]);
continue;
}
int L = upper_bound(itvl[x].begin(), itvl[x].end(), make_pair(l, n + 1)) -
itvl[x].begin() - 1;
int R = upper_bound(itvl[x].begin(), itvl[x].end(), make_pair(r, n + 1)) -
itvl[x].begin() - 1;
if (L < 0) L = 0;
int u = son[x][L], v = son[x][R];
if (op[x] == 1) {
int res = 1;
if (L != R) {
num0 qwq = ss[x][R - 1] / ss[x][L];
res = qwq.val();
}
if (~op[u])
res = 1ll * res * val[u] % MOD;
else {
if (isdigit(s[l]))
res = 1ll * res * getnum(l, nt[l]) % MOD;
else
res = 1ll * res * val[u] % MOD;
}
if (~op[v])
res = 1ll * res * val[v] % MOD;
else {
if (isdigit(s[r]))
res = 1ll * res * getnum(pr[r], r) % MOD;
else
res = 1ll * res * val[v] % MOD;
}
printf("%d\n", res);
} else {
int res = 0;
if (L != R) res = (ss[x][R - 1].val() - ss[x][L].val() + MOD) % MOD;
if (~op[u]) {
if (op[u] == 0)
res = (res + val[u]) % MOD;
else {
int LL =
upper_bound(itvl[u].begin(), itvl[u].end(), make_pair(l, n + 1)) -
itvl[u].begin() - 1;
if (LL < 0) LL = 0;
int su = son[u][LL], mul = 1;
if (LL + 1 != ss[u].size()) mul = (ss[u].back() / ss[u][LL]).val();
if (~op[su])
mul = 1ll * mul * val[su] % MOD;
else {
if (isdigit(s[l]))
mul = 1ll * mul * getnum(l, nt[l]) % MOD;
else
mul = 1ll * mul * val[su] % MOD;
}
res = (res + mul) % MOD;
}
} else {
if (isdigit(s[l]))
res = (res + getnum(l, nt[l])) % MOD;
else
res = (res + val[u]) % MOD;
}
if (~op[v]) {
if (op[v] == 0)
res = (res + val[v]) % MOD;
else {
int RR =
upper_bound(itvl[v].begin(), itvl[v].end(), make_pair(r, n + 1)) -
itvl[v].begin() - 1;
int sv = son[v][RR], mul = 1;
if (RR) mul = (ss[v][RR - 1]).val();
if (~op[sv])
mul = 1ll * mul * val[sv] % MOD;
else {
if (isdigit(s[r]))
mul = 1ll * mul * getnum(pr[r], r) % MOD;
else
mul = 1ll * mul * val[sv] % MOD;
}
res = (res + mul) % MOD;
}
} else {
if (isdigit(s[r]))
res = (res + getnum(pr[r], r)) % MOD;
else
res = (res + val[v]) % MOD;
}
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
namespace FIO {
const int mxsz = 1 << 23;
char ibuf[mxsz], *iend = ibuf + mxsz, *ipos = iend;
char obuf[mxsz], *oend = obuf + mxsz, *opos = obuf;
char get_char() {
if (ipos == iend) iend = (ipos = ibuf) + fread(ibuf, 1, mxsz, stdin);
return ipos == iend ? EOF : *ipos++;
}
void put_char(char c) {
if (opos == oend) fwrite(opos = obuf, 1, mxsz, stdout);
*opos++ = c;
}
int read_int() {
int x = 0, c = get_char();
while (c <= 32) c = get_char();
while (c > 32) x = x * 10 + c - 48, c = get_char();
return x;
}
void read_str(char *S) {
while ((*S = get_char()) <= 32)
;
while ((*++S = get_char()) > 32)
;
*S = 0;
}
void write_int(int x) {
static char stk[20];
if (x < 0) put_char(45), x *= -1;
if (x == 0) put_char(48);
int top = 0;
while (x) stk[top++] = x % 10 + 48, x /= 10;
while (top--) put_char(stk[top]);
put_char(10);
}
void flush() {
fwrite(obuf, 1, opos - obuf, stdout);
opos = obuf;
}
} // namespace FIO
using FIO::flush;
using FIO::read_int;
using FIO::read_str;
using FIO::write_int;
const int mxn = 1 << 19;
int n, q;
char expr[mxn];
int jmp[mxn];
int lv[mxn];
std::vector<int> vplus[mxn], vmul[mxn];
std::vector<int> elem;
int L[mxn], R[mxn];
namespace BracketChecker {
struct Node {
int a, b;
Node() : a(), b() {}
Node(int _a, int _b) : a(_a), b(_b) {}
};
Node operator+(const Node &a, const Node &b) {
if (a.b <= b.a)
return Node(a.a + b.a - a.b, b.b);
else
return Node(a.a, a.b - b.a + b.b);
}
Node t[mxn << 1];
void init() {
for (int i = 0; i < n; ++i) {
if (expr[i] == '(')
t[i + mxn] = Node(0, 1);
else if (expr[i] == ')')
t[i + mxn] = Node(1, 0);
else
t[i + mxn] = Node(0, 0);
}
for (int i = n; i < mxn; ++i) t[i + mxn] = Node(0, 0);
for (int i = mxn - 1; i; --i) t[i] = t[i << 1] + t[i << 1 | 1];
}
Node query(int l, int r) {
Node ansl = Node(0, 0);
Node ansr = Node(0, 0);
for (l += mxn, r += mxn; l < r; l >>= 1, r >>= 1) {
if (l & 1) ansl = ansl + t[l++];
if (r & 1) ansr = t[--r] + ansr;
}
return ansl + ansr;
}
bool check(int l, int r) {
Node s = query(l, r);
return s.a == 0 && s.b == 0;
}
} // namespace BracketChecker
int pw10[mxn];
namespace Number {
int va[mxn << 1], len[mxn << 1];
void merge(int vl, int ll, int vr, int lr, int &v, int &l) {
v = (1LL * vl * pw10[lr] + vr) % mod;
l = ll + lr;
}
void init() {
for (int i = 0; i < (int)(n); ++i)
if (isdigit(expr[i]))
va[i + mxn] = expr[i] - '0', len[i + mxn] = 1;
else
va[i + mxn] = 0, len[i + mxn] = 0;
for (int i = mxn - 1; i; --i)
merge(va[i << 1], len[i << 1], va[i << 1 | 1], len[i << 1 | 1], va[i],
len[i]);
}
int query(int l, int r) {
int vl = 0, ll = 0, vr = 0, lr = 0;
for (l += mxn, r += mxn; l < r; l >>= 1, r >>= 1) {
if (l & 1) merge(vl, ll, va[l], len[l], vl, ll), ++l;
if (r & 1) --r, merge(va[r], len[r], vr, lr, vr, lr);
}
int ans_va, ans_len;
merge(vl, ll, vr, lr, ans_va, ans_len);
return ans_va;
}
} // namespace Number
int ans[mxn];
namespace Tree {
const int MUL = 0;
const int ADD = 1;
const int CONCAT = 2;
int tot, rt;
std::vector<int> adj[mxn << 1];
int type[mxn << 1];
int build(int l, int r) {
int pl = std::lower_bound(vplus[lv[l]].begin(), vplus[lv[l]].end(), l) -
vplus[lv[l]].begin();
int pr = std::lower_bound(vplus[lv[l]].begin(), vplus[lv[l]].end(), r) -
vplus[lv[l]].begin();
if (pl < pr) {
int u = tot++;
type[u] = ADD;
int las = l;
for (int x = pl; x < pr; ++x) {
adj[u].push_back(build(las, vplus[lv[l]][x]));
las = vplus[lv[l]][x] + 1;
}
adj[u].push_back(build(las, r));
return u;
}
int ml = std::lower_bound(vmul[lv[l]].begin(), vmul[lv[l]].end(), l) -
vmul[lv[l]].begin();
int mr = std::lower_bound(vmul[lv[l]].begin(), vmul[lv[l]].end(), r) -
vmul[lv[l]].begin();
if (ml < mr) {
int u = tot++;
type[u] = MUL;
int las = l;
for (int x = ml; x < mr; ++x) {
adj[u].push_back(build(las, vmul[lv[l]][x]));
las = vmul[lv[l]][x] + 1;
}
adj[u].push_back(build(las, r));
return u;
}
if (jmp[l] == r - 1) return build(l + 1, r - 1);
int u = tot++;
type[u] = CONCAT;
for (int x = l; x < r; ++x) adj[u].push_back(x);
return u;
}
struct Tag {
int a, b;
Tag() : a(1), b(0) {}
Tag(int _a, int _b) : a(_a), b(_b) {}
};
Tag operator+(const Tag &a, const Tag &b) {
return Tag(1LL * a.a * b.a % mod, (1LL * a.b * b.a + b.b) % mod);
}
struct SegmentTree {
static const int mxlg = 19;
Tag ta[mxn << 1];
void push(int x, Tag t) { ta[x] = ta[x] + t; }
void pushdown(int x) {
if (ta[x].a != 1 || ta[x].b != 0) {
push(x << 1, ta[x]);
push(x << 1 | 1, ta[x]);
ta[x] = Tag();
}
}
void init() {
for (int i = 1; i < mxn << 1; ++i) ta[i] = Tag();
}
void update(int l, int r, Tag t) {
l += mxn, r += mxn;
for (int i = mxlg; i; --i) {
if (((l >> i) << i) != l) pushdown(l >> i);
if (((r >> i) << i) != r) pushdown(r >> i);
}
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) push(l++, t);
if (r & 1) push(--r, t);
}
}
int query(int x) {
x += mxn;
for (int i = mxlg; i; --i) pushdown(x >> i);
return ta[x].b;
}
} pre, suf;
const int mxlg = 20;
int fa[mxn << 1][mxlg];
int dep[mxn << 1];
void dfs0(int u) {
for (int i = 0; i < (int)(mxlg - 1); ++i) fa[u][i + 1] = fa[fa[u][i]][i];
for (int i = 0; i < (int)(adj[u].size()); ++i) {
int v = adj[u][i];
fa[v][0] = u;
dep[v] = dep[u] + 1;
dfs0(v);
}
}
void init() {
tot = n;
rt = build(0, n);
fa[rt][0] = rt;
dep[rt] = 0;
dfs0(rt);
}
int lca(int u, int v) {
if (dep[u] > dep[v]) std::swap(u, v);
for (int i = 0; i < (int)(mxlg); ++i)
if ((dep[v] - dep[u]) >> i & 1) v = fa[v][i];
if (u == v) return u;
for (int i = mxlg - 1; ~i; --i)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
int jmp(int u, int v) {
for (int i = mxlg - 1; ~i; --i) {
if (dep[fa[u][i]] > dep[v]) {
u = fa[u][i];
}
}
return u;
}
struct Query {
int x1, x2, v1, v2, id;
Query(int _x1, int _x2, int _v1, int _v2, int _id)
: x1(_x1), x2(_x2), v1(_v1), v2(_v2), id(_id) {}
};
std::vector<Query> qry[mxn << 1];
int boundl[mxn << 1], boundr[mxn << 1];
void reg_query(int u, int x1, int x2, int v1, int v2, int id) {
qry[u].push_back(Query(x1, x2, v1, v2, id));
}
int bsearch(int u, int v) {
int lb = 0, rb = (int)adj[u].size() - 1;
while (lb < rb) {
int md = (lb + rb) >> 1;
if (boundl[adj[u][md]] < boundl[v])
lb = md + 1;
else
rb = md;
}
return lb;
}
int TYPE;
int merge(int a, int b) {
return TYPE == MUL ? 1LL * a * b % mod : (a + b) % mod;
}
int sz;
int seg_mini[mxn << 1];
void init_mini(int n, const std::vector<int> &vec) {
sz = 1;
while (sz < n) sz <<= 1;
for (int i = 0; i < (int)(n); ++i) seg_mini[i + sz] = vec[i];
for (int i = n; i < sz; ++i) seg_mini[i + sz] = TYPE == MUL ? 1 : 0;
for (int i = sz - 1; i; --i)
seg_mini[i] = merge(seg_mini[i << 1], seg_mini[i << 1 | 1]);
}
int query_mini(int l, int r) {
int ansl = TYPE == MUL ? 1 : 0;
int ansr = TYPE == MUL ? 1 : 0;
for (l += sz, r += sz; l < r; l >>= 1, r >>= 1) {
if (l & 1) ansl = merge(ansl, seg_mini[l++]);
if (r & 1) ansr = merge(seg_mini[--r], ansr);
}
return merge(ansl, ansr);
}
void dfs1(int u) {
if (u < n) {
boundl[u] = u;
boundr[u] = u;
return;
}
boundl[u] = 0x3f3f3f3f;
boundr[u] = -0x3f3f3f3f;
for (int i = 0; i < (int)(adj[u].size()); ++i) {
int v = adj[u][i];
dfs1(v);
boundl[u] = std::min(boundl[u], boundl[v]);
boundr[u] = std::max(boundr[u], boundr[v]);
}
TYPE = type[u];
std::vector<int> vadj(adj[u].size());
for (int i = 0; i < (int)(adj[u].size()); ++i) {
int v = adj[u][i];
vadj[i] = pre.query(boundr[v]);
}
init_mini(adj[u].size(), vadj);
for (Query Q : qry[u]) {
int x1 = Q.x1;
int x2 = Q.x2;
int v1 = Q.v1;
int v2 = Q.v2;
int id = Q.id;
int p1 = bsearch(u, v1);
int p2 = bsearch(u, v2);
if (TYPE == CONCAT) {
ans[id] = Number::query(v1, v2 + 1);
} else {
ans[id] =
merge(merge(suf.query(x1), query_mini(p1 + 1, p2)), pre.query(x2));
}
}
if (TYPE == CONCAT) {
int now = 0;
for (int i = 0; i < (int)adj[u].size(); ++i) {
int v = adj[u][i];
now = (10LL * now + expr[v] - '0') % mod;
pre.update(v, v + 1, Tag(0, now));
}
now = 0;
for (int i = (int)adj[u].size() - 1; ~i; --i) {
int v = adj[u][i];
now = (now + 1LL * pw10[(int)adj[u].size() - 1 - i] * (expr[v] - '0')) %
mod;
suf.update(v, v + 1, Tag(0, now));
}
} else {
Tag now = Tag();
for (int i = 0; i < (int)adj[u].size(); ++i) {
int v = adj[u][i];
pre.update(boundl[v], boundr[v] + 1, now);
int x = vadj[i];
if (TYPE == MUL)
now.a = 1LL * now.a * x % mod;
else
now.b = (now.b + x) % mod;
}
now = Tag();
for (int i = (int)adj[u].size() - 1; ~i; --i) {
int v = adj[u][i];
suf.update(boundl[v], boundr[v] + 1, now);
int x = vadj[i];
if (TYPE == MUL)
now.a = 1LL * now.a * x % mod;
else
now.b = (now.b + x) % mod;
}
}
}
void proc() {
pre.init();
suf.init();
dfs1(rt);
}
} // namespace Tree
int main() {
for (int i = 0; i < (int)(mxn); ++i)
pw10[i] = i ? 10LL * pw10[i - 1] % mod : 1;
read_str(expr);
n = strlen(expr);
q = read_int();
{
static int stk[mxn];
int top = 0;
for (int i = 0; i < (int)(n); ++i) {
jmp[i] = -1;
if (expr[i] == '(') {
stk[top++] = i;
} else if (expr[i] == ')') {
--top;
jmp[i] = stk[top];
jmp[stk[top]] = i;
}
}
for (int i = 0; i < (int)(n); ++i) {
lv[i + 1] = lv[i];
if (expr[i] == '(')
++lv[i + 1];
else if (expr[i] == ')')
--lv[i + 1];
}
for (int i = 0; i < (int)(n); ++i) {
if (expr[i] == '+')
vplus[lv[i]].push_back(i);
else if (expr[i] == '*')
vmul[lv[i]].push_back(i);
}
}
BracketChecker::init();
for (int i = 0; i < (int)(n); ++i)
if (isdigit(expr[i])) elem.push_back(i);
Tree::init();
for (int i = 0; i < (int)(q); ++i) {
L[i] = read_int() - 1;
R[i] = read_int() - 1;
bool fail = false;
fail |= !BracketChecker::check(L[i], R[i] + 1);
fail |= expr[L[i]] == '+' || expr[L[i]] == '*';
fail |= expr[R[i]] == '+' || expr[R[i]] == '*';
if (fail) {
ans[i] = -1;
continue;
}
int u =
elem[std::lower_bound(elem.begin(), elem.end(), L[i]) - elem.begin()];
int v = elem[std::upper_bound(elem.begin(), elem.end(), R[i]) -
elem.begin() - 1];
if (u == v) {
ans[i] = expr[u] - '0';
continue;
}
int l = Tree::lca(u, v);
int ju = Tree::jmp(u, l);
int jv = Tree::jmp(v, l);
Tree::reg_query(l, u, v, ju, jv, i);
}
Number::init();
Tree::proc();
for (int i = 0; i < (int)(q); ++i) write_int(ans[i]);
flush();
return 0;
}
|
#include <bits/stdc++.h>
inline int read() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') ch = getchar(), w = -1;
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - 48, ch = getchar();
return x * w;
}
const int N = 5e5 + 5;
const int MOD = 1e9 + 7;
char s[N];
inline void add(int &a, int b) { a = a + b >= MOD ? a + b - MOD : a + b; }
inline int madd(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
inline int get_id(char ch) {
if (ch >= '0' && ch <= '9') return 0;
if (ch == '+' || ch == '*') return 1;
return 2;
}
int pow_10[N];
inline int fpow(int x, int p) {
int res = 1;
while (p) {
if (p & 1) res = 1ll * x * res % MOD;
x = 1ll * x * x % MOD;
p >>= 1;
}
return res;
}
int n, Q;
int left[N], right[N], num[N];
int dep[N], val[N];
int nval[N], nid[N], cnt1;
int osum[N], oid[N], opl[N], opr[N], cnt2;
int zero[N], prod[N], inv_prod[N];
inline int get_num(int l, int r) {
if (s[r] == ')') return val[r];
return madd(num[r], MOD - 1ll * num[l - 1] * pow_10[r - l + 1] % MOD);
}
inline int get_opt(int l, int r) {
if (nid[l] == nid[r]) return get_num(l, r);
int res = 1ll * get_num(l, right[l]) * get_num(left[r], r) % MOD;
l = right[l] + 2, r = left[r] - 2;
if (l > r || !res) return res;
l = nid[l], r = nid[r];
if (zero[r] - zero[l - 1] > 0) return 0;
return 1ll * res * prod[r] % MOD * inv_prod[l - 1] % MOD;
}
inline int build(int l, int r, int cur_dep) {
std::vector<int> id, seg_num, opts;
for (int i = l; i <= r; i = right[i] + 2) {
id.push_back(i);
if (s[i] == '(') {
dep[i] = dep[right[i]] = cur_dep;
val[i] = val[right[i]] = build(i + 1, right[i] - 1, i);
} else
for (int j = i; j <= right[i]; j++) dep[j] = cur_dep;
seg_num.push_back(get_num(i, right[i]));
}
opts.push_back(0);
for (int i = 1; i < (int)id.size(); i++)
if (s[id[i] - 1] == '+') opts.push_back(i);
opts.push_back((int)id.size());
for (int i = 0; i < (int)id.size(); i++) {
int nl = id[i];
int nr = right[nl];
nval[++cnt1] = seg_num[i];
if (s[nl] == '(')
nid[nl] = nid[nr] = cnt1;
else
for (int j = nl; j <= nr; j++) nid[j] = cnt1;
}
int res = 0;
for (int i = 0; i < (int)opts.size() - 1; i++) {
int nl = opts[i];
int nr = opts[i + 1] - 1;
int sum = 1;
++cnt2;
opl[cnt2] = id[nl];
opr[cnt2] = right[id[nr]];
for (int j = nl; j <= nr; j++) {
sum = 1ll * sum * seg_num[j] % MOD;
int ml = id[j];
int mr = right[ml];
if (s[ml] == '(')
oid[ml] = oid[mr] = cnt2;
else
for (int k = ml; k <= mr; k++) oid[k] = cnt2;
}
osum[cnt2] = sum;
add(res, sum);
}
return res;
}
inline void init() {
scanf("%s", s + 2);
Q = read();
n = strlen(s + 2) + 2;
s[1] = '(';
s[n] = ')';
pow_10[0] = 1;
for (int i = 1; i <= n; i++) pow_10[i] = 1ll * pow_10[i - 1] * 10 % MOD;
std::stack<int> stk;
for (int i = n; i >= 1; i--) {
int id = get_id(s[i]);
if (!id)
right[i] = get_id(s[i + 1]) ? i : right[i + 1];
else if (s[i] == ')')
right[i] = i, stk.push(i);
else if (s[i] == '(')
right[i] = stk.top(), stk.pop();
}
for (int i = 1; i <= n; i++) {
int id = get_id(s[i]);
if (!id)
left[i] = get_id(s[i - 1]) ? i : left[i - 1];
else if (s[i] == '(')
left[i] = i, stk.push(i);
else if (s[i] == ')')
left[i] = stk.top(), stk.pop();
}
for (int i = 1; i <= n; i++)
if (!get_id(s[i])) num[i] = (1ll * num[i - 1] * 10 + s[i] - 48) % MOD;
val[1] = val[n] = build(2, n - 1, 1);
for (int i = 1; i <= cnt2; i++) add(osum[i], osum[i - 1]);
prod[0] = 1;
for (int i = 1; i <= cnt1; i++) {
if (!nval[i])
zero[i] = zero[i - 1] + 1;
else
zero[i] = zero[i - 1];
prod[i] = 1ll * prod[i - 1] * (std::max(1, nval[i])) % MOD;
inv_prod[i] = fpow(prod[i], MOD - 2);
}
}
int main() {
init();
while (Q--) {
int l = read() + 1, r = read() + 1;
if (s[l] == '*' || s[r] == '+' || s[l] == '+' || s[r] == '*' ||
s[l] == ')' || s[r] == '(' || dep[l] != dep[r]) {
puts("-1");
continue;
}
if (nid[l] == nid[r]) {
printf("%d\n", get_num(l, r));
} else if (oid[l] == oid[r]) {
printf("%d\n", get_opt(l, r));
} else {
int res = madd(get_opt(l, opr[oid[l]]), get_opt(opl[oid[r]], r));
l = oid[l] + 1, r = oid[r] - 1;
if (l <= r) add(res, (osum[r] + MOD - osum[l - 1]) % MOD);
printf("%d\n", (res % MOD + MOD) % MOD);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
template <int MOD>
struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
ModInt(signed long long sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
};
template <typename Val>
struct GetRangeSegmentTree {
static Val combineVal(const Val &x, const Val &y) { return x + y; }
static void assignCombineVal(Val &x, const Val &y) { x = x + y; }
static Val identityVal() { return Val(); }
vector<Val> nodes;
int n;
void init(int n_, const Val &v = Val()) { init(vector<Val>(n_, v)); }
void init(const vector<Val> &u) {
n = 1;
while (n < (int)u.size()) n *= 2;
nodes.resize(n, identityVal());
nodes.insert(nodes.end(), u.begin(), u.end());
nodes.resize(n * 2, identityVal());
for (int i = n - 1; i > 0; --i)
nodes[i] = combineVal(nodes[i * 2], nodes[i * 2 + 1]);
}
Val get(int i) { return nodes[i + n]; }
Val getWhole() const { return nodes[1]; }
Val getRange(int l, int r) const {
Val m = identityVal();
int indices[64];
int k = 0;
for (; l && l + (l & -l) <= r; l += l & -l)
assignCombineVal(m, nodes[(n + l) / (l & -l)]);
for (; l < r; r -= r & -r) indices[k++] = (n + r) / (r & -r) - 1;
while (--k >= 0) assignCombineVal(m, nodes[indices[k]]);
return m;
}
Val getRangeCommutative(int l, int r) const {
Val m = identityVal();
for (; l && l + (l & -l) <= r; l += l & -l)
assignCombineVal(m, nodes[(n + l) / (l & -l)]);
for (; l < r; r -= r & -r)
assignCombineVal(m, nodes[(n + r) / (r & -r) - 1]);
return m;
}
void set(int i, const Val &x) {
i += n;
nodes[i] = x;
for (i >>= 1; i > 0; i >>= 1)
nodes[i] = combineVal(nodes[i * 2], nodes[i * 2 + 1]);
}
};
typedef const char *Pos;
int nNodes;
char expr[400001];
struct Node {
int type;
int parent;
int left, right;
vector<int> children;
};
vector<int> nodeId;
vector<Node> nodes;
vector<int> postOrder;
int getIndex(Pos p) { return (int)(p - expr); }
int newNode(int type) {
nodes.push_back(Node{type, -1, -1, -1, {}});
return nNodes++;
}
int p_expr(Pos &p, int t);
int p_term(Pos &p) {
if (*p == '(') {
int i = getIndex(p);
++p;
int node = p_expr(p, 0);
assert(*p == ')');
int j = getIndex(p);
++p;
nodeId[i] = nodeId[j] = node;
return node;
} else if (isdigit(*p)) {
int left = getIndex(p);
int node = newNode(2);
while (isdigit(*p)) {
nodeId[getIndex(p)] = node;
++p;
}
postOrder.push_back(node);
nodes[node].left = left;
nodes[node].right = getIndex(p);
return node;
} else {
return -1;
}
}
int p_expr(Pos &p, int t) {
int left = getIndex(p);
int x = t == 0 ? p_expr(p, t + 1) : p_term(p);
if (x == -1) return -1;
int node = newNode(t);
nodes[x].parent = node;
nodes[node].children.push_back(x);
while (*p == (t == 0 ? '+' : '*')) {
++p;
int y = t == 0 ? p_expr(p, t + 1) : p_term(p);
assert(y != -1);
nodes[y].parent = node;
nodes[node].children.push_back(y);
}
postOrder.push_back(node);
nodes[node].left = left;
nodes[node].right = getIndex(p);
return node;
}
struct Paren {
int sum, mini;
Paren() : Paren(0) {}
explicit Paren(int x) : sum(x), mini(min(x, 0)) {}
Paren operator+(const Paren &that) const {
Paren res;
res.sum = sum + that.sum;
res.mini = min(mini, sum + that.mini);
return res;
}
};
struct Digits {
ModInt<1000000007> num, pow;
Digits() : num(), pow(1) {}
explicit Digits(int d) : num(d), pow(10) {}
Digits operator+(const Digits &that) const {
Digits res;
res.num = num * that.pow + that.num;
res.pow = pow * that.pow;
return res;
}
};
struct SumProd {
ModInt<1000000007> sum, prod;
SumProd() : sum(), prod(1) {}
explicit SumProd(ModInt<1000000007> x) : sum(x), prod(x) {}
SumProd(ModInt<1000000007> sum, ModInt<1000000007> prod)
: sum(sum), prod(prod) {}
SumProd operator+(const SumProd &that) const {
return SumProd(sum + that.sum, prod * that.prod);
}
};
namespace naive {
bool p_expr(Pos &p, int t, ModInt<1000000007> &res);
bool p_term(Pos &p, ModInt<1000000007> &res) {
if (*p == '(') {
++p;
p_expr(p, 0, res);
if (*p != ')') throw 0;
++p;
return true;
} else if (isdigit(*p)) {
res = ModInt<1000000007>();
while (isdigit(*p)) {
res = res * 10 + (*p - '0');
++p;
}
return true;
} else {
return false;
}
}
bool p_expr(Pos &p, int t, ModInt<1000000007> &res) {
if (!(t == 0 ? p_expr(p, t + 1, res) : p_term(p, res))) return false;
while (*p == (t == 0 ? '+' : '*')) {
++p;
ModInt<1000000007> x;
if (!(t == 0 ? p_expr(p, t + 1, x) : p_term(p, x))) throw 0;
if (t == 0)
res += x;
else
res *= x;
}
return true;
}
} // namespace naive
int main() {
while (~scanf("%s", expr)) {
int len = (int)strlen(expr);
int root;
nNodes = 0;
nodes.clear();
nodeId.assign(len, -1);
postOrder.clear();
{
Pos p = expr;
root = p_expr(p, 0);
assert(root != -1);
assert(*p == '\0');
}
vector<int> t_ord = postOrder, t_parent(nNodes);
reverse(t_ord.begin(), t_ord.end());
for (int(i) = 0; (i) < (int)(nNodes); ++(i)) t_parent[i] = nodes[i].parent;
vector<int> depth(nNodes, -1);
depth[root] = 0;
for (int ix = 1; ix < (int)t_ord.size(); ++ix) {
int i = t_ord[ix], p = t_parent[i];
depth[i] = depth[p] + 1;
}
GetRangeSegmentTree<Paren> segtParen;
vector<Paren> parentheses(len);
for (int(i) = 0; (i) < (int)(len); ++(i))
parentheses[i] = Paren(expr[i] == '(' ? 1 : expr[i] == ')' ? -1 : 0);
segtParen.init(parentheses);
GetRangeSegmentTree<Digits> segtDigits;
vector<Digits> digits(len);
for (int(i) = 0; (i) < (int)(len); ++(i))
if (isdigit(expr[i])) digits[i] = Digits(expr[i] - '0');
segtDigits.init(digits);
vector<ModInt<1000000007>> values(nNodes);
vector<GetRangeSegmentTree<SumProd>> segtSumProds(nNodes);
vector<SumProd> tmpSumProds;
vector<vector<int>> childLefts(nNodes), childRights(nNodes);
for (int ix = (int)t_ord.size() - 1; ix >= 0; --ix) {
int i = t_ord[ix];
auto &n = nodes[i];
int l = n.left, r = n.right;
if (n.type == 2) {
values[i] = segtDigits.getRange(l, r).num;
} else {
childLefts[i].reserve(n.children.size());
childRights[i].reserve(n.children.size());
tmpSumProds.clear();
for (int j : n.children) {
childLefts[i].push_back(nodes[j].left);
childRights[i].push_back(nodes[j].right);
tmpSumProds.emplace_back(values[j]);
}
segtSumProds[i].init(tmpSumProds);
SumProd sp = segtSumProds[i].getWhole();
values[i] = n.type == 0 ? sp.sum : sp.prod;
}
}
auto calc = [&](int node, int l, int r) -> ModInt<1000000007> {
int type = nodes[node].type;
if (type == 2) {
int L = max(l, nodes[node].left);
int R = min(r, nodes[node].right);
return segtDigits.getRange(L, R).num;
} else {
int L = (int)(lower_bound(childLefts[node].begin(),
childLefts[node].end(), l) -
childLefts[node].begin());
int R = (int)(lower_bound(childRights[node].begin(),
childRights[node].end(), r) -
childRights[node].begin());
SumProd sp = segtSumProds[node].getRangeCommutative(L, R);
return type == 0 ? sp.sum : sp.prod;
}
};
auto combine = [&](int node, ModInt<1000000007> x,
ModInt<1000000007> y) -> ModInt<1000000007> {
int type = nodes[node].type;
if (type == 0)
return x + y;
else if (type == 1)
return x * y;
assert(false);
return ModInt<1000000007>();
};
int q;
scanf("%d", &q);
for (int(ii) = 0; (ii) < (int)(q); ++(ii)) {
int l;
int r;
scanf("%d%d", &l, &r), --l;
bool ok = true;
Paren paren = segtParen.getRange(l, r);
ok &= paren.sum == 0;
ok &= paren.mini == 0;
int nodeL = nodeId[l], nodeR = nodeId[r - 1];
ok &= nodeL != -1;
ok &= nodeR != -1;
if (!ok) {
puts("-1");
continue;
}
int x = nodeL, y = nodeR;
ModInt<1000000007> valx = calc(x, l, r), valy = calc(y, l, r);
while (x != y) {
if (t_parent[x] == t_parent[y]) {
int p = t_parent[x];
valx = valy = combine(
p, combine(p, valx, calc(p, nodes[x].right, nodes[y].left)),
valy);
x = y = p;
} else if (depth[x] >= depth[y]) {
int p = t_parent[x];
valx = combine(p, valx, calc(p, nodes[x].right, r));
x = p;
} else {
int p = t_parent[y];
valy = combine(p, calc(p, l, nodes[y].left), valy);
y = p;
}
}
assert(valx.get() == valy.get());
ModInt<1000000007> ans = valx;
printf("%d\n", ans.get());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 4e5 + 7;
const int LOG = 20;
int n;
int match[N], dep[N];
vector<int> PLUS[N], times[N];
char s[N];
int f[N][LOG], g[N][LOG], go[N][LOG];
int suffix[N], prefix[N], nxt_opt[N], bv[N];
void add(int &a, int b) {
if ((a += b) >= MOD) a -= MOD;
}
void mul(int &a, int b) { a = 1LL * a * b % MOD; }
bool is_digit(char c) { return '0' <= c && c <= '9'; }
int power(int a, int n) {
int ret = 1;
for (int i = 1; i <= n; i <<= 1) {
if (n & i) {
mul(ret, a);
}
mul(a, a);
}
return ret;
}
int dfs(int l, int r, int cur) {
if (s[l] == '(' && s[r] == ')' && match[l] == r) {
return bv[l] = bv[r] = dfs(l + 1, r - 1, cur + 1);
} else {
int ret = 0;
int pos =
lower_bound(PLUS[cur].begin(), PLUS[cur].end(), l) - PLUS[cur].begin();
if (pos < PLUS[cur].size() && PLUS[cur][pos] < r) {
ret = 0;
vector<int> tmp;
for (int i = pos; i < PLUS[cur].size() && PLUS[cur][i] < r; i++) {
tmp.push_back(PLUS[cur][i]);
}
assert(tmp.size() > 0);
add(ret, dfs(l, tmp[0] - 1, cur));
for (int i = 0; i + 1 < tmp.size(); i++) {
add(ret, f[tmp[i]][0] = dfs(tmp[i] + 1, tmp[i + 1] - 1, cur));
go[tmp[i]][0] = tmp[i + 1];
}
add(ret, dfs(tmp.back() + 1, r, cur));
return ret;
}
pos = lower_bound(times[cur].begin(), times[cur].end(), l) -
times[cur].begin();
if (pos < times[cur].size() && times[cur][pos] < r) {
ret = 1;
vector<int> tmp;
for (int i = pos; i < times[cur].size() && times[cur][i] < r; i++) {
tmp.push_back(times[cur][i]);
}
assert(tmp.size() > 0);
mul(ret, dfs(l, tmp[0] - 1, cur));
for (int i = 0; i + 1 < tmp.size(); i++) {
mul(ret, g[tmp[i]][0] = dfs(tmp[i] + 1, tmp[i + 1] - 1, cur));
go[tmp[i]][0] = tmp[i + 1];
}
mul(ret, dfs(tmp.back() + 1, r, cur));
return ret;
}
for (int i = l; i <= r; i++) {
assert(is_digit(s[i]));
prefix[i] = (prefix[i - 1] * 10LL + s[i] - '0') % MOD;
nxt_opt[i] = r + 1;
}
for (int i = r, base = 1; i >= l; i--) {
suffix[i] = (suffix[i + 1] + 1LL * (s[i] - '0') * base) % MOD;
base = base * 10LL % MOD;
}
return prefix[r];
}
}
void prepare() {
vector<int> lb;
for (int i = 1, cur_dep = 0; i <= n; i++) {
if (s[i] == '(') {
cur_dep++;
lb.push_back(i);
} else if (s[i] == ')') {
cur_dep--;
match[i] = lb.back();
match[lb.back()] = i;
lb.pop_back();
} else if (s[i] == '+') {
PLUS[cur_dep].push_back(i);
} else if (s[i] == '*') {
times[cur_dep].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
go[i][0] = 0;
}
dfs(1, n, 0);
}
int get_number(int l, int r) {
return 1LL * (suffix[l] + MOD - suffix[r + 1]) % MOD *
power(power(10, nxt_opt[l] - r - 1), MOD - 2) % MOD;
}
int get_first_number(int &l, int r) {
int ret;
if (s[l] == '(') {
ret = bv[l];
l = match[l] + 1;
} else {
assert(is_digit(s[l]));
if (nxt_opt[l] == nxt_opt[r]) {
ret = get_number(l, r);
l = r + 1;
return ret;
}
ret = suffix[l];
l = nxt_opt[l];
}
return ret;
}
int solve(int l, int r) {
if (l > r || l < 1 || r > n) return -1;
if (s[l] == '+' || s[r] == '+' || s[l] == '*' || s[r] == '*' || s[l] == ')') {
return -1;
}
int first = get_first_number(l, r);
if (l == r + 1) return first;
if (l > r || s[l] == ')') return -1;
assert(s[l] != '(');
if (s[l] == '*') {
for (int i = LOG - 1; i >= 0; i--) {
if (go[l][i] != 0 && go[l][i] <= r) {
mul(first, g[l][i]);
l = go[l][i];
}
}
l++;
int second = get_first_number(l, r);
mul(first, second);
if (l == r + 1) {
return first;
}
}
if (l > r || s[l] == ')') return -1;
assert(s[l] == '+');
for (int i = LOG - 1; i >= 0; i--) {
if (go[l][i] != 0 && go[l][i] <= r) {
add(first, f[l][i]);
l = go[l][i];
}
}
l++;
int second = get_first_number(l, r);
if (l == r + 1) return (first + second) % MOD;
if (l > r || s[l] == ')') return -1;
assert(s[l] == '*');
for (int i = LOG - 1; i >= 0; i--) {
if (go[l][i] != 0 && go[l][i] <= r) {
mul(second, g[l][i]);
l = go[l][i];
}
}
l++;
int third = get_first_number(l, r);
mul(second, third);
if (l == r + 1) return (first + second) % MOD;
return -1;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
prepare();
for (int i = 0; i + 1 < LOG; i++) {
for (int j = 1; j <= n; j++) {
go[j][i + 1] = go[go[j][i]][i];
f[j][i + 1] = (f[j][i] + f[go[j][i]][i]) % MOD;
g[j][i + 1] = 1LL * g[j][i] * g[go[j][i]][i] % MOD;
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", solve(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int add(int x, int y) { return (x += y) < 1000000007 ? x : x - 1000000007; }
int mul(int x, int y) { return (int)((long long int)x * y % 1000000007); }
int len;
char s[444444];
int p10[444444];
int chk_id[444444];
int nex_para[444444];
int pre_para[444444];
int nex_add[444444], nex_mul[444444];
int pre_add[444444], pre_mul[444444];
int st_pos[444444], st_chk_id[444444];
int top;
int CHK;
int id[444444];
int typ[444444], T;
vector<int> op[444444];
int szz[444444];
int pos[444444];
int val[444444];
vector<int> seg[444444];
int CUR;
void build(int i, int s, int e) {
if (s == e) {
seg[CUR][i] = op[CUR][s];
return;
}
int m = (s + e) / 2;
build(i * 2, s, m);
build(i * 2 + 1, m + 1, e);
if (typ[CUR] == 2)
seg[CUR][i] = add(seg[CUR][i * 2], seg[CUR][i * 2 + 1]);
else if (typ[CUR] == 3)
seg[CUR][i] = mul(seg[CUR][i * 2], seg[CUR][i * 2 + 1]);
else
seg[CUR][i] = add(mul(seg[CUR][i * 2], p10[e - m]), seg[CUR][i * 2 + 1]);
}
int query(int i, int s, int e, int l, int r) {
if (s == l && e == r) return seg[CUR][i];
int m = (s + e) / 2;
if (r <= m) return query(i * 2, s, m, l, r);
if (l > m) return query(i * 2 + 1, m + 1, e, l, r);
int res1 = query(i * 2, s, m, l, m);
int res2 = query(i * 2 + 1, m + 1, e, m + 1, r);
if (typ[CUR] == 2)
return add(res1, res2);
else if (typ[CUR] == 3)
return mul(res1, res2);
else
return add(mul(res1, p10[r - m]), res2);
}
int analysis(int from, int to) {
int cur = ++T;
if (s[from] == '(' && nex_para[from] == to) {
id[from] = id[to] = cur;
typ[cur] = 1;
return val[cur] = analysis(from + 1, to - 1);
}
if (nex_add[from] != -1 && nex_add[from] <= to) {
typ[cur] = 2;
while (1) {
int nx = nex_add[from];
if (nx == -1 || nx > to) break;
op[cur].push_back(analysis(from, nx - 1));
id[nx] = cur;
pos[nx] = op[cur].size();
from = nx + 1;
}
op[cur].push_back(analysis(from, to));
int sz = szz[cur] = op[cur].size();
seg[cur].resize(sz * 4);
CUR = cur;
build(1, 0, sz - 1);
return seg[cur][1];
}
if (nex_mul[from] != -1 && nex_mul[from] <= to) {
typ[cur] = 3;
while (1) {
int nx = nex_mul[from];
if (nx == -1 || nx > to) break;
op[cur].push_back(analysis(from, nx - 1));
pos[nx] = op[cur].size();
id[nx] = cur;
from = nx + 1;
}
op[cur].push_back(analysis(from, to));
int sz = szz[cur] = op[cur].size();
seg[cur].resize(sz * 4);
CUR = cur;
build(1, 0, sz - 1);
return seg[cur][1];
}
typ[cur] = 4;
for (int i = from; i <= to; i++) {
id[i] = cur;
op[cur].push_back(s[i] - '0');
pos[i] = op[cur].size();
}
int sz = szz[cur] = op[cur].size();
seg[cur].resize(sz * 4);
CUR = cur;
build(1, 0, sz - 1);
return seg[cur][1];
}
int process(int from, int to) {
if (s[from] == '(' && nex_para[from] == to) {
return val[id[from]];
}
if (nex_add[from] != -1 && nex_add[from] <= to) {
int A = nex_add[from];
int B = pre_add[to];
int cur = id[A];
int A_id = pos[A], B_id = pos[B];
CUR = cur;
int zz = A_id != B_id ? query(1, 0, szz[cur] - 1, A_id, B_id - 1) : 0;
zz = add(zz, process(from, A - 1));
zz = add(zz, process(B + 1, to));
return zz;
}
if (nex_mul[from] != -1 && nex_mul[from] <= to) {
int A = nex_mul[from];
int B = pre_mul[to];
int cur = id[A];
int A_id = pos[A], B_id = pos[B];
CUR = cur;
int zz = A_id != B_id ? query(1, 0, szz[cur] - 1, A_id, B_id - 1) : 1;
zz = mul(zz, process(from, A - 1));
zz = mul(zz, process(B + 1, to));
return zz;
}
int cur = id[from];
CUR = cur;
return query(1, 0, szz[cur] - 1, pos[from] - 1, pos[to] - 1);
}
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
s[0] = '(';
s[len + 1] = ')';
len += 2;
top = 0;
for (int i = 0; i < len; i++)
if (s[i] == '(') {
st_pos[top] = i;
st_chk_id[top] = ++CHK;
top++;
} else if (s[i] == ')') {
int from = st_pos[top - 1] + 1, to = i - 1, chk = st_chk_id[top - 1];
int add = -1, mul = -1;
for (int j = from; j <= to; j++) {
pre_add[j] = add;
pre_mul[j] = mul;
chk_id[j] = chk;
if (s[j] == '(') {
j = nex_para[j];
pre_add[j] = add;
pre_mul[j] = mul;
chk_id[j] = chk;
} else if (s[j] == '+')
add = j;
else if (s[j] == '*')
mul = j;
}
add = mul = -1;
for (int j = to; j >= from; j--) {
nex_add[j] = add;
nex_mul[j] = mul;
if (s[j] == ')') {
j = pre_para[j];
nex_add[j] = add;
nex_mul[j] = mul;
} else if (s[j] == '+')
add = j;
else if (s[j] == '*')
mul = j;
}
nex_para[st_pos[top - 1]] = i;
pre_para[i] = st_pos[top - 1];
--top;
}
p10[0] = 1;
for (int i = 1; i <= len; i++) p10[i] = mul(p10[i - 1], 10);
analysis(0, len - 1);
int q, from, to;
for (scanf("%d", &q); q--;) {
scanf("%d%d", &from, &to);
if (chk_id[from] == chk_id[to] && (isdigit(s[from]) || s[from] == '(') &&
(isdigit(s[to]) || s[to] == ')')) {
printf("%d\n", process(from, to));
} else
puts("-1");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int jt = 1000000007, maxn = 1 << 19;
void inline add(int &a, int b) {
a += b - jt;
a += (a >> 31) & jt;
}
void inline sub(int &a, int b) {
a -= b;
a += (a >> 31) & jt;
}
void inline mul(int &a, int b) { a = (long long)a * b % jt; }
int inline Add(int a, int b) { return a + b >= jt ? a + b - jt : a + b; }
int inline Sub(int a, int b) { return a - b < 0 ? a - b + jt : a - b; }
int inline Mul(int a, int b) { return (long long)a * b % jt; }
struct NumberGetter {
int val[maxn], mii[maxn];
void inline init(char s[], int n) {
val[0] = 0;
mii[0] = 1;
for (int i = 1; i <= (n); ++i) {
val[i] = Add(Mul(val[i - 1], 10), isdigit(s[i]) ? s[i] - '0' : 0);
mii[i] = Mul(mii[i - 1], 10);
}
}
int inline query(int l, int r) {
return Sub(val[r], Mul(val[l - 1], mii[r - l + 1]));
}
} Ng;
struct Segtree {
vector<int> dt;
int N;
void init(vector<int> s) {
N = 1;
while (N <= ((int)(s).size())) N <<= 1;
dt.resize(N << 1);
for (int i = 0; i < (((int)(s).size())); ++i) dt[i + N] = s[i];
for (int i = (N - 1); (-1) > 0 ? i <= (0) : i >= (0); i += (-1))
dt[i] = Mul(dt[i << 1], dt[i << 1 | 1]);
}
int query(int l, int r) {
int res = 1;
for (l += N, r += N + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) mul(res, dt[l++]);
if (r & 1) mul(res, dt[--r]);
}
return res;
}
};
struct Multiply {
int l, r;
vector<int> brs, bgs;
vector<int> pre, suf;
Segtree seg;
int getpre(int);
int getsuf(int);
int getval(int, int);
} Ms[maxn];
struct Bracket {
int l, r;
bool single;
vector<int> mls, bgs;
vector<int> pre;
int getpre(int);
int getsuf(int);
int getval(int, int);
Bracket(int l = 0, int r = 0, int single = 0) : l(l), r(r), single(single) {}
} Bs[maxn];
int inline Bracket::getpre(int len) {
if (len < 0) return 1;
if (single) return Ng.query(l, l + len - 1);
if (len == r - l + 1) return pre.back();
return 1;
}
int inline Bracket::getsuf(int len) {
if (len < 0) return 1;
if (single) return Ng.query(r - len + 1, r);
if (len == r - l + 1) return pre.back();
return 1;
}
int inline Multiply::getpre(int len) {
if (len < 0) return 0;
int id =
upper_bound((bgs).begin(), (bgs).end(), l + len - 1) - bgs.begin() - 1;
if (Bs[brs[id]].r == l + len - 1) return pre[id + 1];
return Mul(pre[id], Bs[brs[id]].getpre(l + len - 1 - Bs[brs[id]].l + 1));
}
int inline Multiply::getsuf(int len) {
if (len < 0) return 0;
int id =
upper_bound((bgs).begin(), (bgs).end(), r - len + 1) - bgs.begin() - 1;
if (Bs[brs[id]].l == r - len + 1) return suf[id];
return Mul(suf[id + 1],
Bs[brs[id]].getsuf(Bs[brs[id]].r - (r - len + 1) + 1));
}
int inline Bracket::getval(int l, int r) {
if (single) return Ng.query(l, r);
if (l < bgs[0]) ++l;
if (r == this->r) --r;
int id1 = lower_bound((bgs).begin(), (bgs).end(), l) - bgs.begin();
int id2 = upper_bound((bgs).begin(), (bgs).end(), r) - bgs.begin() - 1;
if (id1 > id2) return Ms[mls[id2]].getval(l, r);
return Add(Ms[mls[id1]].l == l
? 0
: Ms[mls[id1 - 1]].getsuf(Ms[mls[id1 - 1]].r - l + 1),
Add(Sub(pre[id2], pre[id1]),
id2 < ((int)(mls).size())
? Ms[mls[id2]].getpre(r - Ms[mls[id2]].l + 1)
: 0));
}
int inline Multiply::getval(int l, int r) {
int id1 = lower_bound((bgs).begin(), (bgs).end(), l) - bgs.begin();
int id2 = upper_bound((bgs).begin(), (bgs).end(), r) - bgs.begin() - 1;
if (id1 > id2) return Bs[brs[id2]].getval(l, r);
return Mul(Bs[brs[id1]].l == l
? 1
: Bs[brs[id1 - 1]].getsuf(Bs[brs[id1 - 1]].r - l + 1),
Mul(seg.query(id1, id2 - 1),
id2 < ((int)(brs).size())
? Bs[brs[id2]].getpre(r - Bs[brs[id2]].l + 1)
: 1));
}
struct Segtree3 {
pair<int, int> dt[maxn << 1];
void init() {
for (int i = 0; i < (maxn << 1); ++i) dt[i].first = Inf;
}
void set(int a, pair<int, int> x) {
a += maxn;
dt[a] = x;
while (a >>= 1) dt[a] = min(dt[a << 1], dt[a << 1 | 1]);
}
pair<int, int> query(int l, int r) {
pair<int, int> res(Inf, 0);
for (l += maxn, r += maxn + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, dt[l++]);
if (r & 1) res = min(res, dt[--r]);
}
return res;
}
} sgg;
int N, Q;
char s[maxn];
int mcs, bcs;
int parseBracket(int &, int);
int parseMulti(int &ptr, int dep, int uid) {
int id = ++mcs;
Ms[id].l = ptr;
Ms[id].pre.push_back(1);
vector<int> val;
while (1) {
Ms[id].bgs.push_back(ptr);
sgg.set(ptr, make_pair(dep, uid));
int nid = parseBracket(ptr, dep + 1);
Ms[id].brs.push_back(nid);
Ms[id].pre.push_back(Mul(Ms[id].pre.back(), Bs[nid].pre.back()));
val.push_back(Bs[nid].pre.back());
if (s[ptr] != '*') break;
sgg.set(ptr, make_pair(dep, uid));
++ptr;
}
Ms[id].suf.resize(((int)(Ms[id].pre).size()));
Ms[id].suf.back() = 1;
for (int i = (((int)(Ms[id].brs).size()) - 1); (-1) > 0 ? i <= (0) : i >= (0);
i += (-1))
Ms[id].suf[i] = Mul(Ms[id].suf[i + 1], Bs[Ms[id].brs[i]].pre.back());
Ms[id].seg.init(val);
Ms[id].r = ptr - 1;
return id;
}
int parseBracket(int &ptr, int dep) {
if (s[ptr] != '(') {
Bs[++bcs].single = 1;
Bs[bcs].l = ptr;
while (isdigit(s[ptr])) sgg.set(ptr, make_pair(dep, bcs)), ++ptr;
Bs[bcs].r = ptr - 1;
Bs[bcs].pre.push_back(Ng.query(Bs[bcs].l, Bs[bcs].r));
return bcs;
}
int id = ++bcs;
Bs[id].l = ptr;
++ptr;
Bs[id].pre.push_back(0);
while (1) {
Bs[id].bgs.push_back(ptr);
int nid = parseMulti(ptr, dep, id);
Bs[id].mls.push_back(nid);
Bs[id].pre.push_back(Add(Bs[id].pre.back(), Ms[nid].pre.back()));
if (s[ptr] == ')') break;
sgg.set(ptr, make_pair(dep, id));
++ptr;
}
Bs[id].r = ptr++;
return id;
}
struct Segtree2 {
pair<int, int> dt[maxn << 1];
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
return make_pair(a.first + b.first, min(a.second, a.first + b.second));
}
void set(int a, pair<int, int> x) {
a += maxn;
dt[a] = x;
while (a >>= 1) dt[a] = merge(dt[a << 1], dt[a << 1 | 1]);
}
pair<int, int> query(int l, int r) {
pair<int, int> lres(0, 0), rres(0, 0);
for (l += maxn, r += maxn + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) lres = merge(lres, dt[l++]);
if (r & 1) rres = merge(dt[--r], rres);
}
return merge(lres, rres);
}
} seg;
int rt;
int main() {
scanf("%s", s + 1);
N = strlen(s + 1) + 2;
scanf("%d", &Q);
s[0] = '(';
s[N - 1] = ')';
Ng.init(s, N - 2);
int ptr = 0;
sgg.init();
rt = parseBracket(ptr, 0);
for (int i = 1; i <= (N); ++i) {
if (s[i] == '(') seg.set(i, make_pair(1, 0));
if (s[i] == ')') seg.set(i, make_pair(-1, -1));
}
int tms = 0;
while (Q--) {
int l, r;
scanf("%d%d", &l, &r);
if (s[l] == '+' || s[l] == '*') {
puts("-1");
continue;
}
if (s[r] == '+' || s[r] == '*') {
puts("-1");
continue;
}
auto bbr = seg.query(l, r);
if (bbr.second < 0 || bbr.first > 0) {
puts("-1");
continue;
}
int khid = sgg.query(l, r).second;
tms -= clock();
printf("%d\n", Bs[khid].getval(l, r));
tms += clock();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int jt = 1000000007, maxn = 1 << 19;
void inline add(int &a, int b) {
a += b - jt;
a += (a >> 31) & jt;
}
void inline sub(int &a, int b) {
a -= b;
a += (a >> 31) & jt;
}
void inline mul(int &a, int b) { a = (long long)a * b % jt; }
int inline Add(int a, int b) { return a + b >= jt ? a + b - jt : a + b; }
int inline Sub(int a, int b) { return a - b < 0 ? a - b + jt : a - b; }
int inline Mul(int a, int b) { return (long long)a * b % jt; }
struct NumberGetter {
int val[maxn], mii[maxn];
void inline init(char s[], int n) {
val[0] = 0;
mii[0] = 1;
for (int i = 1; i <= (n); ++i) {
val[i] = Add(Mul(val[i - 1], 10), isdigit(s[i]) ? s[i] - '0' : 0);
mii[i] = Mul(mii[i - 1], 10);
}
}
int inline query(int l, int r) {
return Sub(val[r], Mul(val[l - 1], mii[r - l + 1]));
}
} Ng;
struct Segtree {
vector<int> dt;
int N;
void init(vector<int> s) {
N = 1;
while (N <= ((int)(s).size())) N <<= 1;
dt.resize(N << 1);
for (int i = 0; i < (((int)(s).size())); ++i) dt[i + N] = s[i];
for (int i = (N - 1); (-1) > 0 ? i <= (0) : i >= (0); i += (-1))
dt[i] = Mul(dt[i << 1], dt[i << 1 | 1]);
}
int query(int l, int r) {
int res = 1;
for (l += N, r += N + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) mul(res, dt[l++]);
if (r & 1) mul(res, dt[--r]);
}
return res;
}
};
struct Multiply {
int l, r;
vector<int> brs, bgs;
vector<int> pre, suf;
Segtree seg;
int getpre(int);
int getsuf(int);
int getval(int, int);
} Ms[maxn];
struct Bracket {
int l, r;
bool single;
vector<int> mls, bgs;
vector<int> pre;
int getpre(int);
int getsuf(int);
int getval(int, int);
Bracket(int l = 0, int r = 0, int single = 0) : l(l), r(r), single(single) {}
} Bs[maxn];
int inline Bracket::getpre(int len) {
if (len < 0) return 1;
if (single) return Ng.query(l, l + len - 1);
if (len == r - l + 1) return pre.back();
return 1;
}
int inline Bracket::getsuf(int len) {
if (len < 0) return 1;
if (single) return Ng.query(r - len + 1, r);
if (len == r - l + 1) return pre.back();
return 1;
}
int inline Multiply::getpre(int len) {
if (len < 0) return 0;
int id =
upper_bound((bgs).begin(), (bgs).end(), l + len - 1) - bgs.begin() - 1;
if (Bs[brs[id]].r == l + len - 1) return pre[id + 1];
return Mul(pre[id], Bs[brs[id]].getpre(l + len - 1 - Bs[brs[id]].l + 1));
}
int inline Multiply::getsuf(int len) {
if (len < 0) return 0;
int id =
upper_bound((bgs).begin(), (bgs).end(), r - len + 1) - bgs.begin() - 1;
if (Bs[brs[id]].l == r - len + 1) return suf[id];
return Mul(suf[id + 1],
Bs[brs[id]].getsuf(Bs[brs[id]].r - (r - len + 1) + 1));
}
int inline Bracket::getval(int l, int r) {
if (single) return Ng.query(l, r);
if (l < bgs[0]) ++l;
if (r == this->r) --r;
int id1 = lower_bound((bgs).begin(), (bgs).end(), l) - bgs.begin();
int id2 = upper_bound((bgs).begin(), (bgs).end(), r) - bgs.begin() - 1;
if (id1 > id2) return Ms[mls[id2]].getval(l, r);
return Add(Ms[mls[id1]].l == l
? 0
: Ms[mls[id1 - 1]].getsuf(Ms[mls[id1 - 1]].r - l + 1),
Add(Sub(pre[id2], pre[id1]),
id2 < ((int)(mls).size())
? Ms[mls[id2]].getpre(r - Ms[mls[id2]].l + 1)
: 0));
}
int inline Multiply::getval(int l, int r) {
int id1 = lower_bound((bgs).begin(), (bgs).end(), l) - bgs.begin();
int id2 = upper_bound((bgs).begin(), (bgs).end(), r) - bgs.begin() - 1;
if (id1 > id2) return Bs[brs[id2]].getval(l, r);
return Mul(Bs[brs[id1]].l == l
? 1
: Bs[brs[id1 - 1]].getsuf(Bs[brs[id1 - 1]].r - l + 1),
Mul(seg.query(id1, id2 - 1),
id2 < ((int)(brs).size())
? Bs[brs[id2]].getpre(r - Bs[brs[id2]].l + 1)
: 1));
}
struct Segtree3 {
pair<int, int> dt[maxn << 1];
void init() {
for (int i = 0; i < (maxn << 1); ++i) dt[i].first = Inf;
}
void set(int a, pair<int, int> x) {
a += maxn;
dt[a] = x;
while (a >>= 1) dt[a] = min(dt[a << 1], dt[a << 1 | 1]);
}
pair<int, int> query(int l, int r) {
pair<int, int> res(Inf, 0);
for (l += maxn, r += maxn + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, dt[l++]);
if (r & 1) res = min(res, dt[--r]);
}
return res;
}
} sgg;
int N, Q;
char s[maxn];
int mcs, bcs;
int parseBracket(int &, int);
int parseMulti(int &ptr, int dep, int uid) {
int id = ++mcs;
Ms[id].l = ptr;
Ms[id].pre.push_back(1);
vector<int> val;
while (1) {
Ms[id].bgs.push_back(ptr);
sgg.set(ptr, make_pair(dep, uid));
int nid = parseBracket(ptr, dep + 1);
Ms[id].brs.push_back(nid);
Ms[id].pre.push_back(Mul(Ms[id].pre.back(), Bs[nid].pre.back()));
val.push_back(Bs[nid].pre.back());
if (s[ptr] != '*') break;
sgg.set(ptr, make_pair(dep, uid));
++ptr;
}
Ms[id].suf.resize(((int)(Ms[id].pre).size()));
Ms[id].suf.back() = 1;
for (int i = (((int)(Ms[id].brs).size()) - 1); (-1) > 0 ? i <= (0) : i >= (0);
i += (-1))
Ms[id].suf[i] = Mul(Ms[id].suf[i + 1], Bs[Ms[id].brs[i]].pre.back());
Ms[id].seg.init(val);
Ms[id].r = ptr - 1;
return id;
}
int parseBracket(int &ptr, int dep) {
if (s[ptr] != '(') {
Bs[++bcs].single = 1;
Bs[bcs].l = ptr;
while (isdigit(s[ptr])) sgg.set(ptr, make_pair(dep, bcs)), ++ptr;
Bs[bcs].r = ptr - 1;
Bs[bcs].pre.push_back(Ng.query(Bs[bcs].l, Bs[bcs].r));
return bcs;
}
int id = ++bcs;
Bs[id].l = ptr;
++ptr;
Bs[id].pre.push_back(0);
while (1) {
Bs[id].bgs.push_back(ptr);
int nid = parseMulti(ptr, dep, id);
Bs[id].mls.push_back(nid);
Bs[id].pre.push_back(Add(Bs[id].pre.back(), Ms[nid].pre.back()));
if (s[ptr] == ')') break;
sgg.set(ptr, make_pair(dep, id));
++ptr;
}
Bs[id].r = ptr++;
return id;
}
struct Segtree2 {
pair<int, int> dt[maxn << 1];
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
return make_pair(a.first + b.first, min(a.second, a.first + b.second));
}
void set(int a, pair<int, int> x) {
a += maxn;
dt[a] = x;
while (a >>= 1) dt[a] = merge(dt[a << 1], dt[a << 1 | 1]);
}
pair<int, int> query(int l, int r) {
pair<int, int> lres(0, 0), rres(0, 0);
for (l += maxn, r += maxn + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) lres = merge(lres, dt[l++]);
if (r & 1) rres = merge(dt[--r], rres);
}
return merge(lres, rres);
}
} seg;
int rt;
int main() {
scanf("%s", s + 1);
N = strlen(s + 1) + 2;
scanf("%d", &Q);
s[0] = '(';
s[N - 1] = ')';
Ng.init(s, N - 2);
int ptr = 0;
sgg.init();
rt = parseBracket(ptr, 0);
for (int i = 1; i <= (N); ++i) {
if (s[i] == '(') seg.set(i, make_pair(1, 0));
if (s[i] == ')') seg.set(i, make_pair(-1, -1));
}
int tms = 0;
while (Q--) {
int l, r;
scanf("%d%d", &l, &r);
if (s[l] == '+' || s[l] == '*') {
puts("-1");
continue;
}
if (s[r] == '+' || s[r] == '*') {
puts("-1");
continue;
}
auto bbr = seg.query(l, r);
if (bbr.second < 0 || bbr.first > 0) {
puts("-1");
continue;
}
int khid = sgg.query(l, r).second;
tms -= clock();
printf("%d\n", Bs[khid].getval(l, r));
tms += clock();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
constexpr int mod = 1000 * 1000 * 1000 + 7;
ll Add(ll a, ll b) { return (a + b) % mod; }
ll Mul(ll a, ll b) { return (a * b) % mod; }
ll pot10[1000 * 1000 + 5];
char buf[1000 * 1000 + 5];
int position = 1;
char Read() { return buf[position++]; }
int Position() { return position; }
void PutBack() { position--; }
struct Token;
Token* token[1000 * 1000 + 5];
struct Liczba {
ll value;
int len;
Liczba operator/(const Liczba& l) const {
Liczba nowa;
nowa.value = Add(Mul(value, pot10[l.len]), l.value);
nowa.len = len + l.len;
return nowa;
}
};
struct Value {
ll lewo, sum, prawo;
ll cale;
static Value MakeCale(ll c) { return Value{0ll, 0ll, 0ll, c}; }
static Value MakeRozbite(ll l, ll s, ll p) { return Value{l, s, p, -2ll}; }
ll Get() const {
if (Cale())
return cale;
else
return Add(lewo, Add(sum, prawo));
}
bool Cale() const { return cale != -2ll; }
Value operator+(const Value& v) const {
if (Cale() and v.Cale()) {
return MakeRozbite(Get(), 0ll, v.Get());
} else if (Cale()) {
return MakeRozbite(Get(), v.lewo + v.sum, v.prawo);
} else if (v.Cale()) {
return MakeRozbite(lewo, sum + prawo, v.Get());
} else {
return MakeRozbite(lewo, sum + prawo + v.lewo + v.sum, v.prawo);
}
}
Value operator*(const Value& v) const {
if (Cale() and v.Cale()) {
return MakeCale(Mul(Get(), v.Get()));
} else if (Cale()) {
return MakeRozbite(Mul(Get(), v.lewo), v.sum, v.prawo);
} else if (v.Cale()) {
return MakeRozbite(lewo, sum, Mul(prawo, v.Get()));
} else {
return MakeRozbite(lewo, sum + Mul(prawo, v.lewo) + v.sum, v.prawo);
}
}
};
struct Token {
vector<pair<char, Token>> tokens;
int a, b;
ll val = -1ll;
int n2;
vector<Value> drz;
vector<Liczba> drz2;
Token* ojciec = nullptr;
bool JestLiczba() const { return tokens.empty(); }
Liczba LiczLiczba_(int w, int a, int b, int p, int k) {
if (b < p or k < a) return Liczba{0, 0};
if (a <= p and k <= b) {
return drz2[w];
}
return LiczLiczba_(w * 2, a, b, p, (p + k) / 2) /
LiczLiczba_(w * 2 + 1, a, b, (p + k + 1) / 2, k);
}
ll LiczLiczba(int p, int k) {
assert(p <= k);
assert(a <= p and k <= b);
return LiczLiczba_(1, p - a, k - a, 0, n2 - 1).value;
}
void CountPositions(Token* ojc) {
if (JestLiczba()) {
for (int i = a; i <= b; i++) {
token[i] = this;
}
} else {
token[a] = this;
token[b] = this;
}
ojciec = ojc;
for (auto& t : tokens) {
t.second.CountPositions(this);
}
}
void Wypisz() {
if (tokens.empty()) {
printf("{%p}Liczba(%lld [%d:%d])", this, val, a, b);
} else {
printf("{%p}Ciag([%d:%d], val = %lld,", this, a, b, Wartosc());
for (auto& t : tokens) {
printf(" %c ", t.first);
t.second.Wypisz();
}
printf(")");
}
}
int ZnajdzPocz(int pos) {
int a = 0, b = (int)tokens.size() - 1, c;
while (a <= b) {
c = (a + b) / 2;
const Token& t = tokens[c].second;
if (t.JestLiczba() and t.a <= pos and pos <= t.b) {
return c;
} else if (t.a == pos) {
return c;
} else if (pos < t.a) {
b = c - 1;
} else {
a = c + 1;
}
}
return -1;
}
int ZnajdzKon(int pos) {
int a = 0, b = (int)tokens.size() - 1, c;
while (a <= b) {
c = (a + b) / 2;
const Token& t = tokens[c].second;
if (t.JestLiczba() and t.a <= pos and pos <= t.b) {
return c;
} else if (t.b == pos) {
return c;
} else if (pos < t.b) {
b = c - 1;
} else {
a = c + 1;
}
}
return -1;
}
Value Wylicz_(int pos, int a, int b) {
Token& t = tokens[pos].second;
if (t.JestLiczba()) {
return Value::MakeCale(t.LiczLiczba(max(a, t.a), min(b, t.b)));
} else {
assert(a <= t.a and t.b <= b);
return Value::MakeCale(t.Wartosc());
}
}
Value Wylicz(int pos, int a, int b) {
const Value& val = Wylicz_(pos, a, b);
return val;
}
Value Zapytanie(int a, int b) {
assert(!tokens.empty());
const int pocz = ZnajdzPocz(a);
const int kon = ZnajdzKon(b);
if (pocz < 0 or kon < 0) return Value::MakeCale(-1);
if (pocz > kon) return Value::MakeCale(-1);
if (pocz == kon) {
if (tokens[pocz].second.JestLiczba()) {
return Value::MakeCale(tokens[pocz].second.LiczLiczba(a, b));
} else {
return Value::MakeCale(tokens[pocz].second.Wartosc());
}
} else if (pocz + 1 == kon) {
if (tokens[kon].first == '+') {
return Wylicz(pocz, a, b) + Wylicz(kon, a, b);
} else {
return Wylicz(pocz, a, b) * Wylicz(kon, a, b);
}
}
Value lewo = (tokens[pocz + 1].first == '+')
? (Wylicz(pocz, a, b) + Licz(pocz + 1, kon - 1))
: (Wylicz(pocz, a, b) * Licz(pocz + 1, kon - 1));
if (tokens[kon].first == '+') {
return lewo + Wylicz(kon, a, b);
} else {
return lewo * Wylicz(kon, a, b);
}
}
ll Wartosc() {
if (val != -1ll) {
return val;
}
Build();
return val = Licz(0, (int)tokens.size() - 1).Get();
}
Value Licz_(int w, int a, int b, int p, int k) {
if (b < p or k < a) assert(false);
if (a <= p and k <= b) {
return drz[w];
}
const int s = (p + k + 1) / 2;
if (a < s and s <= b) {
if (tokens[s].first == '+') {
return Licz_(w * 2, a, b, p, s - 1) + Licz_(w * 2 + 1, a, b, s, k);
} else {
return Licz_(w * 2, a, b, p, s - 1) * Licz_(w * 2 + 1, a, b, s, k);
}
} else if (a < s) {
return Licz_(w * 2, a, b, p, s - 1);
} else {
return Licz_(w * 2 + 1, a, b, s, k);
}
}
Value Licz(int a, int b) {
Build();
return Licz_(1, a, b, 0, n2 - 1);
}
void Przelicz(int w, int p, int k) {
if (p == k) {
if (k < (int)tokens.size()) {
drz[w] = Value::MakeCale(tokens[k].second.Wartosc());
} else {
drz[w] = Value::MakeCale(0);
}
return;
}
const int s = (p + k + 1) / 2;
Przelicz(w * 2, p, s - 1);
Przelicz(w * 2 + 1, s, k);
char c = '?';
if (s < (int)tokens.size()) {
c = tokens[s].first;
} else {
c = '+';
}
if (c == '+') {
drz[w] = drz[w * 2] + drz[w * 2 + 1];
} else {
drz[w] = drz[w * 2] * drz[w * 2 + 1];
}
}
void Build() {
if (!drz.empty()) return;
n2 = 1;
while (n2 < (int)tokens.size()) {
n2 *= 2;
}
drz.resize(n2 * 2);
Przelicz(1, 0, n2 - 1);
}
void ReadInt() {
vector<int> cyfry;
a = Position();
val = 0ll;
while (true) {
const char c = Read();
if ('0' <= c and c <= '9') {
cyfry.push_back(c - '0');
val = Add(Mul(val, 10), c - '0');
} else {
PutBack();
break;
}
}
b = Position() - 1;
n2 = 1;
while (n2 < (int)cyfry.size()) {
n2 *= 2;
}
drz2.resize(n2 * 2);
for (int i = 0; i < (int)cyfry.size(); i++) {
drz2[n2 + i] = Liczba{cyfry[i], 1};
}
for (int i = (int)cyfry.size(); i < n2; i++) {
drz2[n2 + i] = Liczba{0, 0};
}
for (int i = n2 - 1; i >= 1; i--) {
drz2[i] = drz2[i * 2] / drz2[i * 2 + 1];
}
}
void Parse() {
a = Position() - 1;
char last = '?';
while (true) {
const char c = Read();
switch (c) {
case ')':
b = position - 1;
return;
case '+':
case '*':
last = c;
break;
case '(':
tokens.emplace_back();
tokens.back().first = last;
tokens.back().second.Parse();
break;
default:
assert('0' <= c and c <= '9');
tokens.emplace_back();
tokens.back().first = last;
PutBack();
tokens.back().second.ReadInt();
}
}
}
};
ll zapytanie(int a, int b) {
if (token[a] == nullptr or token[b] == nullptr or
token[a]->ojciec == nullptr or token[a]->ojciec != token[b]->ojciec) {
return -1;
}
return token[a]->ojciec->Zapytanie(a, b).Get();
}
int main() {
pot10[0] = 1ll;
for (int i = 1; i < 1000 * 1000; i++) {
pot10[i] = Mul(pot10[i - 1], 10);
}
scanf("%[^\n]\n", buf + 1);
buf[0] = '(';
buf[strlen(buf) + 1] = '\0';
buf[strlen(buf)] = ')';
Token token;
token.Parse();
token.CountPositions(nullptr);
int m;
scanf("%d", &m);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
printf("%lld\n", zapytanie(a, b));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int iv10;
int ip10[500006];
int n, q;
int Pow(int x, int a) {
int ret = 1;
while (a) {
if (a & 1) ret = ret * 1ll * x % P;
x = x * 1ll * x % P, a >>= 1;
}
return ret;
}
int rd() {
char ch = getchar();
int ret = 0;
while (ch > '9' || ch < '0') ch = getchar();
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret;
}
char S[500006];
int bel[500006], lk[500006];
struct sgt {
struct node {
int l, r;
node operator+(const node a) {
return (node){a.l - min(a.l, r) + l, r - min(a.l, r) + a.r};
}
} T[500006 << 2];
void build(int rt, int l, int r) {
if (l == r) {
if (S[l] == '(')
T[rt].r = 1;
else if (S[l] == ')')
T[rt].l = 1;
return;
}
int m = l + r >> 1;
build(rt << 1, l, m), build(rt << 1 | 1, m + 1, r);
T[rt] = T[rt << 1] + T[rt << 1 | 1];
}
node que(int rt, int l, int r, int L, int R) {
if (L <= l && R >= r) return T[rt];
int m = l + r >> 1;
node re = (node){0, 0};
if (L <= m) re = re + que(rt << 1, l, m, L, R);
if (R > m) re = re + que(rt << 1 | 1, m + 1, r, L, R);
return re;
}
bool que(int l, int r) {
node re = que(1, 1, n, l, r);
return !re.l && !re.r;
}
} T;
int solve(int l, int r);
int cnn, bn[500006];
struct segnum {
int l, r, v, dx;
vector<int> s;
int build() {
if (S[l] == '(') {
bn[l] = bn[r] = cnn;
return v = solve(l + 1, r - 1);
}
int pw = 1;
for (int j = (1), jend = (r - l + 1); j <= jend; ++j) pw = pw * 10ll % P;
for (int i = (l), iend = (r); i <= iend; ++i) bn[i] = dx;
for (int i = (0), iend = (r - l); i <= iend; ++i) {
pw = pw * 1ll * iv10 % P;
s.push_back((S[i + l] - '0') * 1ll * pw % P);
if (s.size() > 1) s[s.size() - 1] = (s.back() + s[s.size() - 2]) % P;
}
return v = s.back();
}
int gv(int L, int R) {
if (L == l && R == r) return v;
int x = (s[R - l] + P - (L == l ? 0 : s[L - 1 - l])) % P;
return x * 1ll * ip10[r - R] % P;
}
} N[500006];
int bm[500006], cnm;
struct segmul {
int l, r, v, dx;
vector<int> nums, pm, c0;
int build() {
int pl = l;
for (int i = (l), iend = (r); i <= iend; ++i) {
if (S[i] == '*') {
++cnn;
N[cnn].l = pl, N[cnn].r = i - 1, N[cnn].dx = cnn;
nums.push_back(cnn);
int v = N[cnn].build();
pm.push_back(v == 0 ? 1 : v), c0.push_back(v == 0);
pl = i + 1;
}
bm[i] = dx;
if (S[i] == '(') i = lk[i] - 1;
}
++cnn, N[cnn].l = pl, N[cnn].r = r, N[cnn].dx = cnn;
nums.push_back(cnn);
int v = N[cnn].build();
pm.push_back(v == 0 ? 1 : v), c0.push_back(v == 0);
for (int i = (1), iend = (pm.size() - 1); i <= iend; ++i) {
pm[i] = pm[i - 1] * 1ll * pm[i] % P;
c0[i] += c0[i - 1];
}
return c0.back() ? 0 : pm.back();
}
int gv(int L, int R) {
int tl = bn[L], tr = bn[R];
if (tl == tr) return N[tl].gv(L, R);
int re = N[tl].gv(L, N[tl].r) * 1ll * N[tr].gv(N[tr].l, R) % P;
tl = upper_bound((nums).begin(), (nums).end(), tl) - nums.begin(),
tr = lower_bound((nums).begin(), (nums).end(), tr) - nums.begin() - 1;
if (tr >= tl && c0[tr]) return 0;
return pm[tr] * 1ll * (tl == 0 ? 1 : Pow(pm[tl - 1], P - 2)) % P * re % P;
}
} M[500006];
int cna;
struct segadd {
int l, r, v;
vector<int> ms, ps;
int build() {
int pl = l;
for (int i = (l), iend = (r); i <= iend; ++i) {
if (S[i] == '+') {
++cnm;
M[cnm].l = pl, M[cnm].r = i - 1, M[cnm].dx = cnm;
ms.push_back(cnm), ps.push_back(M[cnm].build());
pl = i + 1;
}
if (S[i] == '(') i = lk[i] - 1;
}
++cnm, M[cnm].l = pl, M[cnm].r = r, M[cnm].dx = cnm;
ms.push_back(cnm), ps.push_back(M[cnm].build());
for (int i = (1), iend = (ps.size() - 1); i <= iend; ++i)
ps[i] = (ps[i - 1] + ps[i]) % P;
return ps.back();
}
int gv(int L, int R) {
int tl = bm[L], tr = bm[R];
if (tl == tr) return M[tl].gv(L, R);
int res = M[tl].gv(L, M[tl].r) + M[tr].gv(M[tr].l, R);
tl = upper_bound((ms).begin(), (ms).end(), tl) - ms.begin(),
tr = lower_bound((ms).begin(), (ms).end(), tr) - ms.begin() - 1;
return (1ll * res + ps[tr] + P - ps[tl - 1]) % P;
}
} W[500006];
int solve(int l, int r) {
W[l - 1].l = l, W[l - 1].r = r;
return W[l - 1].build();
}
void solve() {
iv10 = Pow(10, P - 2);
ip10[0] = 1;
scanf("%s", S + 1);
n = strlen(S + 1);
for (int i = (1), iend = (n); i <= iend; ++i)
ip10[i] = ip10[i - 1] * 1ll * iv10 % P;
cin >> q;
vector<int> pt;
pt.push_back(0);
for (int i = (1), iend = (n); i <= iend; ++i) {
if (S[i] == '(')
bel[i] = pt.back(), pt.push_back(i);
else {
if (S[i] == ')') lk[pt.back()] = i, pt.pop_back();
bel[i] = pt.back();
}
}
T.build(1, 1, n);
solve(1, n);
for (int i = (1), iend = (q); i <= iend; ++i) {
int l, r;
l = rd(), r = rd();
if (S[l] == '+' || S[l] == '*' || S[r] == '+' || S[r] == '*') {
puts("-1");
continue;
}
if (!T.que(l, r)) {
puts("-1");
continue;
}
int x = bel[l];
printf("%d\n", W[x].gv(l, r));
}
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 4e5 + 7;
const int LOG = 20;
int n;
int match[N], dep[N];
vector<int> PLUS[N], times[N];
char s[N];
int f[N][LOG], g[N][LOG], go[N][LOG];
int suffix[N], prefix[N], nxt_opt[N], bv[N];
void add(int &a, int b) {
if ((a += b) >= MOD) a -= MOD;
}
void mul(int &a, int b) { a = 1LL * a * b % MOD; }
bool is_digit(char c) { return '0' <= c && c <= '9'; }
int power(int a, int n) {
int ret = 1;
for (int i = 1; i <= n; i <<= 1) {
if (n & i) {
mul(ret, a);
}
mul(a, a);
}
return ret;
}
int dfs(int l, int r, int cur) {
if (s[l] == '(' && s[r] == ')' && match[l] == r) {
return bv[l] = bv[r] = dfs(l + 1, r - 1, cur + 1);
} else {
int ret = 0;
int pos =
lower_bound(PLUS[cur].begin(), PLUS[cur].end(), l) - PLUS[cur].begin();
if (pos < PLUS[cur].size() && PLUS[cur][pos] < r) {
ret = 0;
vector<int> tmp;
for (int i = pos; i < PLUS[cur].size() && PLUS[cur][i] < r; i++) {
tmp.push_back(PLUS[cur][i]);
}
assert(tmp.size() > 0);
add(ret, dfs(l, tmp[0] - 1, cur));
for (int i = 0; i + 1 < tmp.size(); i++) {
add(ret, f[tmp[i]][0] = dfs(tmp[i] + 1, tmp[i + 1] - 1, cur));
go[tmp[i]][0] = tmp[i + 1];
}
add(ret, dfs(tmp.back() + 1, r, cur));
return ret;
}
pos = lower_bound(times[cur].begin(), times[cur].end(), l) -
times[cur].begin();
if (pos < times[cur].size() && times[cur][pos] < r) {
ret = 1;
vector<int> tmp;
for (int i = pos; i < times[cur].size() && times[cur][i] < r; i++) {
tmp.push_back(times[cur][i]);
}
assert(tmp.size() > 0);
mul(ret, dfs(l, tmp[0] - 1, cur));
for (int i = 0; i + 1 < tmp.size(); i++) {
mul(ret, g[tmp[i]][0] = dfs(tmp[i] + 1, tmp[i + 1] - 1, cur));
go[tmp[i]][0] = tmp[i + 1];
}
mul(ret, dfs(tmp.back() + 1, r, cur));
return ret;
}
for (int i = l; i <= r; i++) {
assert(is_digit(s[i]));
prefix[i] = (prefix[i - 1] * 10LL + s[i] - '0') % MOD;
nxt_opt[i] = r + 1;
}
for (int i = r, base = 1; i >= l; i--) {
suffix[i] = (suffix[i + 1] + 1LL * (s[i] - '0') * base) % MOD;
base = base * 10LL % MOD;
}
return prefix[r];
}
}
void prepare() {
vector<int> lb;
for (int i = 1, cur_dep = 0; i <= n; i++) {
if (s[i] == '(') {
cur_dep++;
lb.push_back(i);
} else if (s[i] == ')') {
cur_dep--;
match[i] = lb.back();
match[lb.back()] = i;
lb.pop_back();
} else if (s[i] == '+') {
PLUS[cur_dep].push_back(i);
} else if (s[i] == '*') {
times[cur_dep].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
go[i][0] = 0;
}
dfs(1, n, 0);
}
int get_number(int l, int r) {
return 1LL * (suffix[l] + MOD - suffix[r + 1]) % MOD *
power(power(10, nxt_opt[l] - r - 1), MOD - 2) % MOD;
}
int get_first_number(int &l, int r) {
int ret;
if (s[l] == '(') {
ret = bv[l];
l = match[l] + 1;
} else {
assert(is_digit(s[l]));
if (nxt_opt[l] == nxt_opt[r]) {
ret = get_number(l, r);
l = r + 1;
return ret;
}
ret = suffix[l];
l = nxt_opt[l];
}
return ret;
}
int solve(int l, int r) {
if (l > r || l < 1 || r > n) return -1;
if (s[l] == '+' || s[r] == '+' || s[l] == '*' || s[r] == '*' || s[l] == ')') {
return -1;
}
int first = get_first_number(l, r);
if (l == r + 1) return first;
if (l > r || s[l] == ')') return -1;
assert(s[l] != '(');
if (s[l] == '*') {
for (int i = LOG - 1; i >= 0; i--) {
if (go[l][i] != 0 && go[l][i] <= r) {
mul(first, g[l][i]);
l = go[l][i];
}
}
l++;
int second = get_first_number(l, r);
mul(first, second);
if (l == r + 1) {
return first;
}
}
if (l > r || s[l] == ')') return -1;
assert(s[l] == '+');
for (int i = LOG - 1; i >= 0; i--) {
if (go[l][i] != 0 && go[l][i] <= r) {
add(first, f[l][i]);
l = go[l][i];
}
}
l++;
int second = get_first_number(l, r);
if (l == r + 1) return (first + second) % MOD;
if (l > r || s[l] == ')') return -1;
assert(s[l] == '*');
for (int i = LOG - 1; i >= 0; i--) {
if (go[l][i] != 0 && go[l][i] <= r) {
mul(second, g[l][i]);
l = go[l][i];
}
}
l++;
int third = get_first_number(l, r);
mul(second, third);
if (l == r + 1) return (first + second) % MOD;
return -1;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
prepare();
for (int i = 0; i + 1 < LOG; i++) {
for (int j = 1; j <= n; j++) {
go[j][i + 1] = go[go[j][i]][i];
f[j][i + 1] = (f[j][i] + f[go[j][i]][i]) % MOD;
g[j][i + 1] = 1LL * g[j][i] * g[go[j][i]][i] % MOD;
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", solve(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int iv10;
int ip10[500006];
int n, q;
int Pow(int x, int a) {
int ret = 1;
while (a) {
if (a & 1) ret = ret * 1ll * x % P;
x = x * 1ll * x % P, a >>= 1;
}
return ret;
}
int rd() {
char ch = getchar();
int ret = 0;
while (ch > '9' || ch < '0') ch = getchar();
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret;
}
char S[500006];
int bel[500006], lk[500006];
struct sgt {
struct node {
int l, r;
node operator+(const node a) {
return (node){a.l - min(a.l, r) + l, r - min(a.l, r) + a.r};
}
} T[500006 << 2];
void build(int rt, int l, int r) {
if (l == r) {
if (S[l] == '(')
T[rt].r = 1;
else if (S[l] == ')')
T[rt].l = 1;
return;
}
int m = l + r >> 1;
build(rt << 1, l, m), build(rt << 1 | 1, m + 1, r);
T[rt] = T[rt << 1] + T[rt << 1 | 1];
}
node que(int rt, int l, int r, int L, int R) {
if (L <= l && R >= r) return T[rt];
int m = l + r >> 1;
node re = (node){0, 0};
if (L <= m) re = re + que(rt << 1, l, m, L, R);
if (R > m) re = re + que(rt << 1 | 1, m + 1, r, L, R);
return re;
}
bool que(int l, int r) {
node re = que(1, 1, n, l, r);
return !re.l && !re.r;
}
} T;
int solve(int l, int r);
int cnn, bn[500006];
struct segnum {
int l, r, v, dx;
vector<int> s;
int build() {
if (S[l] == '(') {
bn[l] = bn[r] = cnn;
return v = solve(l + 1, r - 1);
}
int pw = 1;
for (int j = (1), jend = (r - l + 1); j <= jend; ++j) pw = pw * 10ll % P;
for (int i = (l), iend = (r); i <= iend; ++i) bn[i] = dx;
for (int i = (0), iend = (r - l); i <= iend; ++i) {
pw = pw * 1ll * iv10 % P;
s.push_back((S[i + l] - '0') * 1ll * pw % P);
if (s.size() > 1) s[s.size() - 1] = (s.back() + s[s.size() - 2]) % P;
}
return v = s.back();
}
int gv(int L, int R) {
if (L == l && R == r) return v;
int x = (s[R - l] + P - (L == l ? 0 : s[L - 1 - l])) % P;
return x * 1ll * ip10[r - R] % P;
}
} N[500006];
int bm[500006], cnm;
struct segmul {
int l, r, v, dx;
vector<int> nums, pm, c0;
int build() {
int pl = l;
for (int i = (l), iend = (r); i <= iend; ++i) {
if (S[i] == '*') {
++cnn;
N[cnn].l = pl, N[cnn].r = i - 1, N[cnn].dx = cnn;
nums.push_back(cnn);
int v = N[cnn].build();
pm.push_back(v == 0 ? 1 : v), c0.push_back(v == 0);
pl = i + 1;
}
bm[i] = dx;
if (S[i] == '(') i = lk[i] - 1;
}
++cnn, N[cnn].l = pl, N[cnn].r = r, N[cnn].dx = cnn;
nums.push_back(cnn);
int v = N[cnn].build();
pm.push_back(v == 0 ? 1 : v), c0.push_back(v == 0);
for (int i = (1), iend = (pm.size() - 1); i <= iend; ++i) {
pm[i] = pm[i - 1] * 1ll * pm[i] % P;
c0[i] += c0[i - 1];
}
return c0.back() ? 0 : pm.back();
}
int gv(int L, int R) {
int tl = bn[L], tr = bn[R];
if (tl == tr) return N[tl].gv(L, R);
int re = N[tl].gv(L, N[tl].r) * 1ll * N[tr].gv(N[tr].l, R) % P;
tl = upper_bound((nums).begin(), (nums).end(), tl) - nums.begin(),
tr = lower_bound((nums).begin(), (nums).end(), tr) - nums.begin() - 1;
if (tr >= tl && c0[tr]) return 0;
return pm[tr] * 1ll * (tl == 0 ? 1 : Pow(pm[tl - 1], P - 2)) % P * re % P;
}
} M[500006];
int cna;
struct segadd {
int l, r, v;
vector<int> ms, ps;
int build() {
int pl = l;
for (int i = (l), iend = (r); i <= iend; ++i) {
if (S[i] == '+') {
++cnm;
M[cnm].l = pl, M[cnm].r = i - 1, M[cnm].dx = cnm;
ms.push_back(cnm), ps.push_back(M[cnm].build());
pl = i + 1;
}
if (S[i] == '(') i = lk[i] - 1;
}
++cnm, M[cnm].l = pl, M[cnm].r = r, M[cnm].dx = cnm;
ms.push_back(cnm), ps.push_back(M[cnm].build());
for (int i = (1), iend = (ps.size() - 1); i <= iend; ++i)
ps[i] = (ps[i - 1] + ps[i]) % P;
return ps.back();
}
int gv(int L, int R) {
int tl = bm[L], tr = bm[R];
if (tl == tr) return M[tl].gv(L, R);
int res = M[tl].gv(L, M[tl].r) + M[tr].gv(M[tr].l, R);
tl = upper_bound((ms).begin(), (ms).end(), tl) - ms.begin(),
tr = lower_bound((ms).begin(), (ms).end(), tr) - ms.begin() - 1;
return (1ll * res + ps[tr] + P - ps[tl - 1]) % P;
}
} W[500006];
int solve(int l, int r) {
W[l - 1].l = l, W[l - 1].r = r;
return W[l - 1].build();
}
void solve() {
scanf("%s", S + 1);
n = strlen(S + 1);
iv10 = Pow(10, P - 2);
ip10[0] = 1;
for (int i = (1), iend = (n); i <= iend; ++i)
ip10[i] = ip10[i - 1] * 1ll * iv10 % P;
cin >> q;
vector<int> pt;
pt.push_back(0);
for (int i = (1), iend = (n); i <= iend; ++i) {
if (S[i] == '(')
bel[i] = pt.back(), pt.push_back(i);
else {
if (S[i] == ')') lk[pt.back()] = i, pt.pop_back();
bel[i] = pt.back();
}
}
T.build(1, 1, n);
solve(1, n);
for (int i = (1), iend = (q); i <= iend; ++i) {
int l, r;
l = rd(), r = rd();
if (S[l] == '+' || S[l] == '*' || S[r] == '+' || S[r] == '*') {
puts("-1");
continue;
}
if (!T.que(l, r)) {
puts("-1");
continue;
}
int x = bel[l];
printf("%d\n", W[x].gv(l, r));
}
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5e5 + 10, mod = 1e9 + 7;
int n, q, cnt;
int nxt[maxN + 1], res[maxN + 1], ans[maxN + 1];
int pw[maxN + 1], id[maxN + 1], tp[maxN + 1];
int L[maxN + 1], R[maxN + 1], S[maxN + 1];
int stk[maxN + 1], top;
int sum[maxN + 1], mn[maxN + 1][21], lg[maxN + 1];
char s[maxN + 1];
vector<int> pm[maxN + 1], pa[maxN + 1];
vector<int> son[maxN + 1], pre[maxN + 1], p0[maxN + 1];
inline int read() {
int num = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
return num * f;
}
inline void update(int &x, int y) { x = x + y >= mod ? x + y - mod : x + y; }
inline int mpow(int a, int x) {
int ans = 1;
while (x) {
if (x & 1) ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod;
x >>= 1;
}
return ans;
}
inline int get_mn(int l, int r) {
int k = lg[r - l + 1];
return min(mn[l][k], mn[r - (1 << k) + 1][k]);
}
inline bool check(int l, int r) {
if (sum[r] != sum[l - 1]) return false;
if (s[l] == '*' || s[l] == '+') return false;
if (s[r] == '*' || s[r] == '+') return false;
return get_mn(l, r) >= sum[r];
}
inline int get_Mul(int l, int r) {
int id = sum[r];
int x = lower_bound(pm[id].begin(), pm[id].end(), l) - pm[id].begin();
if (x == pm[id].size() || pm[id][x] > r) return -1;
return pm[id][x];
}
inline int get_Add(int l, int r) {
int id = sum[r];
int x = lower_bound(pa[id].begin(), pa[id].end(), l) - pa[id].begin();
if (x == pa[id].size() || pa[id][x] > r) return -1;
return pa[id][x];
}
inline int build(int l, int r) {
int node = ++cnt;
L[node] = l, R[node] = r;
while (s[l] == '(' && nxt[l] == r) id[l++] = node, r--;
int mid = get_Add(l, r);
if (mid != -1) {
tp[node] = 0;
int x = l;
while (mid != -1) {
id[mid] = node;
son[node].push_back(build(x, mid - 1));
x = mid + 1;
mid = get_Add(x, r);
}
son[node].push_back(build(x, r));
int sum = 0;
for (int i = 0; i < son[node].size(); i++) {
update(sum, res[son[node][i]]);
pre[node].push_back(sum);
}
return res[node] = sum, node;
}
mid = get_Mul(l, r);
if (mid != -1) {
tp[node] = 1;
int x = l;
while (mid != -1) {
id[mid] = node;
son[node].push_back(build(x, mid - 1));
x = mid + 1;
mid = get_Mul(x, r);
}
son[node].push_back(build(x, r));
int sum = 1, tot = 0;
for (int i = 0; i < son[node].size(); i++) {
if (!res[son[node][i]])
tot++;
else
sum = 1ll * sum * res[son[node][i]] % mod;
pre[node].push_back(sum);
p0[node].push_back(tot);
}
return res[node] = tot ? 0 : sum, node;
}
tp[node] = 2;
for (int i = l; i <= r; i++)
res[node] = (10ll * res[node] % mod + s[i] - '0') % mod;
return node;
}
inline int get(int l, int r) {
int ans = S[r];
update(ans, mod - 1ll * S[l - 1] * pw[r - l + 1] % mod);
return ans;
}
inline int findl(int node, int x) {
int l = 0, r = son[node].size() - 1, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (L[son[node][mid]] < x)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
return ans;
}
inline int findr(int node, int x) {
int l = 0, r = son[node].size() - 1, ans = son[node].size();
while (l <= r) {
int mid = (l + r) >> 1;
if (R[son[node][mid]] > x)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
return ans;
}
inline int query3(int node, int l, int r) {
l = max(l, L[node]), r = min(r, R[node]);
if (l > r) return 0;
return get(l, r);
}
inline int query2(int node, int l, int r) {
if (tp[node] == 2) return query3(node, l, r);
l = max(l, L[node]), r = min(r, R[node]);
if (l > r) return 0;
int x = findl(node, l), y = findr(node, r);
int ans = (y ? pre[node][y - 1] : 1), tot = (y ? p0[node][y - 1] : 0);
if (x != -1)
ans = 1ll * ans * mpow(pre[node][x], mod - 2) % mod, tot -= p0[node][x];
if (x != -1 && R[son[node][x]] >= l)
ans = 1ll * ans * query3(son[node][x], l, r) % mod;
if (y != son[node].size() && L[son[node][y]] <= r)
ans = 1ll * ans * query3(son[node][y], l, r) % mod;
return tot ? 0 : ans;
}
inline int query1(int node, int l, int r) {
int x = findl(node, l), y = findr(node, r);
int ans = (y ? pre[node][y - 1] : 0);
if (x != -1) update(ans, mod - pre[node][x]);
if (x != -1 && R[son[node][x]] >= l) update(ans, query2(son[node][x], l, r));
if (y != son[node].size() && L[son[node][y]] <= r)
update(ans, query2(son[node][y], l, r));
return ans;
}
inline int solve(int l, int r) {
if (s[l] == '(' && nxt[l] == r) return res[id[l]];
int mid = get_Add(l, r);
if (mid != -1) return query1(id[mid], l, r);
mid = get_Mul(l, r);
if (mid != -1) return query2(id[mid], l, r);
return get(l, r);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1];
if (s[i] == '(') sum[i]++, stk[++top] = i;
if (s[i] == ')') sum[i]--, nxt[stk[top--]] = i;
}
for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; i++) mn[i][0] = sum[i];
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i + (1 << j) - 1 <= n; i++)
mn[i][j] = min(mn[i][j - 1], mn[i + (1 << j - 1)][j - 1]);
for (int i = 1; i <= n; i++) {
if (s[i] == '+') pa[sum[i]].push_back(i);
if (s[i] == '*') pm[sum[i]].push_back(i);
}
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = 10ll * pw[i - 1] % mod;
for (int i = 1; i <= n; i++) {
S[i] = 10ll * S[i - 1] % mod;
if (isdigit(s[i])) update(S[i], s[i] - '0');
}
build(1, n);
q = read();
while (q--) {
int l = read(), r = read();
if (!check(l, r)) {
puts("-1");
continue;
}
printf("%d\n", solve(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
const int mod = 1e9 + 7;
inline void add_mod(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline int mod_add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
inline long long pw(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long pw10[MAXN];
inline int get_cid(char c) {
return c >= '0' && c <= '9' ? 0 : c == '+' || c == '*' ? 1 : 2;
}
char s[MAXN];
int lef[MAXN], rig[MAXN], lvl[MAXN];
int val[MAXN], pren[MAXN];
int pid[MAXN], psum[MAXN], pl[MAXN], pr[MAXN], pcnt = 0;
int nid[MAXN], nval[MAXN], nprod[MAXN], inprod[MAXN], nzero[MAXN], ncnt = 0;
inline int get_num(int l, int r) {
return s[r] == ')' ? val[r]
: mod_add(pren[r], mod - (long long)pren[l - 1] *
pw10[r - l + 1] % mod);
}
inline int get_p(int l, int r) {
if (nid[l] == nid[r]) return get_num(l, r);
int res = (long long)get_num(l, rig[l]) * get_num(lef[r], r) % mod;
l = rig[l] + 2;
r = lef[r] - 2;
if (l > r || !res) return res;
l = nid[l];
r = nid[r];
if (nzero[r] - nzero[l - 1] > 0) return 0;
return (long long)res * nprod[r] % mod * inprod[l - 1] % mod;
}
int build(int l, int r, int cur_lvl) {
vector<int> num, vs, ps;
for (int i = l; i <= r; i = rig[i] + 2) {
num.push_back(i);
if (s[i] == '(') {
lvl[i] = lvl[rig[i]] = cur_lvl;
val[i] = val[rig[i]] = build(i + 1, rig[i] - 1, i);
} else {
for (int j = i; j <= rig[i]; ++j) lvl[j] = cur_lvl;
}
vs.push_back(get_num(i, rig[i]));
}
ps.push_back(0);
for (int i = 1; i < (int)num.size(); ++i)
if (s[num[i] - 1] == '+') ps.push_back(i);
ps.push_back((int)num.size());
for (int i = 0; i < (int)num.size(); ++i) {
int nl = num[i], nr = rig[nl];
nval[++ncnt] = vs[i];
if (s[nl] == '(')
nid[nl] = nid[nr] = ncnt;
else
for (int j = nl; j <= nr; ++j) nid[j] = ncnt;
}
int res = 0;
for (int k = 0; k + 1 < (int)ps.size(); ++k) {
int il = ps[k], ir = ps[k + 1] - 1, cur = 1;
++pcnt;
pl[pcnt] = num[il];
pr[pcnt] = rig[num[ir]];
for (int i = il; i <= ir; ++i) {
cur = (long long)cur * vs[i] % mod;
int nl = num[i], nr = rig[nl];
if (s[nl] == '(')
pid[nl] = pid[nr] = pcnt;
else
for (int j = nl; j <= nr; ++j) pid[j] = pcnt;
}
psum[pcnt] = cur;
add_mod(res, cur);
}
return res;
}
int main(void) {
pw10[0] = 1;
for (int i = 1; i < MAXN; ++i) pw10[i] = pw10[i - 1] * 10 % mod;
int n, Q;
scanf("%s%d", s + 2, &Q);
n = strlen(s + 2) + 2;
s[1] = '(';
s[n] = ')';
stack<int> sta;
for (int i = n; i >= 1; --i) {
if (get_cid(s[i]) == 0)
rig[i] = get_cid(s[i + 1]) ? i : rig[i + 1];
else if (s[i] == ')')
rig[i] = i, sta.push(i);
else if (s[i] == '(')
rig[i] = sta.top(), sta.pop();
}
for (int i = 1; i <= n; ++i) {
if (get_cid(s[i]) == 0)
lef[i] = get_cid(s[i - 1]) ? i : lef[i - 1];
else if (s[i] == '(')
lef[i] = i, sta.push(i);
else if (s[i] == ')')
lef[i] = sta.top(), sta.pop();
}
for (int i = 1; i <= n; ++i)
if (get_cid(s[i]) == 0)
pren[i] = ((long long)pren[i - 1] * 10 + (s[i] - '0')) % mod;
val[1] = val[n] = build(2, n - 1, 1);
for (int i = 1; i <= pcnt; ++i) add_mod(psum[i], psum[i - 1]);
nprod[0] = 1;
for (int i = 1; i <= ncnt; ++i) {
nzero[i] = nzero[i - 1] + !nval[i];
nprod[i] = (long long)nprod[i - 1] * max(nval[i], 1) % mod;
}
inprod[ncnt] = pw(nprod[ncnt], mod - 2);
for (int i = ncnt - 1; i >= 0; --i)
inprod[i] = (long long)inprod[i + 1] * max(nval[i + 1], 1) % mod;
while (Q--) {
int l, r;
scanf("%d%d", &l, &r);
++l;
++r;
if (get_cid(s[l]) == 1 || get_cid(s[r]) == 1) {
printf("-1\n");
continue;
}
if (s[l] == ')' || s[r] == '(') {
printf("-1\n");
continue;
}
if (lvl[l] != lvl[r]) {
printf("-1\n");
continue;
}
if (nid[l] == nid[r]) {
printf("%d\n", get_num(l, r));
} else if (pid[l] == pid[r]) {
printf("%d\n", get_p(l, r));
} else {
int res = mod_add(get_p(l, pr[pid[l]]), get_p(pl[pid[r]], r));
l = pid[l] + 1;
r = pid[r] - 1;
if (l <= r) res = ((long long)res + psum[r] + mod - psum[l - 1]) % mod;
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
mt19937 ggen;
const int MOD = 1000000007;
int add(int a, int b) {
int res = a + b;
if (res >= MOD) res -= MOD;
return res;
}
int mul(int a, int b) { return (long long)a * b % MOD; }
int blen[500010];
void precalc() {
for (int i = 0; i < 500010; i++) {
int ti = i;
while (ti) {
blen[i]++;
ti >>= 1;
}
}
}
struct sparse {
vector<pair<int, int> > a;
vector<pair<int, int> > mn[20];
void build() {
int n = a.size();
mn[0].resize(n);
for (int i = 0; i < n; i++) {
mn[0][i] = a[i];
}
for (int i = 1; i < 20; i++) {
mn[i].resize(n);
for (int j = 0; j < n; j++) {
mn[i][j] = mn[i - 1][j];
if (j + (1 << (i - 1)) < n)
mn[i][j] = min(mn[i][j], mn[i - 1][j + (1 << (i - 1))]);
}
}
}
pair<int, int> get(int l, int r) {
int dt = r - l + 1;
return min(mn[blen[dt] - 1][l],
mn[blen[dt] - 1][r + 1 - (1 << (blen[dt] - 1))]);
}
};
int n;
string s;
int sb[500010];
sparse st[3];
struct node {
node *l, *r;
int type;
int val;
int ev;
int id;
node() : l(NULL), r(NULL), val(-1), ev(-1) {}
};
node tr[800000];
int ts;
node *root;
node *ptr[500010];
typedef node *nodeptr;
bool right(int l, int r) {
int mb = st[2].get(l, r + 1).first;
return (sb[l] == sb[r + 1] && sb[l] == mb);
}
void parse(nodeptr &v, int l, int r) {
v = &tr[ts];
tr[ts].id = ts;
ts++;
if (l == r) {
v->val = s[l] - '0';
ptr[l] = v;
return;
}
if (s[l] == '(' && s[r] == ')' && right(l + 1, r - 1)) {
v->type = -1;
parse(v->l, l + 1, r - 1);
ptr[l] = ptr[r] = v;
} else {
auto t = st[0].get(l, r);
if (t.first == sb[l]) {
v->type = 0;
parse(v->l, l, t.second - 1);
parse(v->r, t.second + 1, r);
} else {
t = st[1].get(l, r);
if (t.first == sb[l]) {
v->type = 1;
parse(v->l, l, t.second - 1);
parse(v->r, t.second + 1, r);
} else {
v->type = 2;
parse(v->l, l, r - 1);
parse(v->r, r, r);
}
}
}
}
int tin[800000];
int tout[800000];
int timer;
int p[20][800000];
pair<int, int> L[20][800000];
pair<int, int> apply(pair<int, int> a, pair<int, int> b) {
a.first = mul(a.first, b.first);
a.second = add(mul(a.second, b.first), b.second);
return a;
}
int eval(nodeptr v, nodeptr pt) {
tin[v->id] = ++timer;
p[0][v->id] = pt->id;
if (v->val != -1) {
v->ev = v->val;
} else {
if (v->type == -1)
v->ev = eval(v->l, v);
else {
int a = eval(v->l, v);
int b = eval(v->r, v);
if (v->type == 0)
v->ev = add(a, b);
else if (v->type == 1)
v->ev = mul(a, b);
else
v->ev = add(mul(a, 10), b);
}
}
tout[v->id] = ++timer;
return v->ev;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tin[b] <= tout[a]; }
int lca(int a, int b) {
if (upper(a, b))
return a;
else if (upper(b, a))
return b;
for (int i = 19; i >= 0; i--) {
if (!upper(p[i][a], b)) a = p[i][a];
}
return p[0][a];
}
int get(pair<int, int> arr[][800000], int val, int a, int b) {
if (a == b) return val;
for (int i = 19; i >= 0; i--) {
if (!upper(p[i][a], b)) {
val = add(mul(val, arr[i][a].first), arr[i][a].second);
a = p[i][a];
}
}
return val;
}
int ql[500010];
int qr[500010];
int ansa[500010];
int ansb[500010];
void solve_l(int m) {
for (int i = 0; i < ts; i++) {
nodeptr cur = &tr[i];
nodeptr p = &tr[::p[0][i]];
if (i == 0) {
L[0][i].first = 1;
L[0][i].second = 0;
} else if (p->type == -1) {
L[0][i].first = 1;
L[0][i].second = 0;
} else if (p->type == 0) {
if (p->l == cur) {
L[0][i].first = 1;
L[0][i].second = p->r->ev;
} else {
L[0][i].first = 1;
L[0][i].second = 0;
}
} else if (p->type == 1) {
if (p->l == cur) {
L[0][i].first = p->r->ev;
L[0][i].second = 0;
} else {
L[0][i].first = 1;
L[0][i].second = 0;
}
} else {
if (p->l == cur) {
L[0][i].first = 10;
L[0][i].second = p->r->ev;
} else {
L[0][i].first = 1;
L[0][i].second = 0;
}
}
}
for (int pw = 1; pw < 20; pw++) {
for (int i = 0; i < ts; i++) {
L[pw][i] = apply(L[pw - 1][i], L[pw - 1][p[pw - 1][i]]);
}
}
for (int i = 0; i < m; i++) {
int l = ql[i], r = qr[i];
if (s[l] == '+' || s[l] == '*' || s[l] == ')' || s[r] == '+' ||
s[r] == '*' || s[r] == '(' || !right(l, r)) {
continue;
}
l = ptr[l]->id;
r = ptr[r]->id;
if (l == r) {
continue;
}
int lc = lca(l, r);
ansa[i] = get(L, tr[l].ev, l, lc);
}
}
void solve_r(int m) {
for (int i = 0; i < ts; i++) {
nodeptr cur = &tr[i];
nodeptr p = &tr[::p[0][i]];
if (i == 0) {
L[0][i].first = 1;
L[0][i].second = 0;
} else if (p->type == -1) {
L[0][i].first = 1;
L[0][i].second = 0;
} else if (p->type == 0) {
if (p->l == cur) {
L[0][i].first = 1;
L[0][i].second = 0;
} else {
L[0][i].first = 1;
L[0][i].second = p->l->ev;
}
} else if (p->type == 1) {
if (p->l == cur) {
L[0][i].first = 1;
L[0][i].second = 0;
} else {
L[0][i].first = p->l->ev;
L[0][i].second = 0;
}
} else {
if (p->l == cur) {
L[0][i].first = 1;
L[0][i].second = 0;
} else {
L[0][i].first = 1;
L[0][i].second = mul(p->l->ev, 10);
}
}
}
for (int pw = 1; pw < 20; pw++) {
for (int i = 0; i < ts; i++) {
L[pw][i] = apply(L[pw - 1][i], L[pw - 1][p[pw - 1][i]]);
}
}
for (int i = 0; i < m; i++) {
int l = ql[i], r = qr[i];
if (s[l] == '+' || s[l] == '*' || s[l] == ')' || s[r] == '+' ||
s[r] == '*' || s[r] == '(' || !right(l, r)) {
continue;
}
l = ptr[l]->id;
r = ptr[r]->id;
if (l == r) {
continue;
}
int lc = lca(l, r);
ansb[i] = get(L, tr[r].ev, r, lc);
}
}
void solve() {
cin >> s;
n = s.size();
int bal = 0;
for (int i = 0; i < n; i++) {
sb[i] = bal;
if (s[i] == '(')
bal++;
else if (s[i] == ')')
bal--;
}
for (int i = 0; i < n; i++) {
st[2].a.push_back(pair<int, int>(sb[i], i));
if (s[i] == '+')
st[0].a.push_back(pair<int, int>(sb[i], i));
else
st[0].a.push_back(pair<int, int>(((int)(1e9) + 1337), i));
if (s[i] == '*')
st[1].a.push_back(pair<int, int>(sb[i], i));
else
st[1].a.push_back(pair<int, int>(((int)(1e9) + 1337), i));
}
st[0].build();
st[1].build();
st[2].build();
parse(root, 0, n - 1);
eval(root, root);
for (int pw = 1; pw < 20; pw++) {
for (int i = 0; i < ts; i++) {
p[pw][i] = p[pw - 1][p[pw - 1][i]];
}
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
ql[i] = l;
qr[i] = r;
}
solve_l(m);
solve_r(m);
for (int i = 0; i < m; i++) {
int l = ql[i], r = qr[i];
if (s[l] == '+' || s[l] == '*' || s[l] == ')' || s[r] == '+' ||
s[r] == '*' || s[r] == '(' || !right(l, r)) {
cout << "-1\n";
continue;
}
l = ptr[l]->id;
r = ptr[r]->id;
if (l == r) {
cout << tr[l].ev << '\n';
continue;
}
int lc = lca(l, r);
int a = ansa[i];
int b = ansb[i];
if (tr[lc].type == 0)
cout << add(a, b);
else if (tr[lc].type == 1)
cout << mul(a, b);
else if (tr[lc].type == 2)
cout << add(mul(a, 10), b);
cout << '\n';
}
}
void testgen(int n) {
ofstream ofs("input.txt", ios_base::out | ios_base::trunc);
mt19937 gen(1337);
uniform_int_distribution<int> distr(0, 9);
for (int i = 0; i < n; i++) ofs << (char)('0' + distr(gen));
ofs << "\n1\n1 " << n;
ofs.close();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
ggen = mt19937(13);
precalc();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
const int mod = 1e9 + 7;
int Pow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) res = (long long)res * x % mod;
return res;
}
int match[N];
char s[N];
int ncnt, L[N], R[N], val[N];
vector<vector<int>> p[N];
vector<int> sum[N];
struct Int {
int x, y;
Int(int v = 0) {
if (v)
x = v, y = 0;
else
x = 1, y = 1;
}
Int(int x, int y) : x(x), y(y) {}
Int operator*(Int b) { return Int((long long)x * b.x % mod, y + b.y); }
Int operator/(Int b) {
return Int((long long)x * Pow(b.x, mod - 2) % mod, y - b.y);
}
int get() { return y ? 0 : x; }
};
vector<vector<Int>> pre[N];
int ed[N], st[N], fuck[N], num[N], pw[N];
int calc(int l, int r) {
int res = (num[r] - (long long)num[l - 1] * pw[r - l + 1]) % mod;
return (res + mod) % mod;
}
int build(int l, int r) {
if (match[l] == r) return build(l + 1, r - 1);
int rt = ++ncnt;
L[rt] = l, R[rt] = r;
if (s[l] != '(' && ed[l] == r) {
val[rt] = calc(l, r), fuck[rt] = 1;
return rt;
}
p[rt].resize(1), pre[rt].resize(1);
Int cur(1);
for (int i = l, j; i <= r; i++) {
if (s[i] == '(' || isdigit(s[i])) {
j = s[i] == '(' ? match[i] : ed[i];
int t = build(i, j);
p[rt].back().push_back(t), i = j, cur = cur * Int(val[t]);
pre[rt].back().push_back(cur);
} else if (s[i] == '+') {
p[rt].push_back({}), val[rt] = (val[rt] + cur.get()) % mod;
sum[rt].push_back(cur.get()), cur = Int(1);
pre[rt].push_back({});
}
}
val[rt] = (val[rt] + cur.get()) % mod;
sum[rt].push_back(cur.get());
for (int i = 1; i < sum[rt].size(); i++)
sum[rt][i] = (sum[rt][i] + sum[rt][i - 1]) % mod;
return rt;
}
long long hsh[N];
bool check(int l, int r) {
if (hsh[l - 1] != hsh[r]) return false;
if (s[l] == '+' || s[l] == '*' || s[r] == '+' || s[r] == '*') return false;
return true;
}
int work1(int rt, int pos, int l, int r) {
int base = 1;
if (l >= 1 && isdigit(s[l]))
base = (long long)base * calc(l, ed[l]) % mod, l = ed[l] + 2;
if (r <= N && isdigit(s[r]))
base = (long long)base * calc(st[r], r) % mod, r = st[r] - 2;
if (l > r || l > R[p[rt][pos].back()] || r < L[p[rt][pos][0]]) return base;
int l1 = 0, r1 = (int)p[rt][pos].size() - 1;
int tl = 0, tr = r1;
while (tl <= tr) {
int mid = (tl + tr) >> 1;
if (R[p[rt][pos][mid]] < l)
l1 = mid + 1, tl = mid + 1;
else
tr = mid - 1;
}
tl = 0, tr = r1;
while (tl <= tr) {
int mid = (tl + tr) >> 1;
if (L[p[rt][pos][mid]] > r)
r1 = mid - 1, tr = mid - 1;
else
tl = mid + 1;
}
assert(l1 <= r1);
if (l1 == 0) return (long long)base * pre[rt][pos][r1].get() % mod;
return (long long)base * (pre[rt][pos][r1] / pre[rt][pos][l1 - 1]).get() %
mod;
}
int query(int rt, int l, int r) {
if (ed[l] >= r) return calc(l, r);
int l1 = 0, r1 = (int)p[rt].size() - 1;
int tl = 0, tr = r1;
while (tl <= tr) {
int mid = (tl + tr) >> 1;
if (R[p[rt][mid].back()] < l)
l1 = mid + 1, tl = mid + 1;
else
tr = mid - 1;
}
tl = 0, tr = r1;
while (tl <= tr) {
int mid = (tl + tr) >> 1;
if (L[p[rt][mid][0]] > r)
r1 = mid - 1, tr = mid - 1;
else
tl = mid + 1;
}
if (l1 == r1) {
return work1(rt, l1, l, r);
} else {
int res = sum[rt][r1 - 1] - sum[rt][l1];
if (res < 0) res += mod;
return (res + (long long)work1(rt, l1, l, 1e9) + work1(rt, r1, -1e9, r)) %
mod;
}
}
long long wkr[N];
mt19937 rnd((long long)new char + time(0));
int ct[N], ans[N], ban[N];
struct event {
int l, r, id, tp;
};
int main() {
int n, q;
scanf("%s%d", s + 1, &q), n = strlen(s + 1);
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = (long long)pw[i - 1] * 10 % mod;
for (int i = 1; i <= n; i++) {
num[i] = ((long long)num[i - 1] * 10 + s[i] - '0') % mod;
if (!isdigit(s[i])) num[i] = 0;
}
for (int i = 1; i <= n; i++) wkr[i] = rnd();
static int stk[N], top = 0;
for (int i = 1; i <= n; i++) {
if (isdigit(s[i])) st[i] = st[i - 1] ? st[i - 1] : i;
}
for (int i = n; i >= 1; i--) {
if (isdigit(s[i])) ed[i] = ed[i + 1] ? ed[i + 1] : i;
}
int cur = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '(') {
stk[++top] = i, cur ^= wkr[i];
} else if (s[i] == ')') {
cur ^= wkr[stk[top]], match[stk[top]] = i, top--;
}
hsh[i] = cur;
ct[i] = ct[i - 1] + (s[i] == '(');
}
vector<event> zjk;
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (!check(l, r))
ban[i] = 1;
else {
int tl = 0, tr = r - l, mid, hh = -1;
while (tl <= tr) {
mid = (tl + tr) >> 1;
if (ct[l + mid] - ct[l - 1] != mid + 1 || match[l + mid] != r - mid) {
tr = mid - 1;
} else {
hh = mid, tl = mid + 1;
}
}
hh++, l += hh, r -= hh;
zjk.push_back({l, r, i, 1});
}
}
build(1, n);
for (int i = 1; i <= ncnt; i++) {
zjk.push_back({L[i], R[i], i, 0});
}
sort(zjk.begin(), zjk.end(), [&](event a, event b) {
if (a.l != b.l) return a.l < b.l;
return a.tp < b.tp;
});
set<pair<int, int>> s;
for (auto t : zjk) {
if (t.tp == 0) {
s.insert(pair<int, int>(t.r, t.id));
} else {
auto pos = s.lower_bound(pair<int, int>(t.r, -1e9));
assert(pos != s.end());
ans[t.id] = query(pos->second, t.l, t.r);
}
}
for (int i = 1; i <= q; i++)
if (ban[i])
puts("-1");
else
printf("%d\n", (ans[i] + mod) % mod);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500000;
const int mod = 1000000007;
char s[N];
struct block;
block *bl[N];
int poww[N];
stack<block *> blocks;
void next(int &it) {
if (blocks.empty())
it++;
else
bl[it++] = blocks.top();
}
int power(int a, int b) {
if (b == 0) return 1;
if (b & 1) return 1LL * a * power(a, b - 1) % mod;
return power(1LL * a * a % mod, b / 2);
}
int inv(int a) { return power(a, mod - 2); }
struct expr {
int a, b;
int val;
virtual int _get(int A, int B) { return 0; };
int get(int A, int B) {
A = max(a, A);
B = min(b, B);
if (a == A && b == B) {
return val;
}
return _get(A, B);
}
expr(int A, int B) : a(A), b(B) {}
expr() = default;
};
struct num : expr {
vector<int> pref;
num(int &it) {
a = it;
val = 0;
pref.push_back(0);
while (isdigit(s[it])) {
val = (1LL * val * 10 + s[it] - '0') % mod;
next(it);
pref.push_back(val);
}
b = it;
}
int _get(int A, int B) {
int ans = (pref[B - a] - 1LL * pref[A - a] * poww[B - A]) % mod;
if (ans < 0) ans += mod;
return ans;
}
};
struct prod : expr {
vector<expr *> vec;
vector<int> res;
prod(int &it);
int _get(int A, int B) {
auto e = new expr(A, B);
auto it1 = upper_bound(vec.begin(), vec.end(), e,
[](expr *a, expr *b) { return a->a < b->a; });
auto it2 = lower_bound(vec.begin(), vec.end(), e,
[](expr *a, expr *b) { return a->b < b->b; });
delete e;
int ans = 1;
if (it2 > it1)
ans = 1LL * res[it2 - vec.begin()] * inv(res[it1 - vec.begin()]) % mod;
if (it2 != vec.end()) ans = 1LL * ans * (*it2)->get(A, B) % mod;
if (it1 != vec.begin() && --it1 != it2)
ans = 1LL * ans * (*it1)->get(A, B) % mod;
return ans;
}
};
struct block : expr {
vector<expr *> vec;
vector<int> res;
block(int &it) {
val = 0;
a = it;
assert(s[it] == '(');
next(it);
blocks.push(this);
res.push_back(0);
while (true) {
vec.push_back(new prod(it));
val = (val + vec.back()->val) % mod;
res.push_back(val);
if (s[it] != '+')
break;
else
next(it);
}
blocks.pop();
assert(s[it] = ')');
next(it);
b = it;
}
int _get(int A, int B) {
if (a == A || b == B) return -1;
auto e = new expr(A, B);
auto it1 = upper_bound(vec.begin(), vec.end(), e,
[](expr *a, expr *b) { return a->a < b->a; });
auto it2 = lower_bound(vec.begin(), vec.end(), e,
[](expr *a, expr *b) { return a->b < b->b; });
delete e;
int ans = 0;
if (it2 > it1) ans = res[it2 - vec.begin()] - res[it1 - vec.begin()];
if (ans < 0) ans += mod;
if (it2 != vec.end()) ans = (ans + (*it2)->get(A, B)) % mod;
if (it1 != vec.begin() && --it1 != it2)
ans = (ans + (*it1)->get(A, B)) % mod;
return ans;
}
};
prod::prod(int &it) {
val = 1;
a = it;
res.push_back(1);
while (true) {
if (s[it] == '(')
vec.push_back(new block(it));
else
vec.push_back(new num(it));
val = 1LL * val * vec.back()->val % mod;
res.push_back(val);
if (s[it] != '*')
break;
else
next(it);
}
b = it;
}
int main() {
poww[0] = 1;
for (int i = 1; i < N; i++) poww[i] = poww[i - 1] * 10LL % mod;
scanf("%s", s + 1);
s[0] = '(';
s[strlen(s)] = ')';
int i = 0;
new block(i);
int n;
scanf("%d", &n);
while (n--) {
int a, b;
scanf("%d %d", &a, &b);
if ((!isdigit(s[a]) && s[a] != '(') || (!isdigit(s[b]) && s[b] != ')') ||
bl[a] != bl[b]) {
puts("-1");
continue;
}
printf("%d\n", bl[a]->get(a, b + 1));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10, P = 1e9 + 7;
char S[maxn], T[maxn];
int tpn, n, q, num[maxn], pw10[maxn], go[maxn], mp[maxn], lg[maxn];
vector<int> vec;
struct RMQ {
int A[maxn], st[19][maxn];
int cmp(int x, int y) { return A[x] < A[y] ? x : y; }
int query(int l, int r) {
int k = lg[r - l + 1];
return cmp(st[k][l], st[k][r - (1 << k) + 1]);
}
void build() {
for (int i = (0), iend = (tpn); i <= iend; ++i)
lg[i] = lg[i >> 1] + (i > 1), st[0][i] = i;
for (int i = (1), iend = (18); i <= iend; ++i)
for (int j = (0), jend = (tpn - (1 << i) + 1); j <= jend; ++j)
st[i][j] = cmp(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
} bra, pr;
int query_num(int l, int r) {
return (num[r] + 1ll * num[l - 1] * (P - pw10[r - l + 1])) % P;
}
struct node {
int mu, ad;
node() : mu(1), ad(0) {}
node(int _m, int _a) : mu(_m), ad(_a) {}
node operator+(const node& o) const {
return node(1ll * mu * o.mu % P, (1ll * ad * o.mu + o.ad) % P);
}
} lef[19][maxn], rig[19][maxn];
int rt, fa[19][maxn], ls[maxn], rs[maxn], sum[maxn], dep[maxn], L[maxn];
void build(int& rt, int l, int r) {
rt = pr.query(l, r), L[rt] = l;
sum[rt] = pr.A[rt] <= tpn ? build(ls[rt], l, rt - 1),
build(rs[rt], rt + 1, r),
S[rt] == '+' ? (sum[ls[rt]] + sum[rs[rt]]) % P
: 1ll * sum[ls[rt]] * sum[rs[rt]] % P
: query_num(L[rt] = l, r);
}
void dfs(int u, int f) {
fa[0][u] = f, dep[u] = dep[f] + 1;
int v = sum[ls[f] ^ rs[f] ^ u];
node tp = S[f] == '+' ? node{1, v} : node{v, 0};
if (f) u == ls[f] ? lef[0][u] = tp : rig[0][u] = tp;
for (int i = (1), iend = (18); i <= iend; ++i) {
fa[i][u] = fa[i - 1][fa[i - 1][u]];
lef[i][u] = lef[i - 1][u] + lef[i - 1][fa[i - 1][u]];
rig[i][u] = rig[i - 1][u] + rig[i - 1][fa[i - 1][u]];
}
if (ls[u]) dfs(ls[u], u), dfs(rs[u], u);
}
int main() {
scanf("%s%d", T + 1, &q), tpn = strlen(T + 1), pw10[0] = 1;
int now = 0;
for (int i = (1), iend = (tpn); i <= iend; ++i) {
pw10[i] = 10ll * pw10[i - 1] % P;
bool f1 = T[i] == '(', f2 = T[i] == ')';
if (f1 || f2)
now += f1 - f2;
else {
S[++n] = T[i], pr.A[n] = T[i] == '+' ? now * 2
: T[i] == '*' ? now * 2 + 1
: tpn + 1;
num[n] = (10ll * num[n - 1] + P + T[i] - 48) % P;
if (isdigit(T[i])) vec.push_back(n);
}
bra.A[i] = now, mp[i] = n;
}
for (int i = (n), iend = (1); i >= iend; --i)
go[i] = isdigit(S[i + 1]) ? go[i + 1] : i;
bra.build(), pr.build(), build(rt, 1, n), dfs(rt, 0);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (T[l] == '+' || T[l] == '*' || T[r] == '+' || T[r] == '*' ||
bra.A[l - 1] != bra.A[r] || bra.query(l - 1, r) != r) {
puts("-1");
continue;
}
l = mp[l - 1] + 1, r = mp[r];
if (pr.A[pr.query(l, r)] > tpn) {
printf("%d\n", query_num(l, r));
continue;
}
int u = go[*lower_bound(vec.begin(), vec.end(), l)];
int v = go[*--upper_bound(vec.begin(), vec.end(), r)];
int x = query_num(max(L[u], l), u), y = query_num(L[v], min(v, r));
node p, q;
for (int i = (18), iend = (0); i >= iend; --i) {
if (dep[u] - (1 << i) >= dep[v]) p = p + lef[i][u], u = fa[i][u];
if (dep[v] - (1 << i) >= dep[u]) q = q + rig[i][v], v = fa[i][v];
}
for (int i = (18), iend = (0); i >= iend; --i)
if (fa[i][u] != fa[i][v]) {
p = p + lef[i][u], q = q + rig[i][v], u = fa[i][u], v = fa[i][v];
}
x = (1ll * x * p.mu + p.ad) % P, y = (1ll * y * q.mu + q.ad) % P;
int anc = fa[0][u], res = S[anc] == '+' ? (x + y) % P : 1ll * x * y % P;
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400050;
const int mod = 1e9 + 7;
int add(int x, int y) {
x += y;
return x >= mod ? x - mod : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + mod : x;
}
int mul(int x, int y) { return (long long)x * y % mod; }
char expr[N];
const int LOG = 20;
int tsz, ls[N], rs[N], type[N], par[N][LOG], dep[N], val[N];
int L[N], R[N], my_node[N], brup[N];
void DFS(int u, int p) {
dep[u] = dep[p] + 1;
par[u][0] = p;
brup[u] = brup[p] + (type[u] == 3);
for (int i = 1; i < LOG; i++) par[u][i] = par[par[u][i - 1]][i - 1];
if (type[u] == 0) {
val[u] = 0;
for (int i = L[u]; i <= R[u]; i++)
val[u] = add(mul(10, val[u]), expr[i] - '0');
return;
}
DFS(ls[u], u);
L[u] = L[ls[u]];
R[u] = R[ls[u]];
if (type[u] != 3) DFS(rs[u], u), R[u] = R[rs[u]];
if (type[u] == 1) val[u] = add(val[ls[u]], val[rs[u]]);
if (type[u] == 2) val[u] = mul(val[ls[u]], val[rs[u]]);
if (type[u] == 3) val[u] = val[ls[u]];
}
int LCA(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = LOG - 1; ~i; i--)
if (dep[par[u][i]] >= dep[v]) u = par[u][i];
for (int i = LOG - 1; ~i; i--)
if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
return u == v ? v : par[v][0];
}
int Climb(int u, int k) {
for (int i = 0; i < LOG; i++)
if (k >> i & 1) u = par[u][i];
return u;
}
int l[N], r[N], ans[N], n;
namespace Pref {
int pre[N], pw[N];
void Build() {
pw[0] = 1;
for (int i = 1; i <= n; i++) {
int v = expr[i] - '0';
if (expr[i] < '0' || expr[i] > '9') v = 0;
pre[i] = add(mul(pre[i - 1], 10), v);
pw[i] = mul(pw[i - 1], 10);
}
}
int EasyGet(int l, int r) {
return sub(pre[r], mul(pw[r - l + 1], pre[l - 1]));
}
}; // namespace Pref
bool work[N];
vector<int> QL[N], QR[N];
int rqa[N], lqa[N];
struct SegmentTree {
static const int M = 2 * N;
int ls[M], rs[M], tsz, root;
int lzy_add[M], lzy_mul[M], val[M];
void Build(int& c, int ss, int se) {
c = ++tsz;
lzy_add[c] = 0;
lzy_mul[c] = 1;
if (ss == se) {
val[c] = 0;
return;
}
int mid = ss + se >> 1;
Build(ls[c], ss, mid);
Build(rs[c], mid + 1, se);
}
void Build() { Build(root, 1, n); }
void upd(int c, int ad, int ml) {
val[c] = mul(val[c], ml);
val[c] = add(val[c], ad);
lzy_add[c] = mul(lzy_add[c], ml);
lzy_mul[c] = mul(lzy_mul[c], ml);
lzy_add[c] = add(lzy_add[c], ad);
}
void push(int c) {
upd(ls[c], lzy_add[c], lzy_mul[c]);
upd(rs[c], lzy_add[c], lzy_mul[c]);
lzy_add[c] = 0;
lzy_mul[c] = 1;
}
void Set(int c, int ss, int se, int qs, int qe, int ad, int ml) {
if (qs > qe || qs > se || ss > qe) return;
if (qs <= ss && qe >= se) {
upd(c, ad, ml);
return;
}
int mid = ss + se >> 1;
push(c);
Set(ls[c], ss, mid, qs, qe, ad, ml);
Set(rs[c], mid + 1, se, qs, qe, ad, ml);
}
void Add(int qs, int qe, int ad) { Set(root, 1, n, qs, qe, ad, 1); }
void Mul(int qs, int qe, int ml) { Set(root, 1, n, qs, qe, 0, ml); }
int Get(int c, int ss, int se, int qi) {
if (ss == se) return val[c];
int mid = ss + se >> 1;
push(c);
if (qi <= mid)
return Get(ls[c], ss, mid, qi);
else
return Get(rs[c], mid + 1, se, qi);
}
int Get(int qi) { return Get(root, 1, n, qi); }
void Set1(int c, int ss, int se, int qi, int v) {
if (ss == se) {
val[c] = v;
return;
}
int mid = ss + se >> 1;
push(c);
if (qi <= mid)
Set1(ls[c], ss, mid, qi, v);
else
Set1(rs[c], mid + 1, se, qi, v);
}
void Set(int qi, int v) { Set1(root, 1, n, qi, v); }
} SGL, SGR;
void SolveQsOffline(int u) {
if (type[u] == 0) {
for (int i = L[u]; i <= R[u]; i++) {
SGR.Set(i, Pref::EasyGet(L[u], i));
SGL.Set(i, Pref::EasyGet(i, R[u]));
}
} else if (type[u] == 1) {
SolveQsOffline(ls[u]);
SolveQsOffline(rs[u]);
SGL.Add(L[ls[u]], R[ls[u]], val[rs[u]]);
SGR.Add(L[rs[u]], R[rs[u]], val[ls[u]]);
} else if (type[u] == 2) {
SolveQsOffline(ls[u]);
SolveQsOffline(rs[u]);
SGL.Mul(L[ls[u]], R[ls[u]], val[rs[u]]);
SGR.Mul(L[rs[u]], R[rs[u]], val[ls[u]]);
} else {
SolveQsOffline(ls[u]);
}
for (int qi : QL[u]) {
if (type[my_node[l[qi]]] == 0)
lqa[qi] = SGL.Get(l[qi]);
else
lqa[qi] = SGL.Get(L[my_node[l[qi]]]);
}
for (int qi : QR[u]) {
if (type[my_node[r[qi]]] == 0)
rqa[qi] = SGR.Get(r[qi]);
else
rqa[qi] = SGR.Get(R[my_node[r[qi]]]);
}
}
bool Bad(int u, int p) {
int br = brup[par[u][0]] - brup[p];
return br > 0;
}
int main() {
scanf("%s", expr + 1);
n = strlen(expr + 1);
stack<int> nodes, pos;
stack<char> ops;
auto MakeMul = [&]() {
assert(ops.top() == '*');
ops.pop();
int b = nodes.top();
nodes.pop();
int a = nodes.top();
nodes.pop();
tsz++;
type[tsz] = 2;
ls[tsz] = a;
rs[tsz] = b;
nodes.push(tsz);
};
auto MakePlus = [&]() {
assert(ops.top() == '+');
ops.pop();
int b = nodes.top();
nodes.pop();
int a = nodes.top();
nodes.pop();
tsz++;
type[tsz] = 1;
ls[tsz] = a;
rs[tsz] = b;
nodes.push(tsz);
};
auto NewNumber = [&](int i) {
tsz++;
type[tsz] = 0;
L[tsz] = R[tsz] = i;
nodes.push(tsz);
};
for (int i = 1; i <= n; i++) {
if (expr[i] == '(') {
ops.push('(');
pos.push(i);
} else if (expr[i] == '+') {
while (ops.size() && ops.top() == '*') MakeMul();
ops.push('+');
} else if (expr[i] == '*') {
ops.push('*');
} else if (expr[i] == ')') {
while (ops.size() && ops.top() == '*') MakeMul();
while (ops.size() && ops.top() == '+') MakePlus();
assert(ops.top() == '(');
ops.pop();
int a = nodes.top();
nodes.pop();
tsz++;
type[tsz] = 3;
ls[tsz] = a;
nodes.push(tsz);
my_node[i] = my_node[pos.top()] = tsz;
pos.pop();
} else {
if (i == 1 || expr[i - 1] < '0' || expr[i - 1] > '9') NewNumber(i);
R[nodes.top()] = i;
my_node[i] = nodes.top();
}
}
while (ops.size() && ops.top() == '*') MakeMul();
while (ops.size() && ops.top() == '+') MakePlus();
assert(ops.empty());
assert(nodes.size() == 1);
int root = nodes.top();
DFS(root, 0);
Pref::Build();
int q;
scanf("%i", &q);
for (int i = 1; i <= q; i++) {
scanf("%i %i", &l[i], &r[i]);
if (expr[l[i]] == '+' || expr[l[i]] == '*' || expr[r[i]] == '+' ||
expr[r[i]] == '*') {
ans[i] = -1;
continue;
}
if (expr[l[i]] == ')' || expr[r[i]] == '(') {
ans[i] = -1;
continue;
}
int lnd = my_node[l[i]];
int rnd = my_node[r[i]];
if (lnd == rnd) {
if (type[lnd] == 0)
ans[i] = Pref::EasyGet(l[i], r[i]);
else {
assert(type[lnd] == 3);
ans[i] = val[lnd];
}
continue;
}
int lca = LCA(lnd, rnd);
if (lca == lnd || lca == rnd) {
ans[i] = -1;
} else if (Bad(lnd, lca) || Bad(rnd, lca)) {
ans[i] = -1;
} else {
int lup = Climb(lnd, dep[lnd] - dep[lca] - 1);
int rup = Climb(rnd, dep[rnd] - dep[lca] - 1);
work[i] = true;
QL[lup].push_back(i);
QR[rup].push_back(i);
}
}
SGL.Build();
SGR.Build();
SolveQsOffline(root);
for (int i = 1; i <= q; i++) {
if (work[i]) {
int lnd = my_node[l[i]];
int rnd = my_node[r[i]];
int lca = LCA(lnd, rnd);
if (type[lca] == 1) {
ans[i] = add(lqa[i], rqa[i]);
} else {
ans[i] = mul(lqa[i], rqa[i]);
}
}
}
for (int i = 1; i <= q; i++) printf("%i\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int ksm(int x, int y = mod - 2) {
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) z = 1ll * z * x % mod;
return z;
}
const int inv10 = ksm(10);
int n, m, pos[400100], cnt, lp[1200100], rp[1200100], tp[1200100];
int ten[400100], net[400100];
char s[400100];
vector<int> v[1200100];
vector<int> pre[1200100], zer[1200100];
stack<int> stk;
void dfs(int x) {
if (tp[x] == 0) pre[x].push_back(0);
if (tp[x] == 1) pre[x].push_back(1);
for (auto y : v[x]) {
dfs(y);
if (tp[x] == 0)
pre[x].push_back((pre[x].back() + (zer[y].empty() ? pre[y].back() : 0)) %
mod);
if (tp[x] == 1) {
if (pre[y].back() == 0)
zer[x].push_back(pre[x].size()), pre[x].push_back(pre[x].back());
else
pre[x].push_back(1ll * pre[x].back() * pre[y].back() % mod);
}
}
if (tp[x] == 2) {
if (!v[x].empty())
pre[x].push_back(pre[v[x].back()].back());
else {
pre[x].push_back(0);
for (int i = lp[x]; i <= rp[x]; i++)
pre[x].push_back((10ll * pre[x].back() + s[i] - '0') % mod);
}
}
}
int calc(int x, int l, int r) {
if (!v[x].empty()) return pre[x].back();
return (pre[x][r - lp[x] + 1] + mod -
1ll * pre[x][l - lp[x]] * ten[r - l + 1] % mod) %
mod;
}
int CALC(int x, int l, int r) {
auto it = upper_bound(zer[x].begin(), zer[x].end(), l);
if (it != zer[x].end() && *it <= r) return 0;
if (!r) return 1;
if (l == v[x].size() + 1) return 1;
return 1ll * pre[x][r] * ksm(pre[x][l + 1]) % mod;
}
int main() {
scanf("%s", s + 1), n = strlen(s + 1);
ten[0] = net[0] = 1;
for (int i = 1; i <= n; i++)
ten[i] = 10ll * ten[i - 1] % mod, net[i] = 1ll * inv10 * net[i - 1] % mod;
s[0] = '(', s[n + 1] = ')';
for (int i = 0; i <= n + 1; i++) {
if (s[i] == '(') stk.push(++cnt), lp[cnt] = i, tp[cnt] = 0;
pos[i] = stk.top();
if (s[i] == ')') rp[stk.top()] = i, stk.pop();
}
for (int i = 0; i <= n + 1; i++) {
if (s[i] == '(') {
if (!stk.empty()) v[stk.top()].push_back(pos[i]);
stk.push(pos[i]);
tp[++cnt] = 1, lp[cnt] = i + 1, stk.push(cnt);
tp[++cnt] = 2, lp[cnt] = i + 1, stk.push(cnt);
}
if (s[i] == '+') {
int tms = stk.top();
stk.pop();
rp[tms] = i - 1;
int pls = stk.top();
stk.pop();
rp[pls] = i - 1;
int bra = stk.top();
v[pls].push_back(tms);
v[bra].push_back(pls);
tp[++cnt] = 1, lp[cnt] = i + 1, stk.push(cnt);
tp[++cnt] = 2, lp[cnt] = i + 1, stk.push(cnt);
}
if (s[i] == '*') {
int tms = stk.top();
stk.pop();
rp[tms] = i - 1;
int pls = stk.top();
v[pls].push_back(tms);
tp[++cnt] = 2, lp[cnt] = i + 1, stk.push(cnt);
}
if (s[i] == ')') {
int tms = stk.top();
stk.pop();
rp[tms] = i - 1;
int pls = stk.top();
stk.pop();
rp[pls] = i - 1;
int bra = stk.top();
stk.pop();
v[pls].push_back(tms);
v[bra].push_back(pls);
}
}
dfs(1);
scanf("%d", &m);
for (int i = 1, l, r; i <= m; i++) {
scanf("%d%d", &l, &r);
if (pos[l - 1] != pos[r + 1] || s[l] == '+' || s[l] == '*' || s[r] == '+' ||
s[r] == '*') {
puts("-1");
continue;
}
int x = pos[l - 1];
lp[0] = l;
int p = upper_bound(v[x].begin(), v[x].end(), 0,
[](int a, int b) { return lp[a] < lp[b]; }) -
v[x].begin() - 1;
int P = v[x][p];
int _p = upper_bound(v[P].begin(), v[P].end(), 0,
[](int a, int b) { return lp[a] < lp[b]; }) -
v[P].begin() - 1;
int _P = v[P][_p];
rp[0] = r;
int q = lower_bound(v[x].begin(), v[x].end(), 0,
[](int a, int b) { return rp[a] < rp[b]; }) -
v[x].begin();
int Q = v[x][q];
int _q = lower_bound(v[Q].begin(), v[Q].end(), 0,
[](int a, int b) { return rp[a] < rp[b]; }) -
v[Q].begin();
int _Q = v[Q][_q];
if (p == q && _p == _q) {
printf("%d\n", calc(_P, l, r));
continue;
}
int pp = calc(_P, l, rp[_P]);
int qq = calc(_Q, lp[_Q], r);
if (p == q) {
printf("%d\n", 1ll * pp * CALC(P, _p, _q) % mod * qq % mod);
continue;
}
pp = 1ll * pp * CALC(P, _p, v[P].size()) % mod;
qq = 1ll * qq * CALC(Q, -1, _q) % mod;
printf("%d\n",
(0ll + pp + (pre[x][q] + mod - pre[x][p + 1]) % mod + qq) % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
template <int MOD>
struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
ModInt(signed long long sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
};
template <typename Val>
struct GetRangeSegmentTree {
static Val combineVal(const Val &x, const Val &y) { return x + y; }
static void assignCombineVal(Val &x, const Val &y) { x = x + y; }
static Val identityVal() { return Val(); }
vector<Val> nodes;
int n;
void init(int n_, const Val &v = Val()) { init(vector<Val>(n_, v)); }
void init(const vector<Val> &u) {
n = 1;
while (n < (int)u.size()) n *= 2;
nodes.resize(n, identityVal());
nodes.insert(nodes.end(), u.begin(), u.end());
nodes.resize(n * 2, identityVal());
for (int i = n - 1; i > 0; --i)
nodes[i] = combineVal(nodes[i * 2], nodes[i * 2 + 1]);
}
Val get(int i) { return nodes[i + n]; }
Val getWhole() const { return nodes[1]; }
Val getRange(int l, int r) const {
Val m = identityVal();
int indices[64];
int k = 0;
for (; l && l + (l & -l) <= r; l += l & -l)
assignCombineVal(m, nodes[(n + l) / (l & -l)]);
for (; l < r; r -= r & -r) indices[k++] = (n + r) / (r & -r) - 1;
while (--k >= 0) assignCombineVal(m, nodes[indices[k]]);
return m;
}
Val getRangeCommutative(int l, int r) const {
Val m = identityVal();
for (; l && l + (l & -l) <= r; l += l & -l)
assignCombineVal(m, nodes[(n + l) / (l & -l)]);
for (; l < r; r -= r & -r)
assignCombineVal(m, nodes[(n + r) / (r & -r) - 1]);
return m;
}
void set(int i, const Val &x) {
i += n;
nodes[i] = x;
for (i >>= 1; i > 0; i >>= 1)
nodes[i] = combineVal(nodes[i * 2], nodes[i * 2 + 1]);
}
};
typedef const char *Pos;
int nNodes;
char expr[400001];
struct Node {
int type;
int parent;
int left, right;
vector<int> children;
};
vector<int> nodeId;
vector<Node> nodes;
vector<int> postOrder;
int getIndex(Pos p) { return (int)(p - expr); }
int newNode(int type) {
nodes.push_back(Node{type, -1, -1, -1, {}});
return nNodes++;
}
int p_expr(Pos &p, int t);
int p_term(Pos &p) {
if (*p == '(') {
int i = getIndex(p);
++p;
int node = p_expr(p, 0);
assert(*p == ')');
int j = getIndex(p);
++p;
nodeId[i] = nodeId[j] = node;
return node;
} else if (isdigit(*p)) {
int left = getIndex(p);
int node = newNode(2);
while (isdigit(*p)) {
nodeId[getIndex(p)] = node;
++p;
}
postOrder.push_back(node);
nodes[node].left = left;
nodes[node].right = getIndex(p);
return node;
} else {
return -1;
}
}
int p_expr(Pos &p, int t) {
int left = getIndex(p);
int x = t == 0 ? p_expr(p, t + 1) : p_term(p);
if (x == -1) return -1;
int node = newNode(t);
nodes[x].parent = node;
nodes[node].children.push_back(x);
while (*p == (t == 0 ? '+' : '*')) {
++p;
int y = t == 0 ? p_expr(p, t + 1) : p_term(p);
assert(y != -1);
nodes[y].parent = node;
nodes[node].children.push_back(y);
}
postOrder.push_back(node);
nodes[node].left = left;
nodes[node].right = getIndex(p);
return node;
}
struct Paren {
int sum, mini;
Paren() : Paren(0) {}
explicit Paren(int x) : sum(x), mini(min(x, 0)) {}
Paren operator+(const Paren &that) const {
Paren res;
res.sum = sum + that.sum;
res.mini = min(mini, sum + that.mini);
return res;
}
};
struct Digits {
ModInt<1000000007> num, pow;
Digits() : num(), pow(1) {}
explicit Digits(int d) : num(d), pow(10) {}
Digits operator+(const Digits &that) const {
Digits res;
res.num = num * that.pow + that.num;
res.pow = pow * that.pow;
return res;
}
};
struct SumProd {
ModInt<1000000007> sum, prod;
SumProd() : sum(), prod(1) {}
explicit SumProd(ModInt<1000000007> x) : sum(x), prod(x) {}
SumProd(ModInt<1000000007> sum, ModInt<1000000007> prod)
: sum(sum), prod(prod) {}
SumProd operator+(const SumProd &that) const {
return SumProd(sum + that.sum, prod * that.prod);
}
};
namespace naive {
bool p_expr(Pos &p, int t, ModInt<1000000007> &res);
bool p_term(Pos &p, ModInt<1000000007> &res) {
if (*p == '(') {
++p;
p_expr(p, 0, res);
if (*p != ')') throw 0;
++p;
return true;
} else if (isdigit(*p)) {
res = ModInt<1000000007>();
while (isdigit(*p)) {
res = res * 10 + (*p - '0');
++p;
}
return true;
} else {
return false;
}
}
bool p_expr(Pos &p, int t, ModInt<1000000007> &res) {
if (!(t == 0 ? p_expr(p, t + 1, res) : p_term(p, res))) return false;
while (*p == (t == 0 ? '+' : '*')) {
++p;
ModInt<1000000007> x;
if (!(t == 0 ? p_expr(p, t + 1, x) : p_term(p, x))) throw 0;
if (t == 0)
res += x;
else
res *= x;
}
return true;
}
} // namespace naive
int main() {
while (~scanf("%s", expr)) {
int len = (int)strlen(expr);
int root;
nNodes = 0;
nodes.clear();
nodeId.assign(len, -1);
postOrder.clear();
{
Pos p = expr;
root = p_expr(p, 0);
assert(root != -1);
assert(*p == '\0');
}
vector<int> t_ord = postOrder, t_parent(nNodes);
reverse(t_ord.begin(), t_ord.end());
for (int(i) = 0; (i) < (int)(nNodes); ++(i)) t_parent[i] = nodes[i].parent;
vector<int> depth(nNodes, -1);
depth[root] = 0;
for (int ix = 1; ix < (int)t_ord.size(); ++ix) {
int i = t_ord[ix], p = t_parent[i];
depth[i] = depth[p] + 1;
}
GetRangeSegmentTree<Paren> segtParen;
vector<Paren> parentheses(len);
for (int(i) = 0; (i) < (int)(len); ++(i))
parentheses[i] = Paren(expr[i] == '(' ? 1 : expr[i] == ')' ? -1 : 0);
segtParen.init(parentheses);
GetRangeSegmentTree<Digits> segtDigits;
vector<Digits> digits(len);
for (int(i) = 0; (i) < (int)(len); ++(i))
if (isdigit(expr[i])) digits[i] = Digits(expr[i] - '0');
segtDigits.init(digits);
vector<ModInt<1000000007>> values(nNodes);
vector<GetRangeSegmentTree<SumProd>> segtSumProds(nNodes);
vector<SumProd> tmpSumProds;
vector<vector<int>> childLefts(nNodes), childRights(nNodes);
for (int ix = (int)t_ord.size() - 1; ix >= 0; --ix) {
int i = t_ord[ix];
auto &n = nodes[i];
int l = n.left, r = n.right;
if (n.type == 2) {
values[i] = segtDigits.getRange(l, r).num;
} else {
childLefts[i].reserve(n.children.size());
childRights[i].reserve(n.children.size());
tmpSumProds.clear();
for (int j : n.children) {
childLefts[i].push_back(nodes[j].left);
childRights[i].push_back(nodes[j].right);
tmpSumProds.emplace_back(values[j]);
}
segtSumProds[i].init(tmpSumProds);
SumProd sp = segtSumProds[i].getWhole();
values[i] = n.type == 0 ? sp.sum : sp.prod;
}
}
auto calc = [&](int node, int l, int r) -> ModInt<1000000007> {
int type = nodes[node].type;
if (type == 2) {
int L = max(l, nodes[node].left);
int R = min(r, nodes[node].right);
return segtDigits.getRange(L, R).num;
} else {
int L = (int)(lower_bound(childLefts[node].begin(),
childLefts[node].end(), l) -
childLefts[node].begin());
int R = (int)(lower_bound(childRights[node].begin(),
childRights[node].end(), r) -
childRights[node].begin());
SumProd sp = segtSumProds[node].getRangeCommutative(L, R);
return type == 0 ? sp.sum : sp.prod;
}
};
auto combine = [&](int node, ModInt<1000000007> x,
ModInt<1000000007> y) -> ModInt<1000000007> {
int type = nodes[node].type;
if (type == 0)
return x + y;
else if (type == 1)
return x * y;
assert(false);
return ModInt<1000000007>();
};
int q;
scanf("%d", &q);
for (int(ii) = 0; (ii) < (int)(q); ++(ii)) {
int l;
int r;
scanf("%d%d", &l, &r), --l;
bool ok = true;
Paren paren = segtParen.getRange(l, r);
ok &= paren.sum == 0;
ok &= paren.mini == 0;
int nodeL = nodeId[l], nodeR = nodeId[r - 1];
ok &= nodeL != -1;
ok &= nodeR != -1;
if (!ok) {
puts("-1");
continue;
}
int x = nodeL, y = nodeR;
ModInt<1000000007> valx = calc(x, l, r), valy = calc(y, l, r);
while (x != y) {
if (t_parent[x] == t_parent[y]) {
int p = t_parent[x];
valx = valy = combine(
p, combine(p, valx, calc(p, nodes[x].right, nodes[y].left)),
valy);
x = y = p;
} else if (depth[x] >= depth[y]) {
int p = t_parent[x];
valx = combine(p, valx, calc(p, nodes[x].right, r));
x = p;
} else {
int p = t_parent[y];
valy = combine(p, calc(p, l, nodes[y].left), valy);
y = p;
}
}
assert(valx.get() == valy.get());
ModInt<1000000007> ans = valx;
printf("%d\n", ans.get());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500000;
const int mod = 1000000007;
char s[N];
struct block;
block *bl[N];
int poww[N];
stack<block *> blocks;
void next(int &it) {
if (blocks.empty())
it++;
else
bl[it++] = blocks.top();
}
int power(int a, int b) {
if (b == 0) return 1;
if (b & 1) return 1LL * a * power(a, b - 1) % mod;
return power(1LL * a * a % mod, b / 2);
}
int inv(int a) { return power(a, mod - 2); }
struct expr {
int a, b;
int val;
virtual int _get(int A, int B) { return 0; };
int get(int A, int B) {
A = max(a, A);
B = min(b, B);
if (a == A && b == B) {
return val;
}
return _get(A, B);
}
expr(int A, int B) : a(A), b(B) {}
expr() = default;
};
struct num : expr {
vector<int> pref;
num(int &it) {
a = it;
val = 0;
pref.push_back(0);
while (isdigit(s[it])) {
val = (1LL * val * 10 + s[it] - '0') % mod;
next(it);
pref.push_back(val);
}
b = it;
}
int _get(int A, int B) {
int ans = (pref[B - a] - 1LL * pref[A - a] * poww[B - A]) % mod;
if (ans < 0) ans += mod;
return ans;
}
};
struct prod : expr {
vector<expr *> vec;
vector<int> res;
prod(int &it);
int _get(int A, int B) {
auto e = new expr(A, B);
auto it1 = upper_bound(vec.begin(), vec.end(), e,
[](expr *a, expr *b) { return a->a < b->a; });
auto it2 = lower_bound(vec.begin(), vec.end(), e,
[](expr *a, expr *b) { return a->b < b->b; });
delete e;
int ans = 1;
if (it2 > it1)
ans = 1LL * res[it2 - vec.begin()] * inv(res[it1 - vec.begin()]) % mod;
if (it2 != vec.end()) ans = 1LL * ans * (*it2)->get(A, B) % mod;
if (it1 != vec.begin() && --it1 != it2)
ans = 1LL * ans * (*it1)->get(A, B) % mod;
return ans;
}
};
struct block : expr {
vector<expr *> vec;
vector<int> res;
block(int &it) {
val = 0;
a = it;
assert(s[it] == '(');
next(it);
blocks.push(this);
res.push_back(0);
while (true) {
vec.push_back(new prod(it));
val = (val + vec.back()->val) % mod;
res.push_back(val);
if (s[it] != '+')
break;
else
next(it);
}
blocks.pop();
assert(s[it] = ')');
next(it);
b = it;
}
int _get(int A, int B) {
if (a == A || b == B) return -1;
auto e = new expr(A, B);
auto it1 = upper_bound(vec.begin(), vec.end(), e,
[](expr *a, expr *b) { return a->a < b->a; });
auto it2 = lower_bound(vec.begin(), vec.end(), e,
[](expr *a, expr *b) { return a->b < b->b; });
delete e;
int ans = 0;
if (it2 > it1) ans = res[it2 - vec.begin()] - res[it1 - vec.begin()];
if (ans < 0) ans += mod;
if (it2 != vec.end()) ans = (ans + (*it2)->get(A, B)) % mod;
if (it1 != vec.begin() && --it1 != it2)
ans = (ans + (*it1)->get(A, B)) % mod;
return ans;
}
};
prod::prod(int &it) {
val = 1;
a = it;
res.push_back(1);
while (true) {
if (s[it] == '(')
vec.push_back(new block(it));
else
vec.push_back(new num(it));
val = 1LL * val * vec.back()->val % mod;
res.push_back(val);
if (s[it] != '*')
break;
else
next(it);
}
b = it;
}
int main() {
poww[0] = 1;
for (int i = 1; i < N; i++) poww[i] = poww[i - 1] * 10LL % mod;
scanf("%s", s + 1);
s[0] = '(';
s[strlen(s)] = ')';
int i = 0;
new block(i);
int n;
scanf("%d", &n);
while (n--) {
int a, b;
scanf("%d %d", &a, &b);
if ((!isdigit(s[a]) && s[a] != '(') || (!isdigit(s[b]) && s[b] != ')') ||
bl[a] != bl[b]) {
puts("-1");
continue;
}
printf("%d\n", bl[a]->get(a, b + 1));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int powten[400005];
template <typename Func, int B>
struct stree {
int n;
vector<int> nodes;
Func op;
explicit stree(int n_) {
for (n = 1; n <= n_; n *= 2)
;
nodes.resize(n * 2 + 1, B);
}
void update(int pos, int val) {
val %= MOD;
pos += n;
nodes[pos] = val;
while (pos >>= 1) {
nodes[pos] = op(nodes[pos << 1], nodes[pos << 1 | 1]) % MOD;
}
}
int get(int s, int e) {
if (e >= n) e = n - 1;
int ret = B;
s += n;
e += n;
while (s <= e) {
if (s & 1) ret = op(ret, nodes[s++]) % MOD;
if ((e & 1) == 0) ret = op(ret, nodes[e--]) % MOD;
s >>= 1;
e >>= 1;
}
return ret;
}
};
using sumtree = stree<plus<int>, 0>;
using multree = stree<multiplies<long long>, 1>;
struct numtree {
int n, l, mulidx, chidx;
bool single = false;
vector<pair<int, int>> nodes;
explicit numtree(int n_, int mulidx, int chidx, int l)
: l(l), mulidx(mulidx), chidx(chidx) {
for (n = 1; n <= n_; n *= 2)
;
nodes.resize(n * 2 + 1);
}
pair<int, int> merge(pair<int, int> p1, pair<int, int> p2) {
return {(p1.first * (long long)powten[p2.second] + p2.first) % MOD,
p1.second + p2.second};
}
void update(int pos, int val) {
pos += n;
nodes[pos] = {val, 1};
while (pos >>= 1) {
nodes[pos] = merge(nodes[pos << 1], nodes[pos << 1 | 1]);
}
}
int get(int s, int e) {
if (e >= n) e = n - 1;
pair<int, int> left = {0, 0}, right = {0, 0};
s += n;
e += n;
while (s <= e) {
if (s & 1) left = merge(left, nodes[s++]);
if ((e & 1) == 0) right = merge(nodes[e--], right);
s >>= 1;
e >>= 1;
}
return merge(left, right).first;
}
};
struct paren {
int l, r;
vector<paren *> childs;
vector<int> queries;
};
pair<int, int> query[400005];
char dat[400005];
paren *pid[400005];
int len;
int ans[400005];
paren root;
void parse_paren() {
stack<paren *> stk;
stk.push(&root);
for (int i = 1; i < len - 1; i++) {
pid[i] = stk.top();
if (dat[i] == '(') {
stk.top()->childs.push_back(new paren{});
auto p = stk.top()->childs.back();
p->l = i;
stk.push(p);
} else if (dat[i] == ')') {
stk.top()->r = i;
stk.pop();
pid[i] = stk.top();
}
}
}
inline bool isop(char ch) { return ch == '*' || ch == '+'; }
int dfs(paren *node) {
vector<int> cval;
auto &&chd = node->childs;
for (auto &&p : chd) cval.push_back(dfs(p));
map<pair<int, int>, numtree *> mp;
vector<multree> multrees;
vector<numtree *> numtrees;
int cidx = 0;
for (int i = node->l + 1; i <= node->r; i++) {
if (i == node->r || dat[i] == '+') {
int midx = multrees.size();
multrees.emplace_back(numtrees.size());
for (int j = 0; j < numtrees.size(); j++) {
numtrees[j]->mulidx = midx;
numtrees[j]->chidx = j;
multrees.back().update(j, numtrees[j]->nodes[1].first);
}
numtrees.clear();
} else if (cidx < chd.size() && chd[cidx]->l == i) {
numtrees.emplace_back(new numtree(1, 0, 0, i));
numtrees.back()->single = true;
numtrees.back()->update(0, cval[cidx]);
mp[make_pair(i, chd[cidx]->r)] = numtrees.back();
i = chd[cidx]->r;
cidx++;
continue;
} else if (dat[i] >= '0' && dat[i] <= '9') {
int j;
for (j = i + 1; j <= node->r - 1 && dat[j] >= '0' && dat[j] <= '9'; j++)
;
j--;
numtrees.emplace_back(new numtree(j - i + 1, 0, 0, i));
mp[make_pair(i, j)] = numtrees.back();
while (i <= j) {
numtrees.back()->update(i - numtrees.back()->l, dat[i] - '0');
i++;
}
i--;
}
}
sumtree sumt(multrees.size());
for (int i = 0; i < multrees.size(); i++) {
sumt.update(i, multrees[i].nodes[1]);
}
for (int q : node->queries) {
int l = query[q].first, r = query[q].second;
auto &&itr1 = mp.lower_bound(make_pair(l, 0));
if (itr1 == mp.end() || itr1->first.first > l) {
--itr1;
}
auto &&itr2 = mp.lower_bound(make_pair(r, 0));
if (itr2 == mp.end() || itr2->first.first > r) {
--itr2;
}
if (itr1 == itr2) {
ans[q] = itr1->second->get(l - itr1->second->l, r - itr1->second->l);
} else {
int midx1 = itr1->second->mulidx;
int midx2 = itr2->second->mulidx;
int org11 = multrees[midx1].get(itr1->second->chidx, itr1->second->chidx);
int org12 = multrees[midx2].get(itr2->second->chidx, itr2->second->chidx);
if (itr1->second->single == false)
multrees[midx1].update(
itr1->second->chidx,
itr1->second->get(l - itr1->second->l, itr1->second->n - 1));
if (itr2->second->single == false)
multrees[midx2].update(itr2->second->chidx,
itr2->second->get(0, r - itr2->second->l));
if (midx1 == midx2) {
ans[q] = multrees[midx1].get(itr1->second->chidx, itr2->second->chidx);
} else {
int org1 = sumt.get(midx1, midx1);
int org2 = sumt.get(midx2, midx2);
sumt.update(midx1, multrees[midx1].get(itr1->second->chidx,
multrees[midx1].n - 1));
sumt.update(midx2, multrees[midx2].get(0, itr2->second->chidx));
ans[q] = sumt.get(midx1, midx2);
sumt.update(midx1, org1);
sumt.update(midx2, org2);
}
multrees[midx1].update(itr1->second->chidx, org11);
multrees[midx2].update(itr2->second->chidx, org12);
}
}
for (auto &&e : mp) delete e.second;
return sumt.nodes[1];
}
int main() {
powten[0] = 1;
for (int i = 1; i <= 400000; i++)
powten[i] = (long long)powten[i - 1] * 10 % MOD;
dat[0] = '(';
scanf("%s", dat + 1);
len = strlen(dat);
dat[len++] = ')';
root.l = 0;
root.r = len - 1;
pid[0] = pid[len - 1] = &root;
parse_paren();
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &query[i].first, &query[i].second);
if (pid[query[i].first] == nullptr ||
pid[query[i].first] != pid[query[i].second] ||
isop(dat[query[i].first]) || isop(dat[query[i].second]) ||
dat[query[i].first] == ')' || dat[query[i].second] == '(') {
ans[i] = -1;
} else {
pid[query[i].first]->queries.push_back(i);
}
}
dfs(&root);
for (int i = 0; i < q; i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9) + 7;
using lint = long long;
struct modint {
int v;
modint(int v_ = 0) : v(v_ % MOD) {}
modint operator+(const modint &m) const { return modint(v + m.v); }
modint operator-(const modint &m) const { return modint(v - m.v + MOD); }
modint operator*(const modint &m) const {
return modint((lint)v * m.v % MOD);
}
modint operator+=(const modint m) {
v = (v + m.v) % MOD;
return *this;
}
modint operator*=(const modint m) {
v = (lint(v) * m.v) % MOD;
return *this;
}
modint inv() const {
modint ret = 1, base = v;
int ex = MOD - 2;
while (ex > 0) {
if (ex & 1) ret *= base;
base *= base;
ex >>= 1;
}
return ret;
}
};
const int N_ = int(4.1e5);
char S[N_];
int IDX;
void print_spaces(int n) {
while (n--) putchar(' ');
}
struct Expression {
int l, r;
modint value;
vector<Expression *> ch;
vector<modint> pref;
virtual modint calc(int s, int e) { return 0; };
int left_bound(int x) {
int low = 0, high = int(ch.size()) - 1;
int pos = ch.size();
x += 1;
while (low <= high) {
int mid = (low + high) >> 1;
if (x <= ch[mid]->l) {
pos = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return pos;
}
int right_bound(int x) {
int low = 0, high = int(ch.size()) - 1;
int pos = -1;
while (low <= high) {
int mid = (low + high) >> 1;
if (ch[mid]->r >= x) {
high = mid - 1;
pos = mid;
} else {
low = mid + 1;
}
}
return pos;
}
modint get(int s, int e) {
if (0) printf("s=%d e=%d l=%d r=%d\n", s, e, l, r);
return (max(l, s) == l && min(r, e) == r) ? value
: calc(max(l, s), min(r, e));
}
virtual void print(int){};
};
vector<Expression *> stk;
Expression *wh[N_];
void adv() { wh[IDX++] = stk.empty() ? NULL : stk.back(); }
modint pw10[N_];
modint pwinv10[N_];
const modint INV10 = modint(10).inv();
struct Number : Expression {
Number() {
value = 0;
pref.push_back(0);
l = IDX;
for (; isdigit(S[IDX]); adv()) {
value = value * 10 + (S[IDX] - '0');
pref.push_back(value);
r = IDX;
}
}
modint calc(int s, int e) {
if (0) printf(" Number calc %d %d\n", s, e);
e -= l - 1;
s -= l - 1;
return (pref[e] - pref[s - 1] * pw10[e - s + 1]);
}
void print(int indent) {}
};
struct Hang : Expression {
Hang();
void print(int indent) {}
modint calc(int s, int e) {
int i = left_bound(s);
int j = right_bound(e);
if (0) printf(" Hang calc %d %d [%d, %d]\n", s, e, i, j);
for (Expression *xx : ch) {
if (0) printf(" (%d, %d) ", xx->l, xx->r);
}
if (0) printf("\n");
for (modint v : pref) {
if (0) printf(" %d ", v.v);
}
if (0) printf("\n");
modint ret = 1;
if (i < j) {
ret *= pref[j] * pref[i].inv();
}
i -= 1;
if (i >= 0) {
ret *= ch[i]->get(s, e);
}
if (i != j && j < ch.size()) {
ret *= ch[j]->get(s, e);
}
if (0) printf(" HANG calc %d %d returned %d\n", s, e, ret.v);
return ret;
}
};
struct SAE : Expression {
SAE() {
value = 0;
pref.push_back(0);
l = IDX;
assert(S[IDX] == '(');
adv();
stk.push_back(this);
while (true) {
ch.push_back(new Hang());
value += ch.back()->value;
pref.push_back(value);
if (S[IDX] != '+') {
break;
}
adv();
}
r = IDX;
stk.pop_back();
assert(S[IDX] == ')');
adv();
}
modint calc(int s, int e) {
int i = left_bound(s);
int j = right_bound(e);
if (0) printf(" SAE calc %d %d [%d, %d]\n", s, e, i, j);
for (Expression *xx : ch) {
if (0) printf(" (%d, %d) ", xx->l, xx->r);
}
if (0) printf("\n");
for (modint v : pref) {
if (0) printf(" %d ", v.v);
}
if (0) printf("\n");
modint ret = 0;
if (i < j) {
ret += pref[j] - pref[i];
}
i -= 1;
if (i >= 0) {
ret += ch[i]->get(s, e);
}
if (i != j && j < ch.size()) {
ret += ch[j]->get(s, e);
}
if (0) printf(" SAE calc %d %d returned %d\n", s, e, ret.v);
return ret;
}
void print(int indent) {
if (0) printf(" value = %d\n", value.v);
}
};
Hang::Hang() {
value = 1;
pref.push_back(1);
l = IDX;
while (true) {
if (S[IDX] == '(') {
ch.push_back(new SAE());
} else {
ch.push_back(new Number());
}
value *= ch.back()->value;
pref.push_back(value);
if (S[IDX] != '*') break;
adv();
}
r = IDX - 1;
}
int N;
int main() {
pwinv10[0] = 1;
pw10[0] = 1;
assert((INV10 * 10).v == 1);
for (int i = 1; i < N_; i++) {
pw10[i] = pw10[i - 1] * 10;
pwinv10[i] = pwinv10[i - 1] * INV10;
}
S[0] = '(';
scanf("%s", S + 1);
S[strlen(S + 1) + 1] = ')';
N = strlen(S);
new SAE();
int Q;
scanf("%d", &Q);
while (Q--) {
int l, r;
scanf("%d%d", &l, &r);
bool good = true;
good &= isdigit(S[l]) || (S[l] == '(');
good &= isdigit(S[r]) || (S[r] == ')');
good &= (wh[l] == wh[r]);
if (good) {
printf("%d\n", wh[l]->get(l, r).v);
} else {
printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int xn = 400008;
const long long MOD = 1000000007;
int N, Q, D, pb[xn], pp[xn], pm[xn], sb[xn], sp[xn], sm[xn], Lb[xn], Lp[xn],
Lm[xn];
char a[xn];
long long P10[xn], iP10[xn], Ab[xn], Ap[xn], Az[xn], Am[xn], ab[xn], ap[xn],
az[xn], am[xn], hb[xn], hp[xn], hz[xn], hm[xn], tb[xn], tp[xn], tz[xn],
tm[xn];
long long INV(long long x) {
long long r = 1;
for (long long b = MOD - 2; b; b >>= 1) {
if (b & 1) r = r * x % MOD;
x = x * x % MOD;
}
return r;
}
long long F(int l, int r) {
if (a[l] == '+' || a[l] == '*' || a[l] == ')') return -1;
if (a[r] == '+' || a[r] == '*' || a[r] == '(') return -1;
if (sb[pb[l]] != sb[r]) return -1;
int lep = pp[l], rip = sp[r];
if (sp[lep] != rip)
return (hb[r] + tb[l] - ab[pb[l]] + MOD) % MOD;
else {
int lem = pm[l], rim = sm[r];
if (sm[lem] != rim)
return hz[r] + tz[l] == az[pp[l]]
? hp[r] * tp[l] % MOD * INV(ap[pp[l]]) % MOD
: 0;
else
return (hm[r] + (tm[l] - am[pm[l]] + MOD) * iP10[rim - r - 1]) % MOD;
}
return 0;
}
int main() {
scanf("%s", a + 2);
while (a[N + 2]) N++;
N += 2;
a[1] = '(', a[N] = ')';
iP10[0] = P10[0] = 1;
for (int i = 1; i <= N; i++) {
P10[i] = P10[i - 1] * 10 % MOD;
iP10[i] = iP10[i - 1] * 700000005 % MOD;
}
for (int i = 1; i <= N; i++) {
if (a[i] == '(') {
pb[i] = Lb[D];
pp[i] = Lp[D];
pm[i] = Lm[D];
D++;
Lb[D] = Lp[D] = Lm[D] = i;
Az[D] = Ab[D] = Am[D] = 0;
Ap[D] = 1;
} else if (a[i] == '+') {
pb[i] = Lb[D];
pp[i] = Lp[D];
pm[i] = Lm[D];
ap[Lp[D]] = Ap[D] * (Am[D] ? Am[D] : 1) % MOD;
az[Lp[D]] = Az[D] + !Am[D];
am[Lm[D]] = Am[D];
Lp[D] = Lm[D] = i;
Ab[D] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
Ap[D] = 1;
Az[D] = 0;
Am[D] = 0;
} else if (a[i] == '*') {
pb[i] = Lb[D];
pp[i] = Lp[D];
pm[i] = Lm[D];
am[Lm[D]] = Am[D];
Lm[D] = i;
Ap[D] = Ap[D] * (Am[D] ? Am[D] : 1) % MOD;
Az[D] = Az[D] + !Am[D];
Am[D] = 0;
} else if (a[i] >= '0' && a[i] <= '9') {
pb[i] = Lb[D];
pp[i] = Lp[D];
pm[i] = Lm[D];
Am[D] = (Am[D] * 10 + a[i] - 48) % MOD;
hb[i] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
hp[i] = Ap[D] * (Am[D] ? Am[D] : 1) % MOD;
hz[i] = Az[D] + !Am[D];
hm[i] = Am[D];
} else {
ab[Lb[D]] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
ap[Lp[D]] = Ap[D] * (Am[D] ? Am[D] : 1) % MOD;
az[Lp[D]] = Az[D] + !Am[D];
am[Lm[D]] = Am[D];
pb[i] = Lb[D];
pp[i] = Lp[D];
pm[i] = Lm[D];
Am[D - 1] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
D--;
hb[i] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
hp[i] = Ap[D] * (Am[D] ? Am[D] : 1) % MOD;
hz[i] = Az[D] + !Am[D];
hm[i] = Am[D];
}
}
for (int i = N, l = -1; i; i--) {
if (a[i] >= '0' && a[i] <= '9')
l++;
else
l = -1;
if (a[i] == ')') {
sb[i] = Lb[D];
sp[i] = Lp[D];
sm[i] = Lm[D];
D++;
Lb[D] = Lp[D] = Lm[D] = i;
Az[D] = Ab[D] = Am[D] = 0;
Ap[D] = 1;
} else if (a[i] == '+') {
sb[i] = Lb[D];
sp[i] = Lp[D];
sm[i] = Lm[D];
Lp[D] = Lm[D] = i;
Ab[D] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
Ap[D] = 1;
Az[D] = 0;
Am[D] = 0;
} else if (a[i] == '*') {
sb[i] = Lb[D];
sp[i] = Lp[D];
sm[i] = Lm[D];
Lm[D] = i;
Ap[D] = Ap[D] * (Am[D] ? Am[D] : 1) % MOD;
Az[D] = Az[D] + !Am[D];
Am[D] = 0;
} else if (a[i] >= '0' && a[i] <= '9') {
sb[i] = Lb[D];
sp[i] = Lp[D];
sm[i] = Lm[D];
Am[D] = (Am[D] + P10[l] * (a[i] - 48)) % MOD;
tb[i] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
tp[i] = Ap[D] * (Am[D] ? Am[D] : 1) % MOD;
tz[i] = Az[D] + !Am[D];
tm[i] = Am[D];
} else {
sb[i] = Lb[D];
sp[i] = Lp[D];
sm[i] = Lm[D];
Am[D - 1] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
D--;
tb[i] = (Ab[D] + (Az[D] ? 0 : Ap[D]) * Am[D]) % MOD;
tp[i] = Ap[D] * (Am[D] ? Am[D] : 1) % MOD;
tz[i] = Az[D] + !Am[D];
tm[i] = Am[D];
}
}
for (scanf("%d", &Q); Q--;) {
int l, r;
scanf("%d%d", &l, &r);
printf("%I64d\n", F(l + 1, r + 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 400000;
const int MOD = 1000000007;
int mypow(int x, int n) {
int ret = 1;
while (true) {
if (n & 1) ret = (long long)ret * x % MOD;
if ((n >>= 1) == 0) break;
x = (long long)x * x % MOD;
}
return ret;
}
int inv(int x) {
assert(x != 0);
return mypow(x, MOD - 2);
}
int n, nq;
char s[MAXN + 1];
int match[MAXN];
int stck[MAXN], nstck;
int numb[MAXN], nnumb, numbval[MAXN], numbstart[MAXN], numbend[MAXN];
int term[MAXN], nterm, termval[MAXN], termstart[MAXN], termend[MAXN];
int expr[MAXN], nexpr, exprval[MAXN];
int p10[MAXN + 1];
int digsum[MAXN + 1];
int zerosum[MAXN + 1], numbprod[MAXN + 1];
int termsum[MAXN + 1];
int parsenumb(int &at) {
numbstart[nnumb] = at;
if (s[at] == '(') {
numbval[nnumb] = exprval[expr[at + 1]];
numb[at] = nnumb, term[at] = nterm, expr[at] = nexpr;
at = match[at];
numb[at] = nnumb, term[at] = nterm, expr[at] = nexpr;
++at;
} else if (isdigit(s[at])) {
numbval[nnumb] = 0;
while (isdigit(s[at])) {
numb[at] = nnumb, term[at] = nterm, expr[at] = nexpr;
numbval[nnumb] = ((long long)numbval[nnumb] * 10 + s[at] - '0') % MOD;
++at;
}
} else
assert(false);
numbend[nnumb] = at - 1;
return numbval[nnumb++];
}
int parseterm(int &at) {
termstart[nterm] = nnumb;
termval[nterm] = parsenumb(at);
while (s[at] == '*') {
++at;
termval[nterm] = (long long)termval[nterm] * parsenumb(at) % MOD;
}
termend[nterm] = nnumb - 1;
return termval[nterm++];
}
int parseexpr(int &at) {
exprval[nexpr] = parseterm(at);
while (s[at] == '+') {
++at;
exprval[nexpr] = (exprval[nexpr] + parseterm(at)) % MOD;
}
return exprval[nexpr++];
}
int solvesamenumb(int l, int r) {
if (s[l] == '(') return numbval[numb[l]];
return (digsum[r + 1] + MOD - (long long)p10[r - l + 1] * digsum[l] % MOD) %
MOD;
}
int solvesameterm(int l, int r) {
int nzero = zerosum[r + 1] - zerosum[l];
if (nzero != 0) return 0;
return (long long)numbprod[r + 1] * inv(numbprod[l]) % MOD;
}
int solvesameexpr(int l, int r) {
return (termsum[r + 1] + MOD - termsum[l]) % MOD;
}
int solve(int l, int r) {
if (!isdigit(s[l]) && s[l] != '(') return -1;
if (!isdigit(s[r]) && s[r] != ')') return -1;
if (numb[l] == numb[r]) return solvesamenumb(l, r);
if (term[l] == term[r]) {
int a = solvesamenumb(l, numbend[numb[l]]);
int b = solvesameterm(numb[l] + 1, numb[r] - 1);
int c = solvesamenumb(numbstart[numb[r]], r);
return (long long)a * b % MOD * c % MOD;
}
if (expr[l] == expr[r]) {
int a = solvesamenumb(l, numbend[numb[l]]);
int b = solvesameterm(numb[l] + 1, termend[term[l]]);
int c = solvesameexpr(term[l] + 1, term[r] - 1);
int d = solvesameterm(termstart[term[r]], numb[r] - 1);
int e = solvesamenumb(numbstart[numb[r]], r);
return ((long long)a * b + c + (long long)d * e) % MOD;
}
return -1;
}
void run() {
scanf("%s", s);
n = strlen(s);
memset(match, -1, sizeof(match));
nstck = 0;
for (int i = (0); i < (n); ++i)
if (s[i] == '(')
stck[nstck++] = i;
else if (s[i] == ')')
assert(nstck > 0), match[i] = stck[nstck - 1], match[stck[nstck - 1]] = i,
--nstck;
assert(nstck == 0);
memset(numb, -1, sizeof(numb));
memset(term, -1, sizeof(term));
memset(expr, -1, sizeof(expr));
nnumb = nterm = nexpr = 0;
for (int i = n - 1; i >= 0; --i)
if (s[i] == '(') {
int at = i + 1;
parseexpr(at);
assert(at == match[i]);
}
{
int at = 0;
parseexpr(at);
assert(at == n);
}
p10[0] = 1;
for (int i = (0); i < (n); ++i) p10[i + 1] = (long long)10 * p10[i] % MOD;
digsum[0] = 0;
for (int i = (0); i < (n); ++i)
digsum[i + 1] =
((long long)10 * digsum[i] + (isdigit(s[i]) ? s[i] - '0' : 0)) % MOD;
zerosum[0] = 0;
for (int i = (0); i < (nnumb); ++i)
zerosum[i + 1] = zerosum[i] + (numbval[i] == 0 ? 1 : 0);
numbprod[0] = 1;
for (int i = (0); i < (nnumb); ++i)
numbprod[i + 1] =
(long long)numbprod[i] * (numbval[i] == 0 ? 1 : numbval[i]) % MOD;
termsum[0] = 0;
for (int i = (0); i < (nterm); ++i)
termsum[i + 1] = (termsum[i] + termval[i]) % MOD;
scanf("%d", &nq);
for (int qi = (0); qi < (nq); ++qi) {
int l, r;
scanf("%d%d", &l, &r);
--l, --r;
printf("%d\n", solve(l, r));
}
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m) {
string st1[1005], st2[1005];
for (int i = 1; i <= n; i++) cin >> st1[i];
for (int i = 1; i <= m; i++) cin >> st2[i];
int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (st1[i] == st2[j]) ans++;
n -= ans / 2;
m -= ans / 2;
if (ans % 2) m--;
if (n > m)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Emsawy() {}
int dx[]{1, -1, 0, 0, 1, -1, 1, -1};
int dy[]{0, 0, 1, -1, 1, -1, -1, 1};
long long suf(long long x) { return (x * (x + 1)) / 2; }
vector<vector<pair<int, int> > > adj;
const long long mod = 1e9 + 7, oo = 1e9;
int n, m;
int main() {
Emsawy();
while (cin >> n >> m) {
vector<string> vn(n), vm(m);
for (int i = 0; i < n; i++) {
cin >> vn[i];
}
for (int i = 0; i < m; i++) {
cin >> vm[i];
}
int rem = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (vn[i] == vm[j]) {
rem++;
break;
}
}
}
int a = n - rem + ceil(rem / 2.0), b = m - rem + (rem / 2);
if (a > b)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<string> a, b, c;
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
a.insert(s);
}
for (int i = 1; i <= m; i++) {
string s;
cin >> s;
if (a.count(s)) c.insert(s);
b.insert(s);
}
while (1) {
if (a.empty()) {
cout << "NO\n";
return;
}
if (!c.empty()) {
a.erase(*c.begin());
b.erase(*c.begin());
c.erase(c.begin());
} else {
if (b.count(*a.begin())) b.erase(*a.begin());
a.erase(a.begin());
}
if (b.empty()) {
cout << "YES\n";
return;
}
if (!c.empty()) {
a.erase(*c.begin());
b.erase(*c.begin());
c.erase(c.begin());
} else {
if (a.count(*b.begin())) a.erase(*b.begin());
b.erase(b.begin());
}
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.