text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int mo = 1e9 + 7;
struct Val {
int x2, x1, x0;
friend Val operator+(const Val &a, const Val &b) {
return Val{(a.x2 + b.x2) % mo, (a.x1 + b.x1) % mo, (a.x0 + b.x0) % mo};
}
friend Val operator-(const Val &a, const Val &b) {
return Val{(a.x2 - b.x2) % mo, (a.x1 - b.x1) % mo, (a.x0 - b.x0) % mo};
}
friend Val operator*(const Val &a, const int d) {
Val c;
c.x2 = (a.x2 + 2ll * d * a.x1 + (long long)d * d % mo * a.x0) % mo;
c.x1 = (a.x1 + 1ll * d * a.x0) % mo;
c.x0 = a.x0;
return c;
}
} f[120000], g[120000], st[21][120000];
int w[120000], ff[21][120000], dis[21][120000], dep[120000], Q, n;
vector<pair<int, int> > E[120000];
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20; i >= 0; --i)
if (dep[x] - dep[y] >= 1 << i) x = ff[i][x];
if (x == y) return x;
for (int i = 20; i >= 0; --i)
if (ff[i][x] != ff[i][y]) x = ff[i][x], y = ff[i][y];
return ff[0][x];
}
void dfs(int x, int fa) {
f[x].x2 = f[x].x1 = 0;
f[x].x0 = 1;
for (int i = 0; i < E[x].size(); ++i)
if (E[x][i].first != fa) {
dep[E[x][i].first] = dep[x] + 1;
w[E[x][i].first] = (w[x] + E[x][i].second) % mo;
dfs(E[x][i].first, x);
f[x] = f[x] + f[E[x][i].first] * E[x][i].second;
}
}
void dp(int x, int fa) {
Val tmp = {0, 0, 1};
for (int i = 0; i < E[x].size(); ++i)
if (E[x][i].first != fa) tmp = tmp + f[E[x][i].first] * E[x][i].second;
for (int i = 0; i < E[x].size(); ++i)
if (E[x][i].first != fa) {
int y = E[x][i].first;
ff[0][y] = x;
st[0][y] = (tmp - f[y] * E[x][i].second) * E[x][i].second;
dis[0][y] = E[x][i].second;
g[y] = (tmp + g[x] - f[y] * E[x][i].second) * E[x][i].second;
dp(y, x);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
E[x].push_back(make_pair(y, k));
E[y].push_back(make_pair(x, k));
}
dfs(1, 0);
dp(1, 0);
for (int i = 1; i <= 20; ++i)
for (int j = 1; j <= n; ++j) {
ff[i][j] = ff[i - 1][ff[i - 1][j]];
dis[i][j] = (dis[i - 1][j] + dis[i - 1][ff[i - 1][j]]) % mo;
st[i][j] = st[i - 1][j] + st[i - 1][ff[i - 1][j]] * dis[i - 1][j];
}
scanf("%d", &Q);
for (int _ = 1; _ <= Q; ++_) {
int u, v;
scanf("%d%d", &u, &v);
int lca = LCA(u, v), dist = ((long long)w[u] + w[v] - 2 * w[lca]) % mo, ans;
if (lca == v) {
int d = 0, x = u;
Val tmp = f[u];
for (int i = 20; i >= 0; --i)
if (dep[u] - dep[v] >= 1 << i) {
tmp = tmp + st[i][u] * d;
d = (d + dis[i][u]) % mo;
u = ff[i][u];
}
ans = (2ll * tmp.x2 - (f[x] + g[x]).x2) % mo;
} else
ans = (2ll * (f[v] * dist).x2 - (f[u] + g[u]).x2) % mo;
printf("%d\n", (ans + mo) % mo);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2 * 1e5 + 10;
const long long Q = 1e9 + 7;
const long double eps = 1e-2;
const long double pi = 3.141592653589793238;
long long dp0[M], dp1[M], f[M], d[M], fi[M];
int kol[M], lvl[M], tin[M], tout[M], T = 0;
int jump[M][22];
vector<pair<int, long long> > g[M];
long long inc(int t, long long su, long long suq, long long y) {
su = ((su % Q) + Q) % Q;
suq = ((suq % Q) + Q) % Q;
y = ((y % Q) + Q) % Q;
return (suq + (2 * su * y) % Q + (t * ((y * y) % Q)) % Q) % Q;
}
long long dec(long long x, long long y) { return (x + Q - y) % Q; }
void build(int i, int pr) {
int j;
tin[i] = T++;
jump[i][0] = pr;
if (pr != i) lvl[i] = lvl[pr] + 1;
for (j = 0; j < (int)g[i].size(); j++)
if (g[i][j].first != pr) {
d[g[i][j].first] = (d[i] + g[i][j].second) % Q;
build(g[i][j].first, i);
}
for (j = 0; j < (int)g[i].size(); j++) {
if (g[i][j].first == pr) continue;
dp0[i] = (dp0[i] + dp0[g[i][j].first] +
g[i][j].second * (long long)kol[g[i][j].first]) %
Q;
kol[i] += kol[g[i][j].first];
dp1[i] = (dp1[i] + inc(kol[g[i][j].first], dp0[g[i][j].first],
dp1[g[i][j].first], g[i][j].second)) %
Q;
}
kol[i]++;
tout[i] = T++;
}
void dfs(int i, int pr, int ch, long long su, long long suq) {
f[i] = (dp1[i] + suq) % Q;
fi[i] = (dp0[i] + su) % Q;
for (int j = 0; j < (int)g[i].size(); j++) {
if (g[i][j].first != pr) {
int child = ch + kol[i] - kol[g[i][j].first];
long long su0 = (dec(0, (g[i][j].second * kol[g[i][j].first]) % Q) +
(su + dec(dp0[i], dp0[g[i][j].first]) +
(child * g[i][j].second) % Q)) %
Q;
long long su1 = inc(
child, dec(su0, (g[i][j].second * child) % Q),
((suq + dec(dp1[i], dp1[g[i][j].first]) -
(kol[g[i][j].first] * ((g[i][j].second * g[i][j].second) % Q)) % Q -
(2 * g[i][j].second * dp0[g[i][j].first]) % Q) %
Q +
Q) %
Q,
g[i][j].second);
dfs(g[i][j].first, i, child, su0, su1);
}
}
}
bool is_child(int u, int v) { return (tin[v] < tin[u] && tout[u] < tout[v]); }
int lca(int i, int j) {
int a = i;
int b = j;
int k;
if (lvl[a] < lvl[b]) swap(a, b);
for (k = 20; k >= 0; k--)
if (lvl[jump[a][k]] >= lvl[b]) a = jump[a][k];
if (a == b) return a;
for (k = 20; k >= 0; k--) {
if (jump[a][k] != jump[b][k]) {
a = jump[a][k];
b = jump[b][k];
}
}
return jump[a][0];
}
long long dist(int i, int j) {
int lc = lca(i, j);
return ((d[i] + d[j] - 2 * d[lc]) % Q + Q) % Q;
}
int main() {
srand(time(NULL));
int n, i, u, v, j, q;
long long c;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
scanf(
"%d%d"
"%lld",
&u, &v, &c);
g[u].push_back(make_pair(v, c));
g[v].push_back(make_pair(u, c));
}
build(1, 1);
dfs(1, 1, 0, 0, 0);
for (i = 1; i <= 20; i++)
for (j = 1; j <= n; j++) jump[j][i] = jump[jump[j][i - 1]][i - 1];
scanf("%d", &q);
for (int tq = 0; tq < q; tq++) {
scanf("%d%d", &u, &v);
if (!is_child(u, v))
printf(
"%lld"
"\n",
((2 * (inc(kol[v], dp0[v], dp1[v], dist(u, v))) - f[u]) % Q + Q) % Q);
else {
long long tmp = ((f[u] - inc(n - kol[v], (fi[v] - dp0[v]) % Q,
(f[v] - dp1[v]) % Q, dist(u, v))) %
Q +
Q) %
Q;
printf(
"%lld"
"\n",
((2 * tmp - f[u]) % Q + Q) % Q);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 17, mod = 1e9 + 7, lg = 20;
int sum(int a, int b) { return (1LL * a + b + mod) % mod; }
int mul(int a, int b) { return (1LL * a * b) % mod; }
int n, dp[MAXN][5], q, sz[MAXN], up[MAXN][lg], tin[MAXN], tout[MAXN], timer,
sm[MAXN][lg];
vector<pair<int, int> > adj[MAXN];
int addEDGE(int x, int y, int sz, int e) {
return sum(x, sum(mul(e, mul(e, sz)), mul(mul(2, e), y)));
}
void dfs_down(int v = 1, int par = 0) {
tin[v] = ++timer;
up[v][0] = par;
for (int i = 1; i < lg; i++) up[v][i] = up[up[v][i - 1]][i - 1];
for (auto i : adj[v])
if (i.first != par) {
int u = i.first;
dfs_down(u, v);
sz[v] += sz[u];
dp[v][2] = sum(dp[v][2], addEDGE(dp[u][2], dp[u][3], sz[u], i.second));
dp[v][3] = sum(dp[v][3], sum(dp[u][3], mul(i.second, sz[u])));
}
tout[v] = ++timer;
sz[v]++;
}
void dfs_up(int v = 1, int par = 0, int e = 0) {
if (v == 1)
;
else {
dp[v][4] = sum(sum(dp[par][3], -sum(dp[v][3], mul(e, sz[v]))),
sum(dp[par][4], mul(e, n - sz[v])));
int tmp1 = sum(sum(dp[par][2], dp[par][1]),
-addEDGE(dp[v][2], dp[v][3], sz[v], e));
int tmp2 =
mul(2, mul(e, sum(dp[par][4],
sum(dp[par][3], -sum(dp[v][3], mul(e, sz[v]))))));
int tmp3 = mul(n - sz[v], mul(e, e));
dp[v][1] = sum(tmp1, sum(tmp2, tmp3));
}
sm[v][0] = e;
for (int i = 1; i < lg; i++)
sm[v][i] = sum(sm[v][i - 1], sm[up[v][i - 1]][i - 1]);
for (auto i : adj[v])
if (i.first != par) dfs_up(i.first, v, i.second);
}
bool is_anc(int v, int u) { return tin[v] <= tin[u] && tout[u] <= tout[v]; }
int lca(int v, int u) {
if (is_anc(u, v)) return u;
for (int i = lg - 1; i >= 0; i--)
if (!is_anc(up[u][i], v)) u = up[u][i];
return up[u][0];
}
int getPAR(int v, int u) {
if (v == u) return 0;
int res = 0;
for (int i = lg - 1; i >= 0; i--)
if (!is_anc(up[u][i], v)) res = sum(res, sm[u][i]), u = up[u][i];
return sum(res, sm[u][0]);
}
int get(int v, int u) {
if (v == u) return 0;
int res = 0, lc = lca(v, u);
res = sum(getPAR(lc, v), getPAR(lc, u));
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
tout[0] = MAXN * 4;
cin >> n;
for (int i = 1; i < n; i++) {
int v, u, w;
cin >> v >> u >> w;
adj[v].push_back({u, w});
adj[u].push_back({v, w});
}
dfs_down();
dfs_up();
cin >> q;
while (q--) {
int v, u;
cin >> u >> v;
if (is_anc(v, u)) {
int e = get(v, u);
int tmp = addEDGE(dp[v][1], dp[v][4], n - sz[v], e);
cout << sum(sum(dp[u][1], dp[u][2]), -mul(2, tmp)) << '\n';
} else {
int e = get(v, u);
cout << sum(mul(2, addEDGE(dp[v][2], dp[v][3], sz[v], e)),
-sum(dp[u][1], dp[u][2]))
<< '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 2;
int n, q, S[N], F[N], H[N], R[N], t;
vector<pair<int, int> > G[N], Q[N];
int SEG[N << 2][2], LAZY[N << 2];
void Apply(int x, int id, int s, int e) {
LAZY[id] = (LAZY[id] + x % MOD + MOD) % MOD;
SEG[id][1] = (SEG[id][1] + 1LL * x * x % MOD * (e - s) % MOD +
2LL * x * SEG[id][0] % MOD + MOD) %
MOD;
SEG[id][0] = (SEG[id][0] + 1LL * (e - s) * x % MOD + MOD) % MOD;
}
void Shift(int id, int s, int e) {
if (LAZY[id] == 0) return;
Apply(LAZY[id], id << 1, s, (s + e) >> 1);
Apply(LAZY[id], id << 1 ^ 1, (s + e) >> 1, e);
LAZY[id] = 0;
}
void Update(int l, int r, int x, int id = 1, int s = 0, int e = t) {
if (l >= e || s >= r) return;
if (l <= s && e <= r) return Apply(x, id, s, e);
Shift(id, s, e);
Update(l, r, x, id << 1, s, (s + e) >> 1),
Update(l, r, x, id << 1 ^ 1, (s + e) >> 1, e);
SEG[id][0] = (SEG[id << 1][0] + SEG[id << 1 ^ 1][0]) % MOD,
SEG[id][1] = (SEG[id << 1][1] + SEG[id << 1 ^ 1][1]) % MOD;
}
int Get(int l, int r, int id = 1, int s = 0, int e = t) {
if (l >= e || s >= r) return 0;
if (l <= s && e <= r) return SEG[id][1];
Shift(id, s, e);
return (Get(l, r, id << 1, s, (s + e) >> 1) +
Get(l, r, id << 1 ^ 1, (s + e) >> 1, e)) %
MOD;
}
void DFST(int v, int p = 0) {
S[v] = t++;
for (auto [u, w] : G[v])
if (u != p) H[u] = (H[v] + w) % MOD, DFST(u, v);
F[v] = t;
}
void DFSQ(int v, int p = 0) {
for (auto [u, i] : Q[v])
R[i] = (2LL * Get(S[u], F[u]) - SEG[1][1] + MOD) % MOD;
for (auto [u, w] : G[v])
if (u != p) {
Update(0, t, +w), Update(S[u], F[u], -2 * w);
DFSQ(u, v);
Update(0, t, -w), Update(S[u], F[u], +2 * w);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
mt19937 Rnd(time(0));
cin >> n;
for (int i = 1; i < n; i++) {
int v, u, w;
cin >> v >> u >> w;
G[v].push_back(make_pair(u, w));
G[u].push_back(make_pair(v, w));
}
cin >> q;
for (int i = 0; i < q; i++) {
int v, u;
cin >> v >> u;
Q[v].push_back(make_pair(u, i));
}
DFST(1);
for (int i = 1; i <= n; i++) Update(S[i], S[i] + 1, H[i]);
DFSQ(1);
for (int i = 0; i < q; i++) cout << R[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int N, Q;
set<pair<int, int> > g[100001];
int t0[100001], t1[100001], t2[100001];
int p[100001];
template <typename T>
class segment_tree {
public:
vector<T> data;
vector<T> tt;
int N;
int construct(int root, int cl, int cr) {
if (cl == cr) return tt[root] = cl;
int t1 = construct(root * 2, cl, (cl + cr) / 2);
int t2 = construct(root * 2 + 1, (cl + cr) / 2 + 1, cr);
return tt[root] = data[t2] < data[t1] ? t2 : t1;
}
int query(int root, int cl, int cr, int l, int r) {
if (cl > r || cr < l) return N;
if (l <= cl && cr <= r) return tt[root];
int t1 = query(root * 2, cl, (cl + cr) / 2, l, r);
int t2 = query(root * 2 + 1, (cl + cr) / 2 + 1, cr, l, r);
return data[t2] < data[t1] ? t2 : t1;
}
inline int q(int l, int r) {
if (r < l) swap(l, r);
return query(1, 0, N - 1, l, r);
}
segment_tree(){};
segment_tree(vector<T> a) {
N = a.size();
data = a;
data.push_back(INT_MAX);
tt.resize(4 * N);
construct(1, 0, N - 1);
}
};
class least_common_ancestor {
public:
int N;
vector<vector<int> > g;
vector<int> invf;
vector<int> f;
vector<int> ll;
segment_tree<int> rmq;
void inorder(int s = 0, int d = 0) {
ll.push_back(d);
invf[ll.size() - 1] = s;
f[s] = ll.size() - 1;
for (int i = 0; i < g[s].size(); i++) {
inorder(g[s][i], d + 1);
ll.push_back(d);
invf[ll.size() - 1] = s;
}
}
least_common_ancestor(){};
least_common_ancestor(vector<vector<int> > t) {
g = t;
N = g.size();
f.resize(N);
invf.resize(2 * N - 1);
inorder();
rmq = segment_tree<int>(ll);
ll.clear();
g.clear();
}
int q(int a, int b) { return invf[rmq.q(f[a], f[b])]; }
};
void fix(int s) {
for (pair<int, int> i : g[s]) {
g[i.first].erase(g[i.first].lower_bound(make_pair(s, 0)));
p[i.first] = s;
fix(i.first);
}
}
int add(int a, int b) {
int ret = a + b;
if (ret >= MOD) ret -= MOD;
return ret;
}
int mul(int a, int b) { return (a * 1ll * b) % MOD; }
int ddd[100001];
least_common_ancestor lca;
int dist(int a, int b) {
return add(add(ddd[a], ddd[b]), MOD - mul(2, ddd[1 + lca.q(a - 1, b - 1)]));
}
set<pair<int, int> > q[100001];
vector<int> ans;
void dfs1(int s, int d = 0) {
t0[s] = 1;
ddd[s] = d;
for (pair<int, int> i : g[s]) {
dfs1(i.first, add(d, i.second));
t0[s] = add(t0[s], t0[i.first]);
t1[s] = add(t1[s], mul(t0[i.first], i.second));
t1[s] = add(t1[s], t1[i.first]);
t2[s] = add(t2[s], t2[i.first]);
t2[s] = add(t2[s], mul(t1[i.first], mul(2, i.second)));
t2[s] = add(t2[s], mul(t0[i.first], mul(i.second, i.second)));
}
}
set<pair<int, pair<int, int> > > st[100001];
void dfs(int s) {
for (pair<int, int> i : g[s]) {
int pt0 = t0[i.first];
int pt1 = t1[i.first];
pt1 = add(pt1, mul(t0[i.first], i.second));
int pt2 = t2[i.first];
pt2 = add(pt2, mul(t1[i.first], mul(2, i.second)));
pt2 = add(pt2, mul(t0[i.first], mul(i.second, i.second)));
t0[s] = add(t0[s], MOD - pt0);
t1[s] = add(t1[s], MOD - pt1);
t2[s] = add(t2[s], MOD - pt2);
int ppt0 = t0[s];
int ppt1 = t1[s];
ppt1 = add(ppt1, mul(t0[s], i.second));
int ppt2 = t2[s];
ppt2 = add(ppt2, mul(t1[s], mul(2, i.second)));
ppt2 = add(ppt2, mul(t0[s], mul(i.second, i.second)));
t0[i.first] = add(t0[i.first], ppt0);
t1[i.first] = add(t1[i.first], ppt1);
t2[i.first] = add(t2[i.first], ppt2);
dfs(i.first);
t0[i.first] = add(t0[i.first], MOD - ppt0);
t1[i.first] = add(t1[i.first], MOD - ppt1);
t2[i.first] = add(t2[i.first], MOD - ppt2);
t0[s] = add(t0[s], pt0);
t1[s] = add(t1[s], pt1);
t2[s] = add(t2[s], pt2);
}
for (pair<int, int> i : g[s])
if (st[i.first].size() > st[s].size()) swap(st[i.first], st[s]);
for (pair<int, int> i : g[s])
st[s].insert(st[i.first].begin(), st[i.first].end());
for (set<pair<int, pair<int, int> > >::iterator it =
st[s].lower_bound(make_pair(s, make_pair(0, 0)));
it != st[s].end() && it->first == s; it++) {
if (s == 1) continue;
int ooo = dist(p[s], it->second.first);
ans[it->second.second] =
add(ans[it->second.second],
MOD - mul(2, add(t2[p[s]], add(mul(t1[p[s]], mul(2, ooo)),
mul(t0[p[s]], mul(ooo, ooo))))));
}
for (pair<int, int> i : q[s]) {
if (i.first == s || lca.q(s - 1, i.first - 1) + 1 != i.first) {
ans[i.second] = MOD - t2[s];
continue;
}
ans[i.second] = t2[s];
st[s].insert(make_pair(i.first, make_pair(s, i.second)));
}
}
vector<vector<int> > g1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
for (int i = 1, a, b, c; i < N; i++) {
cin >> a >> b >> c;
g[a].insert(make_pair(b, c));
g[b].insert(make_pair(a, c));
}
g1.resize(N + 1);
cin >> Q;
ans.resize(Q);
for (int i = 0, u, v; i < Q; i++) {
cin >> u >> v;
q[u].insert(make_pair(v, i));
}
fix(1);
for (int i = 1; i <= N; i++)
for (pair<int, int> j : g[i]) g1[i - 1].push_back(j.first - 1);
lca = least_common_ancestor(g1);
dfs1(1);
dfs(1);
for (int s = 1; s <= N; s++)
for (pair<int, int> i : q[s]) {
if (s != i.first && lca.q(s - 1, i.first - 1) + 1 == i.first) continue;
int ooo = dist(s, i.first);
ans[i.second] =
add(ans[i.second],
mul(2, add(t2[i.first], add(mul(t1[i.first], mul(2, ooo)),
mul(t0[i.first], mul(ooo, ooo))))));
}
for (int i : ans) cout << i << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 10, md = 1e9 + 7;
vector<pair<long long, long long>> adj[MAXN], child[MAXN];
long long ls[MAXN], start[MAXN], finish[MAXN], h[MAXN], sum[4 * MAXN],
sum2[4 * MAXN], lazy[4 * MAXN];
long long n, a1, a2, a3, cnt;
void rel(long long& a) {
if (a >= md) a %= md;
}
void build(long long v, long long par) {
ls[cnt] = v;
start[v] = cnt++;
for (auto i : adj[v])
if (i.first != par) {
h[i.first] = h[v] + i.second;
rel(h[i.first]);
child[v].push_back(i);
build(i.first, v);
}
finish[v] = cnt;
}
void init(long long v, long long b, long long e) {
if (e - b == 1) {
sum[v] = h[ls[b]];
sum2[v] = sum[v] * sum[v];
rel(sum2[v]);
return;
}
long long mid = (b + e) / 2;
init(2 * v, b, mid);
init(2 * v + 1, mid, e);
sum[v] = sum[2 * v] + sum[2 * v + 1];
sum2[v] = sum2[2 * v] + sum2[2 * v + 1];
rel(sum[v]);
rel(sum2[v]);
}
void shift(long long v, long long b, long long e) {
long long mid = (b + e) / 2;
sum2[2 * v] = sum2[2 * v] + lazy[v] * 2 * sum[2 * v] +
((lazy[v] * lazy[v]) % md) * (mid - b);
sum[2 * v] = sum[2 * v] + (mid - b) * lazy[v];
sum2[2 * v + 1] = sum2[2 * v + 1] + lazy[v] * 2 * sum[2 * v + 1] +
((lazy[v] * lazy[v]) % md) * (e - mid);
sum[2 * v + 1] = sum[2 * v + 1] + (e - mid) * lazy[v];
lazy[2 * v] = lazy[2 * v] + lazy[v];
lazy[2 * v + 1] = lazy[2 * v + 1] + lazy[v];
rel(sum2[2 * v]);
rel(sum[2 * v]);
rel(sum2[2 * v + 1]);
rel(sum[2 * v + 1]);
rel(lazy[2 * v]);
rel(lazy[2 * v + 1]);
lazy[v] = 0;
}
void upd(long long v, long long b, long long e, long long l, long long r,
long long val) {
if (r <= b || e <= l) return;
if (l <= b && e <= r) {
sum2[v] = sum2[v] + sum[v] * 2 * val + ((val * val) % md) * (e - b);
sum[v] = sum[v] + (e - b) * val;
lazy[v] = lazy[v] + val;
rel(sum2[v]);
rel(sum[v]);
rel(lazy[v]);
return;
}
long long mid = (b + e) / 2;
shift(v, b, e);
upd(2 * v, b, mid, l, r, val);
upd(2 * v + 1, mid, e, l, r, val);
sum2[v] = sum2[2 * v] + sum2[2 * v + 1];
sum[v] = sum[2 * v] + sum[2 * v + 1];
rel(sum2[v]);
rel(sum[v]);
}
long long find(long long v, long long b, long long e, long long l,
long long r) {
if (r <= b || e <= l) return 0;
if (l <= b && e <= r) return sum2[v];
long long mid = (b + e) / 2;
shift(v, b, e);
return (find(2 * v, b, mid, l, r) + find(2 * v + 1, mid, e, l, r)) % md;
}
long long res[MAXN];
vector<pair<long long, long long>> query[MAXN];
void dfs(long long v) {
for (auto i : query[v]) {
res[i.second] = find(1, 0, n, start[i.first], finish[i.first]) * 2 +
md * 10 - find(1, 0, n, 0, n);
rel(res[i.second]);
}
for (auto i : child[v]) {
upd(1, 0, n, start[i.first], finish[i.first], (md * 10 - i.second) % md);
upd(1, 0, n, 0, start[i.first], i.second);
upd(1, 0, n, finish[i.first], n, i.second);
dfs(i.first);
upd(1, 0, n, start[i.first], finish[i.first], i.second);
upd(1, 0, n, 0, start[i.first], (md * 10 - i.second) % md);
upd(1, 0, n, finish[i.first], n, (md * 10 - i.second) % md);
}
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 1; i < n; ++i) {
cin >> a1 >> a2 >> a3;
adj[a1].push_back({a2, a3 % md});
adj[a2].push_back({a1, a3 % md});
}
build(1, 0);
init(1, 0, n);
long long q;
cin >> q;
for (long long i = 0; i < q; ++i) {
cin >> a1 >> a2;
query[a1].push_back({a2, i});
}
dfs(1);
for (long long i = 0; i < q; ++i) cout << res[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxv = 120000, maxe = maxv * 2;
const int maxq = 120000;
const int mod = 1000000007;
struct {
int v, w, next;
} graph[maxe];
int head[maxv], top;
int n, q;
void addedge(int x, int y, int w = 1) {
graph[top].v = y;
graph[top].w = w;
graph[top].next = head[x];
head[x] = top++;
}
int rdist[maxv];
long long csum[3][maxv];
int ord[maxv], t, seq[maxv * 2], seqlen, first[maxv];
void dfs(int p = 1, int prev = 0) {
int ct = t++;
ord[ct] = p;
seq[first[p] = seqlen++] = ct;
csum[0][p] = 1;
csum[1][p] = csum[2][p] = 0;
for (int i = head[p]; ~i; i = graph[i].next) {
int np = graph[i].v;
if (np == prev) continue;
rdist[np] = (rdist[p] + graph[i].w) % mod;
dfs(np, p);
seq[seqlen++] = ct;
csum[0][p] += csum[0][np];
csum[1][p] += csum[1][np] + csum[0][np] * graph[i].w;
csum[2][p] += csum[2][np] + 2 * csum[1][np] * graph[i].w +
((csum[0][np] * graph[i].w) % mod) * graph[i].w;
for (int j = 0; j < 3; ++j) csum[j][p] %= mod;
}
}
long long asum[3][maxv];
void bfs(int p = 1) {
queue<int> q;
q.push(p);
for (int i = 0; i < 3; ++i) asum[i][p] = csum[i][p];
while (!q.empty()) {
int cp = q.front();
q.pop();
for (int i = head[cp]; ~i; i = graph[i].next) {
int np = graph[i].v, nd = graph[i].w;
if (asum[0][np]) continue;
asum[0][np] = n;
asum[1][np] = asum[1][cp] + (n - 2 * csum[0][np]) * graph[i].w;
asum[2][np] =
asum[2][cp] -
(csum[2][np] + 2 * csum[1][np] * graph[i].w +
((csum[0][np] * graph[i].w) % mod) * graph[i].w) +
(((n - csum[0][np]) * graph[i].w) % mod) * graph[i].w +
2 * ((asum[1][cp] - csum[1][np] - csum[0][np] * graph[i].w) % mod) *
graph[i].w +
csum[2][np];
for (int j = 0; j < 3; ++j) asum[j][np] %= mod;
q.push(np);
}
}
}
int minst[maxv * 2][20];
void init_st() {
for (int i = 0; i < 2 * n; ++i) minst[i][0] = seq[i];
for (int i = 1, ii = 2; ii <= 2 * n; ++i, ii <<= 1)
for (int j = 0; j <= 2 * n - ii; ++j)
minst[j][i] = min(minst[j][i - 1], minst[j + (ii >> 1)][i - 1]);
}
inline int log2(int p) { return (int)(log(p + 0.5) / log(2.0)); }
inline int lca(int x, int y) {
int l = first[x], r = first[y];
if (l > r) swap(l, r);
int pos = log2(r - l + 1), len = 1 << pos;
return ord[min(minst[l][pos], minst[r - len + 1][pos])];
}
inline long long dist(int x, int y) {
return ((long long)rdist[x] + rdist[y] - 2 * rdist[lca(x, y)]) % mod;
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
addedge(x, y, z);
addedge(y, x, z);
}
dfs();
bfs();
init_st();
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
int fa = lca(u, v);
long long ans;
if (fa != v)
ans = 2 * (csum[2][v] + 2 * csum[1][v] * dist(u, v) +
((csum[0][v] * dist(u, v)) % mod) * dist(u, v)) -
asum[2][u];
else
ans = asum[2][u] -
2 * ((asum[2][v] - csum[2][v]) +
2 * (asum[1][v] - csum[1][v]) * dist(u, v) +
(((n - csum[0][v]) * dist(u, v)) % mod) * dist(u, v));
printf("%I64d\n", (ans % mod + mod) % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10, MOD = 1e9 + 7, L = 20;
long long n, dp_down[N], dp_up[N], ch[N], dist_down[N], dist_up[N], dp[N][L],
dpw[N][L], h[N], st[N], ft[N], now = 0;
vector<pair<long long, long long> > g[N];
void dfs_down(long long u, long long p) {
st[u] = now++;
ch[u]++;
for (pair<long long, long long> a : g[u]) {
long long v = a.first, w = a.second;
if (v != p) {
dfs_down(v, u);
(dist_down[u] += (dist_down[v] + ((1ll * ch[v] * w) % MOD)) % MOD) %= MOD;
ch[u] += ch[v];
(dp_down[u] +=
(dp_down[v] + ((1ll * ch[v] * ((1ll * w * w) % MOD)) % MOD)) % MOD) %=
MOD;
(dp_down[u] += (1ll * 2 * w * dist_down[v]) % MOD) %= MOD;
}
}
ft[u] = now;
}
void dfs_up(long long u, long long p) {
for (pair<long long, long long> a : g[u]) {
long long v = a.first, w = a.second;
if (v != p) {
dist_up[v] = (dist_up[u] + dist_down[u] -
(dist_down[v] + ((1ll * w * ch[v]) % MOD))) %
MOD;
if (dist_up[v] < 0) dist_up[v] += MOD;
(dp_up[v] += (1ll * 2 * w * dist_up[v]) % MOD) %= MOD;
dist_up[v] += (1ll * w * (n - ch[v])) % MOD;
(dp_up[v] += (1ll * (n - ch[v]) * ((1ll * w * w) % MOD))) %= MOD;
(dp_up[v] += dp_up[u]) %= MOD;
(dp_up[v] += dp_down[u] -
((dp_down[v] + ((1ll * ch[v] * ((1ll * w * w) % MOD)) % MOD +
((1ll * 2 * dist_down[v] * w) % MOD))) %
MOD)) %= MOD;
while (dp_up[v] < 0) dp_up[v] += MOD;
dfs_up(v, u);
}
}
}
void fill_dp(long long u, long long p, long long W, long long hei) {
h[u] = hei;
dp[u][0] = p;
dpw[u][0] = W;
for (long long i = 1; i < 20; i++) {
dp[u][i] = dp[dp[u][i - 1]][i - 1];
dpw[u][i] = (dpw[dp[u][i - 1]][i - 1] + dpw[u][i - 1]) % MOD;
}
for (pair<long long, long long> a : g[u]) {
long long v = a.first, w = a.second;
if (v != p) fill_dp(v, u, w, hei + 1);
}
}
inline pair<long long, long long> par(long long u, long long x) {
long long sum = 0;
for (long long i = 19; i >= 0; i--)
if ((1 << i) & x) {
(sum += dpw[u][i]) %= MOD;
u = dp[u][i];
}
return {u, sum};
}
inline long long dis(long long u, long long v) {
if (h[u] > h[v]) swap(u, v);
pair<long long, long long> a = par(v, h[v] - h[u]);
long long sum = a.second;
v = a.first;
for (long long i = 19; i >= 0; i--)
if (dp[u][i] != dp[v][i]) {
(sum += (dpw[u][i] + dpw[v][i]) % MOD) %= MOD;
u = dp[u][i];
v = dp[v][i];
}
if (u != v) (sum += (dpw[u][0] + dpw[v][0]) % MOD) %= MOD;
return sum;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long u, v, q, w;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
cin >> u >> v >> w;
u--, v--;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
dfs_down(0, 0);
dfs_up(0, 0);
fill_dp(0, 0, 0, 0);
cin >> q;
for (long long i = 0; i < q; i++) {
cin >> u >> v;
u--, v--;
if (st[u] < st[v] || st[u] >= ft[v]) {
long long x = dis(u, v);
long long res = 2 * ((1ll * 2 * x * dist_down[v]) % MOD) % MOD;
x = (1ll * x * x) % MOD;
res += (2 * (dp_down[v] + (1ll * ch[v] * x) % MOD)) -
(dp_down[u] + dp_up[u]);
while (res < 0) res += MOD;
cout << res % MOD << "\n";
} else {
long long x = dis(u, v);
long long res = (1ll * 2 * x * dist_up[v]) % MOD;
x = (1ll * x * x) % MOD;
res += (1ll * x * (n - ch[v])) % MOD;
(res += dp_up[v]) %= MOD;
res = (dp_down[u] + dp_up[u] - res) - res;
while (res < 0) res += MOD;
cout << res % MOD << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int other, cost;
};
vector<edge> adj[100000];
const int mod = 1e9 + 7;
struct distset {
int many;
int sum1;
int sum2;
distset operator+(const distset &other) const {
return {(many + other.many) % mod, (sum1 + other.sum1) % mod,
(sum2 + other.sum2) % mod};
}
distset operator-(const distset &other) const {
return {(many - other.many + mod) % mod, (sum1 - other.sum1 + mod) % mod,
(sum2 - other.sum2 + mod) % mod};
}
distset operator^(long long by) const {
by %= mod;
return {
many, (int)((sum1 + (long long)by * many) % mod),
(int)((sum2 + (long long)many * by % mod * by + 2LL * by % mod * sum1) %
mod)};
}
distset operator*(long long by) const {
by %= mod;
return {(int)(by * many % mod), (int)(by * sum1 % mod),
(int)(by * sum2 % mod)};
}
} up[100000], down[100000], full[100000];
int parent[100000][16 + 1], logn;
int height[100000];
long long depth[100000];
int goup(int a, int dist) {
for (int l = 0; (1 << l) <= dist; l++)
if (dist & (1 << l)) a = parent[a][l];
return a;
}
int lca(int a, int b) {
if (height[a] < height[b]) swap(a, b);
a = goup(a, height[a] - height[b]);
if (a == b) return a;
for (int l = logn; l >= 0; l--)
if (parent[a][l] != parent[b][l]) a = parent[a][l], b = parent[b][l];
return parent[a][0];
}
void dfs2(int v, int p, distset from_up) {
up[v] = from_up;
full[v] = up[v] + down[v];
for (edge &ed : adj[v]) {
if (ed.other == p) continue;
int u = ed.other;
dfs2(u, v, (from_up + down[v] - (down[u] ^ ed.cost)) ^ ed.cost);
}
}
void dfs(int v, int p, int h, long long d) {
for (int l = 1; l <= logn; l++)
parent[v][l] = parent[parent[v][l - 1]][l - 1];
height[v] = h, depth[v] = d;
down[v] = {1, 0, 0};
for (edge &ed : adj[v]) {
if (ed.other == p) continue;
int u = ed.other;
parent[u][0] = v;
dfs(u, v, h + 1, d + ed.cost);
down[v] = down[v] + (down[u] ^ ed.cost);
}
}
int main() {
int n;
scanf("%d", &n);
logn = 0;
while ((1 << (logn + 1)) <= n) logn++;
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c), a--, b--;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
parent[0][0] = 0;
dfs(0, -1, 0, 0);
dfs2(0, -1, {0, 0, 0});
int nq;
scanf("%d", &nq);
for (int q = 0; q < nq; q++) {
int u, v;
scanf("%d %d", &u, &v), u--, v--;
int l = lca(u, v);
long long dist = depth[u] + depth[v] - 2 * depth[l];
distset result;
if (l == v)
result = full[u] - (up[v] ^ dist) * 2;
else
result = (down[v] ^ dist) * 2 - full[u];
printf("%d\n", result.sum2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long p[400010], s[400010], tt[400010], dis2[400010], dis[400010],
dist[400010], a, b, c, i, j, w[400010], d[400010], ans[400010];
long long dp, pre[400010], n, q, tmp, t, dd;
long long r[400010], st[400010][20], deep[400010], tot;
void link(int x, int y, int z) {
dp++;
pre[dp] = p[x];
p[x] = dp;
tt[dp] = y;
w[dp] = z;
}
int mi(int a, int b) {
if (deep[a] < deep[b]) return a;
return b;
}
int lca(int a, int b) {
int k;
a = r[a];
b = r[b];
if (b < a) {
k = a;
a = b;
b = k;
}
k = (int)log2(b - a + 1);
return mi(st[a][k], st[b - (1 << k) + 1][k]);
}
void dfs(int x, int fa) {
int i;
i = p[x];
s[x] = 1;
tot++;
r[x] = tot;
st[tot][0] = x;
while (i) {
if (tt[i] != fa) {
dist[tt[i]] = (dist[x] + w[i]) % 1000000007;
deep[tt[i]] = deep[x] + 1;
dfs(tt[i], x);
tot++;
st[tot][0] = x;
s[x] = s[x] + s[tt[i]];
dis[x] =
(dis[x] + dis[tt[i]] + (s[tt[i]] * w[i]) % 1000000007) % 1000000007;
dis2[x] = (dis2[x] + dis2[tt[i]] +
((s[tt[i]] * w[i]) % 1000000007 * w[i]) % 1000000007 +
2 * (w[i] * dis[tt[i]]) % 1000000007) %
1000000007;
}
i = pre[i];
}
}
void cnt1(int x, int fa) {
int i;
i = p[x];
while (i) {
if (tt[i] != fa) {
d[tt[i]] = (d[x] - (s[tt[i]] * w[i]) % 1000000007 +
(n - s[tt[i]]) * w[i] % 1000000007) %
1000000007;
cnt1(tt[i], x);
}
i = pre[i];
}
}
void cnt2(int x, int fa) {
int i;
i = p[x];
while (i) {
if (tt[i] != fa) {
ans[tt[i]] =
(ans[x] -
(dis2[tt[i]] + ((w[i] * w[i]) % 1000000007) * s[tt[i]] % 1000000007 +
2 * dis[tt[i]] * w[i] % 1000000007) +
((w[i] * w[i]) % 1000000007) * (n - s[tt[i]]) % 1000000007 +
2 * w[i] * (d[x] - dis[tt[i]] - (s[tt[i]] * w[i]) % 1000000007) %
1000000007 +
dis2[tt[i]]) %
1000000007;
cnt2(tt[i], x);
}
i = pre[i];
}
}
int main() {
cin >> n;
for (i = 1; i <= n - 1; i++) {
cin >> a >> b >> c;
link(a, b, c);
link(b, a, c);
}
dfs(1, 0);
for (i = tot; i >= 1; i--) {
a = (int)log2(tot);
for (j = 1; j <= a; j++)
st[i][j] = mi(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
d[1] = dis[1];
ans[1] = dis2[1];
cnt1(1, 0);
cnt2(1, 0);
cin >> q;
for (i = 1; i <= q; i++) {
cin >> a >> b;
c = lca(a, b);
dd = (dist[a] + dist[b] - 2 * dist[c]) % 1000000007;
if (c != b) {
t = ((2 * (dis2[b] + ((s[b] * dd) % 1000000007) * dd % 1000000007 +
2 * (dd * dis[b]) % 1000000007) -
ans[a]) %
1000000007 +
1000000007) %
1000000007;
} else {
tmp = (ans[b] - dis2[b] + ((n - s[b]) * dd) % 1000000007 * dd +
2 * dd * (d[b] - dis[b])) %
1000000007;
t = ((ans[a] - 2 * tmp) % 1000000007 + 1000000007) % 1000000007;
}
t = (t + 1000000007) % 1000000007;
cout << t << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007;
inline void add(int &a, int b) {
a += b;
if (a >= md) {
a -= md;
}
}
inline int mul(int a, int b) { return (long long)a * b % md; }
const int N = 400010;
vector<pair<int, int> > g[N];
int cnt[N], sum[N], sumsq[N];
int tin[N], tout[N], TIME = 0;
int depth[N];
int pv[N];
const int LOG = 20;
int pr[N][LOG];
void dfs(int v, int pr) {
tin[v] = ++TIME;
int sz = g[v].size();
cnt[v] = 1;
sum[v] = 0;
sumsq[v] = 0;
for (int j = 0; j < sz; j++) {
int u = g[v][j].first;
if (u == pr) {
continue;
}
pv[u] = v;
int len = g[v][j].second;
depth[u] = depth[v];
add(depth[u], len);
dfs(u, v);
add(cnt[v], cnt[u]);
add(sum[v], sum[u]);
add(sum[v], mul(cnt[u], len));
add(sumsq[v], sumsq[u]);
add(sumsq[v], mul(cnt[u], mul(len, len)));
add(sumsq[v], mul(mul(2, len), sum[u]));
}
tout[v] = ++TIME;
}
bool anc(int x, int y) { return (tin[x] <= tin[y] && tout[y] <= tout[x]); }
int lca(int x, int y) {
if (anc(x, y)) return x;
for (int j = LOG - 1; j >= 0; j--)
if (!anc(pr[x][j], y)) x = pr[x][j];
return pv[x];
}
int ups[N];
int up[N];
int n;
void get_up(int v, int pr) {
int sz = g[v].size();
for (int j = 0; j < sz; j++) {
int u = g[v][j].first;
if (u == pr) {
continue;
}
int len = g[v][j].second;
int no_s = sum[v];
add(no_s, md - sum[u]);
add(no_s, md - mul(cnt[u], len));
add(no_s, ups[v]);
int no_sq = sumsq[v];
add(no_sq, md - sumsq[u]);
add(no_sq, md - mul(cnt[u], mul(len, len)));
add(no_sq, md - mul(mul(2, len), sum[u]));
up[u] = up[v];
add(up[u], no_sq);
add(up[u], mul(n - cnt[u], mul(len, len)));
add(up[u], mul(mul(2, len), no_s));
ups[u] = ups[v];
int no_sss = sum[v];
add(no_sss, md - sum[u]);
add(no_sss, md - mul(cnt[u], len));
add(ups[u], no_sss);
add(ups[u], mul(n - cnt[u], len));
get_up(u, v);
}
}
int res[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
g[i].clear();
}
for (int i = 0; i < n - 1; i++) {
int foo, bar, len;
scanf("%d %d %d", &foo, &bar, &len);
foo--;
bar--;
g[foo].push_back(make_pair(bar, len));
g[bar].push_back(make_pair(foo, len));
}
depth[0] = 0;
dfs(0, -1);
for (int i = 0; i < n; i++) pr[i][0] = pv[i];
for (int j = 1; j < LOG; j++)
for (int i = 0; i < n; i++) pr[i][j] = pr[pr[i][j - 1]][j - 1];
ups[0] = 0;
up[0] = 0;
get_up(0, -1);
for (int i = 0; i < n; i++) {
res[i] = sumsq[i];
add(res[i], up[i]);
}
int tt;
scanf("%d", &tt);
while (tt--) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
if (!anc(v, u)) {
int len = depth[v];
add(len, depth[u]);
int z = lca(v, u);
add(len, md - mul(2, depth[z]));
int good = sumsq[v];
add(good, mul(cnt[v], mul(len, len)));
add(good, mul(mul(2, len), sum[v]));
good = mul(good, 2);
add(good, md - res[u]);
printf("%d\n", good);
} else {
int len = depth[u];
add(len, md - depth[v]);
int good = up[v];
add(good, mul(n - cnt[v], mul(len, len)));
add(good, mul(mul(2, len), ups[v]));
good = (res[u] - good + md) % md;
good = mul(good, 2);
add(good, md - res[u]);
printf("%d\n", good);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MN = 101234, MOD = 1000 * 1000 * 1000 + 7;
long long st[MN], fn[MN], h[MN], res[MN], n;
vector<pair<long long, long long> > adj[MN], qwr[MN];
long long se1[MN * 4], se2[MN * 4], lz[MN * 4];
void boom(long long v, long long val, long long sz) {
(se2[v] += val * val % MOD * sz % MOD + 2 * se1[v] * val % MOD) %= MOD;
(se1[v] += val * sz % MOD) %= MOD;
(lz[v] += val) %= MOD;
}
void add(long long l, long long r, long long val, long long s = 0,
long long e = n, long long v = 1) {
if (r <= s || e <= l) return;
if (l <= s && e <= r) {
boom(v, val, e - s);
return;
}
long long mid = (s + e) / 2;
boom(v * 2, lz[v], mid - s);
boom(v * 2 + 1, lz[v], e - mid);
lz[v] = 0;
add(l, r, val, s, mid, v * 2);
add(l, r, val, mid, e, v * 2 + 1);
se1[v] = (se1[v * 2] + se1[v * 2 + 1]) % MOD;
se2[v] = (se2[v * 2] + se2[v * 2 + 1]) % MOD;
}
long long get(long long l, long long r, long long s = 0, long long e = n,
long long v = 1) {
if (r <= s || e <= l) return 0;
if (l <= s && e <= r) return se2[v];
long long mid = (s + e) / 2;
boom(v * 2, lz[v], mid - s);
boom(v * 2 + 1, lz[v], e - mid);
lz[v] = 0;
long long x = get(l, r, s, mid, v * 2);
long long y = get(l, r, mid, e, v * 2 + 1);
return (x + y) % MOD;
}
void dfs(long long v, long long p = 0) {
static long long t = 0;
st[v] = t++;
for (auto [u, w] : adj[v]) {
if (u == p) continue;
h[u] = (h[v] + w) % MOD;
dfs(u, v);
}
fn[v] = t;
}
void sar(long long v, long long p = 0) {
for (auto [u, w] : adj[v]) {
if (u == p) continue;
add(0, n, w);
add(st[u], fn[u], ((-2 * w) % MOD + MOD) % MOD);
sar(u, v);
add(0, n, (-w + MOD) % MOD);
add(st[u], fn[u], 2 * w % MOD);
}
for (auto [u, i] : qwr[v]) {
res[i] = (get(st[u], fn[u]) * 2 % MOD - get(0, n) + MOD) % MOD;
}
}
int32_t main() {
cin >> n;
for (long long i = 1; i < n; i++) {
long long u, v, w;
cin >> u >> v >> w;
adj[--u].push_back({--v, w});
adj[v].push_back({u, w});
}
dfs(0);
long long q;
cin >> q;
for (long long i = 0; i < q; i++) {
long long u, v;
cin >> u >> v;
qwr[--u].push_back({--v, i});
}
for (long long i = 0; i < n; i++) add(st[i], st[i] + 1, h[i]);
sar(0);
for (long long i = 0; i < q; i++) cout << res[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 120000;
int n;
int a, b, c;
vector<pair<int, int> > g[MAX];
long long frg[2][MAX];
int f[20][MAX];
long long fuper[20][3][MAX];
int h[MAX];
long long d[MAX];
long long l[MAX];
long long weight[2][MAX];
long long weight1[2][MAX];
long long coun[MAX];
pair<long long, long long> recalc(long long v0, long long v1, long long hm,
long long len) {
return make_pair(
(v0 + len * hm) % 1000000007,
(v1 + len * len % 1000000007 * hm + 2 * len * v0) % 1000000007);
}
void dfs(int v) {
coun[v]++;
for (int(i) = (0); i < (g[v].size()); ++(i)) {
int u = g[v][i].first;
long long W = g[v][i].second;
if (u != f[0][v]) {
f[0][u] = v;
h[u] = h[v] + 1;
l[u] = W;
d[u] = (d[v] + W) % 1000000007;
for (int(j) = (1); j < (20); ++(j)) f[j][u] = f[j - 1][f[j - 1][u]];
dfs(u);
coun[v] += coun[u];
pair<long long, long long> r =
recalc(weight[0][u], weight[1][u], coun[u], W);
frg[0][u] = r.first;
weight[0][v] = (weight[0][v] + r.first) % 1000000007;
frg[1][u] = r.second;
weight[1][v] = (weight[1][v] + r.second) % 1000000007;
}
}
}
void dfs2(int v) {
if (v == 0) {
weight1[0][v] = weight[0][v];
weight1[1][v] = weight[1][v];
}
for (int(i) = (0); i < (g[v].size()); ++(i)) {
int u = g[v][i].first;
int W = g[v][i].second;
if (u != f[0][v]) {
weight1[0][u] = weight[0][u];
weight1[1][u] = weight[1][u];
long long val0 = (weight1[0][v] - frg[0][u] + 1000000007) % 1000000007;
long long val1 = (weight1[1][v] - frg[1][u] + 1000000007) % 1000000007;
long long cnv = n - coun[u];
pair<long long, long long> r = recalc(val0, val1, cnv, W);
weight1[0][u] = (weight1[0][u] + r.first) % 1000000007;
weight1[1][u] = (weight1[1][u] + r.second) % 1000000007;
dfs2(u);
}
}
}
int upp(int a, int b) {
for (int(i) = (20) - 1; (i) >= (0); --(i)) {
if (h[a] - (1 << i) >= h[b]) {
a = f[i][a];
}
}
for (int(i) = (20) - 1; (i) >= (0); --(i)) {
if (h[b] - (1 << i) >= h[a]) {
b = f[i][b];
}
}
for (int(i) = (20) - 1; (i) >= (0); --(i)) {
if (f[i][a] != f[i][b]) {
b = f[i][b];
a = f[i][a];
}
}
if (a != b)
return f[0][a];
else
return a;
}
void dfs3(int v) {
for (int(i) = (0); i < (g[v].size()); ++(i)) {
int u = g[v][i].first;
if (u != f[0][v]) {
dfs3(u);
}
}
}
int main() {
cin >> n;
for (int(i) = (1); i < (n); ++(i)) {
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
}
f[0][0] = 0;
dfs(0);
dfs2(0);
int q;
cin >> q;
for (int(i) = (0); i < (q); ++(i)) {
scanf("%d%d", &a, &b);
a--;
b--;
int ft = upp(a, b);
long long len = (2 * 1000000007 + d[a] + d[b] - 2 * d[ft]) % 1000000007;
if (ft != b) {
pair<long long, long long> r =
recalc(weight[0][b], weight[1][b], coun[b], len);
cout << (2 * r.second + 1000000007 - weight1[1][a]) % 1000000007 << "\n";
} else {
pair<long long, long long> r =
recalc((weight1[0][b] - weight[0][b] + 1000000007) % 1000000007,
(weight1[1][b] - weight[1][b] + 1000000007) % 1000000007,
n - coun[b], len);
cout << (weight1[1][a] + 2 * 1000000007 - 2 * r.second) % 1000000007
<< "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
int n, head[maxn];
struct Edge {
int next, to, len;
} ed[maxn * 2];
int ecnt;
inline void addedge(int u, int v, int l) {
ed[ecnt].next = head[u];
ed[ecnt].to = v;
ed[ecnt].len = l;
head[u] = ecnt++;
}
inline void add(long long &x, long long v) {
x += v;
if (x >= mod) x -= mod;
}
inline long long sqr(long long x) { return x * x % mod; }
int fa[maxn][20], dep[maxn], sz[maxn];
long long dis[maxn], down[maxn], qdown[maxn];
void dfs1(int u, int father) {
fa[u][0] = father;
for (int i = 1; i < 20; ++i) fa[u][i] = fa[fa[u][i - 1]][i - 1];
sz[u] = 1;
for (int e = head[u]; ~e; e = ed[e].next) {
int v = ed[e].to;
if (v == father) continue;
dep[v] = dep[u] + 1;
dis[v] = dis[u] + ed[e].len;
dfs1(v, u);
sz[u] += sz[v];
add(down[u], (down[v] + 1LL * ed[e].len * sz[v]) % mod);
add(qdown[u], (qdown[v] + sqr(ed[e].len) * sz[v] % mod +
2 * ed[e].len * down[v] % mod) %
mod);
}
}
long long all[maxn], up[maxn], qup[maxn];
void dfs2(int u, int father) {
for (int e = head[u]; ~e; e = ed[e].next) {
int v = ed[e].to;
if (v == father) continue;
qup[v] = (qup[u] + sqr(ed[e].len) * (n - sz[u] + 1) % mod +
2 * ed[e].len * up[u] % mod) %
mod;
long long t1 = qdown[u] - (qdown[v] + sqr(ed[e].len) * sz[v] % mod +
2 * ed[e].len * down[v] % mod) %
mod;
if (t1 < 0) t1 += mod;
long long t2 = down[u] - (down[v] + 1LL * ed[e].len * sz[v]) % mod;
if (t2 < 0) t2 += mod;
add(qup[v], (t1 + sqr(ed[e].len) * (sz[u] - sz[v] - 1) % mod +
2 * ed[e].len * t2 % mod) %
mod);
up[v] = (up[u] + 1LL * ed[e].len * (n - sz[u] + 1)) % mod;
add(up[v], (t2 + 1LL * ed[e].len * (sz[u] - sz[v] - 1)) % mod);
dfs2(v, u);
}
}
inline int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 19; i >= 0; --i)
if (dep[fa[u][i]] >= dep[v]) u = fa[u][i];
if (u == v) return u;
for (int i = 19; i >= 0; --i)
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
return fa[u][0];
}
inline long long D(int u, int v) {
return dis[u] + dis[v] - 2 * dis[lca(u, v)];
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
addedge(u, v, c);
addedge(v, u, c);
}
dfs1(1, 1);
dfs2(1, 1);
for (int i = 1; i <= n; ++i) all[i] = (qdown[i] + qup[i]) % mod;
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
if (u == v) {
printf("%I64d\n", (qdown[u] - qup[u] + mod) % mod);
continue;
}
long long ans = 0, DIS = D(u, v);
if (dis[u] != dis[v] + DIS) {
DIS %= mod;
ans = (qdown[v] + sqr(DIS) * sz[v] % mod + 2 * DIS * down[v] % mod) % mod;
ans += ans - all[u];
ans %= mod;
if (ans < 0) ans += mod;
} else {
DIS %= mod;
ans =
(qup[v] + sqr(DIS) * (n - sz[v]) % mod + 2 * DIS * up[v] % mod) % mod;
ans = all[u] - 2 * ans;
ans %= mod;
if (ans < 0) ans += mod;
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10, MOD = 1e9 + 7, lg = 19;
int n, h[MAXN], LCA[MAXN][lg], q;
long long cntd[MAXN], cntu[MAXN], dsr[MAXN], zdt2[MAXN], zdt1[MAXN],
zdtu1[MAXN], zdtu2[MAXN];
vector<pair<int, long long> > Mat[MAXN];
void topar(int v, int hi, long long val, int p) {
LCA[v][0] = p;
h[v] = hi;
dsr[v] += val;
dsr[v] %= MOD;
cntd[v] = 1;
for (int i = 0; i < Mat[v].size(); i++)
if (Mat[v][i].first != p) {
topar(Mat[v][i].first, hi + 1, val + Mat[v][i].second, v);
cntd[v] += cntd[Mat[v][i].first];
zdt1[v] += zdt1[Mat[v][i].first] +
(cntd[Mat[v][i].first] * Mat[v][i].second) % MOD;
zdt1[v] %= MOD;
zdt2[v] += zdt2[Mat[v][i].first] +
(cntd[Mat[v][i].first] *
((Mat[v][i].second * Mat[v][i].second) % MOD)) %
MOD;
zdt2[v] += 2 * (zdt1[Mat[v][i].first] * Mat[v][i].second) % MOD;
zdt2[v] %= MOD;
}
}
void updup(int v, int p, long long val) {
if (v != 1) {
cntu[v] = cntu[p] + cntd[p] - cntd[v];
zdtu1[v] += zdtu1[p] + zdt1[p] - zdt1[v] - (val * cntd[v]) % MOD +
(cntu[v] * val) % MOD;
zdtu1[v] %= MOD;
zdtu2[v] = zdtu2[p];
zdtu2[v] += (cntu[v] * ((val * val) % MOD)) % MOD;
zdtu2[v] += (val * (zdtu1[p] + zdt1[p] - zdt1[v] - (val * cntd[v]) % MOD) %
MOD * 2) %
MOD;
zdtu2[v] += zdt2[p] - zdt2[v] - (cntd[v] * ((val * val) % MOD)) % MOD -
2 * (zdt1[v] * val) % MOD;
zdtu2[v] %= MOD;
}
for (int i = 0; i < Mat[v].size(); i++)
if (Mat[v][i].first != p) updup(Mat[v][i].first, v, Mat[v][i].second);
}
int goup(int v, int dis) {
int k = 0;
while (dis) {
if (dis % 2) v = LCA[v][k];
k++;
dis /= 2;
}
return v;
}
int getLCA(int v, int u) {
if (h[v] < h[u]) swap(u, v);
int dis = h[v] - h[u];
v = goup(v, dis);
if (v == u) return v;
for (int i = lg - 1; i >= 0; i--)
if (LCA[v][i] != LCA[u][i]) v = LCA[v][i], u = LCA[u][i];
return LCA[u][0];
}
long long getdis(int v, int u) {
return (dsr[v] + dsr[u] - 2 * dsr[getLCA(v, u)]) % MOD;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
Mat[a].push_back({b, c});
Mat[b].push_back({a, c});
}
topar(1, 0, 0, 1);
updup(1, 1, 0);
for (int i = 1; i < lg; i++)
for (int j = 1; j <= n; j++) LCA[j][i] = LCA[LCA[j][i - 1]][i - 1];
cin >> q;
while (q--) {
int v, u;
cin >> u >> v;
if (u == 10) u = 10;
long long d = getdis(v, u);
long long S = zdt2[u] + zdtu2[u];
if (getLCA(v, u) == v) {
S -= 2 * (zdtu2[v] + (cntu[v] * ((d * d) % MOD)) % MOD +
(((d * zdtu1[v]) % MOD) * 2) % MOD);
S %= MOD, S += MOD, S %= MOD;
cout << S << endl;
} else {
long long res = 2 * (zdt2[v] + (cntd[v] * ((d * d) % MOD)) % MOD +
(((d * zdt1[v]) % MOD) * 2) % MOD);
res -= S;
res %= MOD, res += MOD, res %= MOD;
cout << res << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265359;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T sqr(T x) {
return x * x;
}
const int maxn = 200005;
const long long mod = 1000000007;
vector<pair<int, long long> > g[maxn];
long long sumDist[maxn], sumDistAll[maxn], sumDistUp[maxn];
long long sumDist2[maxn], sumDistAll2[maxn], sumDistUp2[maxn];
long long cnt[maxn];
int tin[maxn], tout[maxn];
int timer = 1;
int parent[maxn][18];
int depth[maxn];
long long depth2[maxn];
long long n;
void dfs(int v, int p, int d, long long d2 = 0) {
tin[v] = timer++;
parent[v][0] = p;
depth[v] = d + 1;
cnt[v] = 1;
depth2[v] = d2;
for (int i = 1; i < 18; i++) parent[v][i] = parent[parent[v][i - 1]][i - 1];
for (pair<int, int> to : g[v]) {
if (to.first == p) continue;
dfs(to.first, v, d + 1, d2 + to.second);
long long l2 = ((long long)to.second * to.second) % mod;
sumDist[v] =
(sumDist[v] + (sumDist[to.first] + cnt[to.first] * 1LL * to.second)) %
mod;
sumDist2[v] = (sumDist2[v] +
(sumDist2[to.first] +
((((long long)to.second) * 2LL * sumDist[to.first]) % mod) +
cnt[to.first] * l2)) %
mod;
cnt[v] += cnt[to.first];
}
tout[v] = timer;
}
void dfs2(int v, int p, long long upDist, long long upDist2) {
sumDistAll[v] = (sumDist[v] + upDist) % mod;
sumDistAll2[v] = (sumDist2[v] + upDist2) % mod;
sumDistUp[v] = upDist;
sumDistUp2[v] = upDist2;
for (pair<int, int> to : g[v]) {
if (to.first == p) continue;
long long l2 = ((long long)to.second * to.second) % mod;
long long newUpDist =
(upDist + sumDist[v] -
((sumDist[to.first] + cnt[to.first] * to.second) % mod) + mod) %
mod;
long long t = newUpDist;
newUpDist =
(newUpDist + ((long long)to.second) * (n - cnt[to.first])) % mod;
long long newUpDist2 =
(upDist2 + sumDist2[v] -
((sumDist2[to.first] +
(((long long)to.second * 2LL * sumDist[to.first]) % mod) +
cnt[to.first] * l2) %
mod) +
mod) %
mod;
newUpDist2 = (newUpDist2 + (((long long)to.second * 2LL * t) % mod) +
l2 * (n - cnt[to.first])) %
mod;
dfs2(to.first, v, newUpDist, newUpDist2);
}
}
int lca(int a, int b) {
if (depth[a] < depth[b]) swap(a, b);
int diff = depth[a] - depth[b];
for (int i = 0; i < 18; i++)
if (diff & (1 << i)) a = parent[a][i];
if (a == b) return a;
int ans;
for (int i = 17; i >= 0; i--) {
if (parent[a][i] == parent[b][i])
ans = parent[a][i];
else {
a = parent[a][i];
b = parent[b][i];
}
}
return ans;
}
long long query(int u, int v) {
if (!(tin[v] <= tin[u] && tin[u] < tout[v])) {
int z = lca(u, v);
long long d = (depth2[u] - depth2[z] + depth2[v] - depth2[z]) % mod;
long long d2 = (d * d) % mod;
long long ans = sumDistAll2[u];
ans = (ans + 3LL * mod -
2LL * ((sumDist2[v] + ((2LL * d * sumDist[v]) % mod) + d2 * cnt[v]) %
mod)) %
mod;
ans = (mod - ans) % mod;
return ans;
} else {
long long ans = sumDistAll2[u];
long long d = (depth2[u] - depth2[v]) % mod;
d = (d + mod) % mod;
long long d2 = (d * d) % mod;
ans = (ans + 3LL * mod -
2LL * ((sumDistUp2[v] + 2LL * d * sumDistUp[v] + d2 * (n - cnt[v])) %
mod)) %
mod;
return ans;
}
}
int main() {
int _n;
scanf("%d", &_n);
n = _n;
for (int i = 0; i < n - 1; i++) {
int u, v, c;
scanf("%d %d %d", &u, &v, &c);
g[u].push_back(make_pair(v, c));
g[v].push_back(make_pair(u, c));
}
dfs(1, 1, 0);
dfs2(1, 1, 0, 0);
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d %d", &u, &v);
printf("%d\n", (int)query(u, v));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, MOD = 1000000007;
int n, q;
vector<pair<int, int> > a[N];
int lv[N], pa[20][N];
long long d[N];
long long f[N], g[N], rf[N], rg[N], cnt[N];
void dfs(int u, int p) {
cnt[u] = 1;
f[u] = g[u] = 0;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
long long len = a[u][i].second;
if (v == p) {
continue;
}
d[v] = (d[u] + len) % MOD;
lv[v] = lv[u] + 1;
pa[0][v] = u;
dfs(v, u);
cnt[u] += cnt[v];
g[u] = (g[u] + g[v] + cnt[v] * len) % MOD;
f[u] = (f[u] + f[v] + g[v] * len * 2 + cnt[v] * (len * len % MOD)) % MOD;
}
}
void dfs2(int u, int p) {
vector<long long> ff(a[u].size(), rf[u]);
vector<long long> gg(a[u].size(), rg[u]);
long long curf = 0, curg = 0;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
long long len = a[u][i].second;
if (v == p) {
continue;
}
ff[i] = (ff[i] + curf) % MOD;
gg[i] = (gg[i] + curg) % MOD;
curg = (curg + g[v] + cnt[v] * len) % MOD;
curf = (curf + f[v] + g[v] * len * 2 + cnt[v] * (len * len % MOD)) % MOD;
}
curf = 0, curg = 0;
for (int i = (int)a[u].size() - 1; i >= 0; i--) {
int v = a[u][i].first;
long long len = a[u][i].second;
if (v == p) {
continue;
}
ff[i] = (ff[i] + curf) % MOD;
gg[i] = (gg[i] + curg) % MOD;
curg = (curg + g[v] + cnt[v] * len) % MOD;
curf = (curf + f[v] + g[v] * len * 2 + cnt[v] * (len * len % MOD)) % MOD;
}
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
long long len = a[u][i].second;
if (v == p) {
continue;
}
rg[v] = (rg[v] + gg[i] + len * (1ll * n - cnt[v])) % MOD;
rf[v] = (rf[v] + ff[i] + gg[i] * len * 2 +
(len * len % MOD) * (1ll * n - cnt[v])) %
MOD;
dfs2(v, u);
}
}
int lca(int u, int v) {
if (lv[u] < lv[v]) swap(u, v);
int l = (lv[u] - lv[v]);
for (int i = 19; i >= 0; i--) {
if (l & (1 << i)) {
u = pa[i][u];
}
}
if (u == v) {
return u;
}
for (int i = 19; i >= 0; i--) {
if (pa[i][u] != pa[i][v]) {
u = pa[i][u];
v = pa[i][v];
}
}
return pa[0][u];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
a[u].push_back(make_pair(v, w));
a[v].push_back(make_pair(u, w));
}
dfs(1, 0);
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= n; j++) {
pa[i][j] = pa[i - 1][pa[i - 1][j]];
}
}
dfs2(1, 0);
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
long long res = 0;
if (u == v) {
res = (f[u] - rf[u] + MOD) % MOD;
cout << res << endl;
continue;
}
int w = lca(u, v);
if (w == v) {
long long len = (d[u] - d[v] + MOD) % MOD;
res = (rf[v] + len * rg[v] * 2 + (len * len % MOD) * (1ll * n - cnt[v])) %
MOD;
res = (f[u] + rf[u] - res * 2 + MOD + MOD) % MOD;
cout << res << endl;
} else {
long long len = (d[u] + d[v] - d[w] - d[w] + MOD + MOD) % MOD;
res = (f[v] + len * g[v] * 2 + (len * len % MOD) * cnt[v]) % MOD;
res = (res * 2 - f[u] - rf[u] + MOD + MOD) % MOD;
cout << res << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e5 + 10, MOD = 1e9 + 7, MAX_L = 22;
long long n, q;
vector<pair<long long, long long>> adj[MAX_N];
long long sz[MAX_N], dis[MAX_N], fazir[MAX_N], fazir2[MAX_N], fabal[MAX_N],
fabal2[MAX_N], lca[MAX_N][MAX_L + 10], fasta1[MAX_N];
void down(long long v, long long par = 0, long long w = 0) {
sz[v] = 1;
dis[v] = dis[par] + 1;
fasta1[v] = (fasta1[par] + w) % MOD;
lca[v][0] = par;
for (long long i = 1; i < MAX_L; i++) {
lca[v][i] = lca[lca[v][i - 1]][i - 1];
}
for (auto u : adj[v]) {
if (u.first != par) {
down(u.first, v, u.second);
sz[v] += sz[u.first];
fazir[v] += (((u.second * sz[u.first]) % MOD) + fazir[u.first]) % MOD;
fazir[v] %= MOD;
fazir2[v] += ((((u.second * u.second % MOD * sz[u.first] % MOD) +
fazir2[u.first]) %
MOD) +
(2 * u.second % MOD * fazir[u.first] % MOD)) %
MOD;
fazir2[v] %= MOD;
}
}
}
void up(long long v, long long par = 0, long long w = 0) {
if (v != 1) {
fabal[v] =
((fabal[par] + (w * (n - sz[v]) % MOD)) % MOD) +
(((fazir[par] - (((w * sz[v] % MOD) + fazir[v]) % MOD)) + MOD) % MOD);
fabal[v] %= MOD;
fabal2[v] = w * w % MOD * (n - sz[v]) % MOD;
fabal2[v] %= MOD;
fabal2[v] += fabal2[par];
fabal2[v] %= MOD;
fabal2[v] += 2 * w % MOD * fabal[par] % MOD;
fabal2[v] %= MOD;
fabal2[v] +=
(((fazir2[par] - (((w * w % MOD * sz[v] % MOD) + fazir2[v]) % MOD +
(2 * w % MOD * fazir[v] % MOD)) %
MOD) %
MOD) +
MOD) %
MOD;
fabal2[v] %= MOD;
fabal2[v] +=
2 * w % MOD *
((((fazir[par] - (((w * sz[v] % MOD) + fazir[v]) % MOD)) % MOD) + MOD) %
MOD);
fabal2[v] %= MOD;
}
for (auto u : adj[v]) {
if (u.first != par) {
up(u.first, v, u.second);
}
}
}
long long get_par(long long v, long long k) {
for (long long i = 0; i < MAX_L; i++) {
if (k >> i & 1) {
v = lca[v][i];
}
}
return v;
}
long long get_lca(long long v, long long u) {
if (dis[v] < dis[u]) {
swap(v, u);
}
v = get_par(v, dis[v] - dis[u]);
if (u == v) {
return v;
}
for (long long i = MAX_L - 1; i >= 0; i--) {
if (lca[v][i] != lca[u][i]) {
v = lca[v][i];
u = lca[u][i];
}
}
return lca[v][0];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long a, b, c;
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
dis[0] = -1;
down(1);
up(1);
cin >> q;
while (q--) {
long long u, v, lc;
long long ans = 0, fas;
cin >> u >> v;
lc = get_lca(u, v);
fas =
(((fasta1[v] + fasta1[u]) % MOD) - (2 * fasta1[lc] % MOD) + MOD) % MOD;
if (lc == v) {
ans = (((fazir2[u] + fabal2[u]) % MOD) -
(((((fas * fas % MOD) * (n - sz[v])) % MOD) + fabal2[v] +
((2 * fas % MOD * fabal[v]) % MOD)) %
MOD) +
MOD) %
MOD;
} else {
ans = ((fas * fas % MOD * sz[v]) % MOD) + fazir2[v] +
((2 * fas % MOD * fazir[v]) % MOD);
}
ans %= MOD;
ans *= 2;
ans %= MOD;
ans -= ((fazir2[u] + fabal2[u]) % MOD);
ans %= MOD;
cout << (ans + MOD) % MOD << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100050, maxb = 18, mod = 1e9 + 7;
inline int Add(int x, int y) { return (x += y) >= mod ? x - mod : x; }
inline int Dec(int x, int y) { return (x -= y) < 0 ? x + mod : x; }
inline int Mul(int x, int y) { return 1LL * x * y % mod; }
struct Element {
int siz;
long long sum, sum2;
Element(int siz = 0, int sum = 0, int sum2 = 0)
: siz(siz), sum(sum), sum2(sum2) {}
Element operator+(Element yy) {
return Element(siz + yy.siz, Add(sum, yy.sum), Add(sum2, yy.sum2));
}
Element operator-(Element yy) {
return Element(siz - yy.siz, Dec(sum, yy.sum), Dec(sum2, yy.sum2));
}
Element calc(int c) {
return Element(siz, Add(sum, Mul(c, siz)),
Add(sum2, Mul(c, Add(Mul(2, sum), Mul(c, siz)))));
}
};
int n, q;
int es = 0, he[maxn], ne[maxn * 2], to[maxn * 2], w[maxn * 2];
int dep[maxn], fa[maxn][maxb];
int d[maxn][maxb];
Element v[maxn], vv[maxn][maxb];
void ins(int x, int y, int z) {
ne[++es] = he[x], he[x] = es, to[es] = y, w[es] = z;
}
void dfs(int x) {
int i, y, f0 = fa[x][0];
dep[x] = dep[f0] + 1;
for (i = 0; fa[x][i]; i++) {
fa[x][i + 1] = fa[fa[x][i]][i];
d[x][i + 1] = Add(d[x][i], d[fa[x][i]][i]);
}
v[x].siz = 1;
for (i = he[x]; i; i = ne[i])
if ((y = to[i]) != f0) {
fa[y][0] = x;
d[y][0] = w[i];
dfs(y);
v[x] = v[x] + v[y].calc(w[i]);
}
}
void dfs2(int x) {
int i, y, f0 = fa[x][0], d0 = d[x][0];
if (x != 1) vv[x][0] = (v[f0] - v[x].calc(d0)).calc(d0);
for (i = 0; fa[x][i + 1]; i++)
vv[x][i + 1] = vv[x][i] + vv[fa[x][i]][i].calc(d[x][i]);
for (i = he[x]; i; i = ne[i])
if ((y = to[i]) != f0) dfs2(y);
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int i;
for (i = maxb - 1; i >= 0; i--)
if (dep[x] - dep[y] >= 1 << i) x = fa[x][i];
if (x == y) return x;
for (i = maxb - 1; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int get_dis(int x, int f) {
int i, k = dep[x] - dep[f], s = 0;
for (i = maxb - 1; i >= 0; i--)
if (k >= 1 << i) k -= 1 << i, s = Add(s, d[x][i]), x = fa[x][i];
return s;
}
Element get(int x, int f) {
int i, k = dep[x] - dep[f], d0 = 0;
Element s;
for (i = maxb - 1; i >= 0; i--)
if (k >= 1 << i)
k -= 1 << i, s = s + vv[x][i].calc(d0), d0 = Add(d0, d[x][i]),
x = fa[x][i];
return s;
}
int query(int x, int y) {
int lca = LCA(x, y), dx = get_dis(x, lca), dy = get_dis(y, lca), s = 0;
if (lca == x) {
int t = v[y].calc(dy).sum2;
s = Dec(t, Add(get(x, 1).sum2, Dec(v[x].sum2, t)));
} else if (lca == y)
s = Dec(Add(get(x, y).sum2, v[x].sum2), get(y, 1).calc(dx).sum2);
else {
int t = v[y].calc(Add(dx, dy)).sum2;
s = Dec(t, Add(v[x].sum2, Dec(get(x, 1).sum2, t)));
}
return s;
}
int main() {
int i, x, y, z;
scanf("%d", &n);
for (i = 1; i < n; i++)
scanf("%d%d%d", &x, &y, &z), ins(x, y, z), ins(y, x, z);
dfs(1);
dfs2(1);
scanf("%d", &q);
while (q--) {
scanf("%d%d", &x, &y);
printf("%d\n", query(x, y));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double PI = acos(-1);
template <class T, class S>
inline void add(T& a, S b) {
a += b;
if (a >= mod) a -= mod;
}
template <class T, class S>
inline void sub(T& a, S b) {
a -= b;
if (a < 0) a += mod;
}
template <class T, class S>
inline bool chkmax(T& a, S b) {
return a < b ? a = b, true : false;
}
template <class T, class S>
inline bool chkmin(T& a, S b) {
return a > b ? a = b, true : false;
}
int n, q;
int pa[N][20], len[N][20], depth[N];
int allDis2[N];
vector<pair<int, int> > G[N];
struct dpNode {
dpNode() { cnt = sumDis = sumDis2 = 0; }
dpNode(int cnt, int sumDis, int sumDis2)
: cnt(cnt), sumDis(sumDis), sumDis2(sumDis2) {}
int cnt, sumDis, sumDis2;
void print() {
printf("cnt: %d sumDis: %d sumDis2: %d\n", cnt, sumDis, sumDis2);
}
} dp[N], dp2[N], INIT(1, 0, 0);
dpNode mergeTwo(dpNode a, dpNode b, int w, int op) {
if (op > 0) {
a.cnt += b.cnt;
add(a.sumDis, b.sumDis);
add(a.sumDis, 1LL * b.cnt * w % mod);
add(a.sumDis2, b.sumDis2);
add(a.sumDis2, 1LL * b.sumDis * 2 * w % mod);
add(a.sumDis2, 1LL * w * w % mod * b.cnt % mod);
} else {
a.cnt -= b.cnt;
sub(a.sumDis, b.sumDis);
sub(a.sumDis, 1LL * b.cnt * w % mod);
sub(a.sumDis2, b.sumDis2);
sub(a.sumDis2, 1LL * b.sumDis * 2 * w % mod);
sub(a.sumDis2, 1LL * w * w % mod * b.cnt % mod);
}
return a;
}
void dfs(int u, int fa, int disTofa) {
depth[u] = depth[fa] + 1;
pa[u][0] = fa;
len[u][0] = disTofa;
dp[u].cnt = 1;
for (int i = 1; i < 20; i++) {
pa[u][i] = pa[pa[u][i - 1]][i - 1];
len[u][i] = (len[u][i - 1] + len[pa[u][i - 1]][i - 1]) % mod;
}
for (auto& e : G[u]) {
int v = e.second;
if (v == fa) continue;
dfs(v, u, e.first);
dp[u] = mergeTwo(dp[u], dp[v], e.first, 1);
}
}
pair<int, int> getLca(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
int dis = depth[u] - depth[v];
int ret = 0;
for (int i = 19; i >= 0; i--)
if (dis >> i & 1) add(ret, len[u][i]), u = pa[u][i];
if (u == v) return make_pair(ret, u);
for (int i = 19; i >= 0; i--) {
if (pa[u][i] != pa[v][i]) {
add(ret, len[u][i]);
add(ret, len[v][i]);
u = pa[u][i];
v = pa[v][i];
}
}
add(ret, len[u][0]);
add(ret, len[v][0]);
return make_pair(ret, pa[u][0]);
}
void dfs2(int u, int fa, dpNode up) {
dp2[u] = up;
dp2[u].cnt--;
allDis2[u] = (dp[u].sumDis2 + up.sumDis2) % mod;
for (auto& e : G[u]) {
if (e.second == fa) continue;
up = mergeTwo(up, dp[e.second], e.first, 1);
}
for (auto& e : G[u]) {
if (e.second == fa) continue;
up = mergeTwo(up, dp[e.second], e.first, -1);
dfs2(e.second, u, mergeTwo(INIT, up, e.first, 1));
up = mergeTwo(up, dp[e.second], e.first, 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(make_pair(w, v));
G[v].push_back(make_pair(w, u));
}
dfs(1, 0, 0);
dfs2(1, 0, INIT);
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
pair<int, int> ret = getLca(u, v);
int lca = ret.second, dis = ret.first;
int ans = 0;
if (lca != v) {
int x = mergeTwo(INIT, dp[v], dis, 1).sumDis2;
int z = allDis2[u];
ans = ((2 * x - z) % mod + mod) % mod;
} else {
int y = mergeTwo(INIT, dp2[v], dis, 1).sumDis2;
int z = allDis2[u];
ans = ((z - 2 * y) % mod + mod) % mod;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void output(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x == 0) {
putchar('0');
return;
}
int a[20], num = 0;
while (x) a[++num] = x % 10, x /= 10;
while (num > 0) putchar('0' + a[num--]);
}
inline long long getInt() {
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
int flag = 1;
if (c == '-') flag = -1, c = getchar();
long long x = 0;
while (isdigit(c)) {
x = (x * 10) + (c - '0');
c = getchar();
}
if (flag == -1) return -x;
return x;
}
const int mod = 1000000007;
const int N = 100005;
struct node {
int v, next;
long long w;
};
node edges[N << 1];
int head[N], e;
void add(int u, int v, int w) {
edges[e].v = v;
edges[e].w = w;
edges[e].next = head[u];
head[u] = e++;
}
int n, m;
long long p1[N], p2[N], s[N];
int dep[N];
int fa[N][20];
long long lenFromRoot[N];
void DFS(int u, int pre) {
fa[u][0] = pre;
s[u] = 1;
int i;
for (i = head[u]; i != -1; i = edges[i].next) {
int v = edges[i].v;
long long w = edges[i].w;
if (v == pre) continue;
dep[v] = dep[u] + 1;
lenFromRoot[v] = (lenFromRoot[u] + w) % mod;
DFS(v, u);
p2[u] += p2[v] + 2 * w % mod * p1[v] % mod + w * w % mod * s[v] % mod;
p2[u] %= mod;
p1[u] += p1[v] + s[v] * w % mod;
p1[u] %= mod;
s[u] += s[v];
}
}
long long f[N];
long long pp2[N], pp1[N], ss[N];
long long ppp2[N], ppp1[N], sss[N];
void dfs(int u, int pre) {
f[u] = p2[u];
int i;
for (i = head[u]; i != -1; i = edges[i].next) {
int v = edges[i].v;
long long w = edges[i].w;
if (v == pre) continue;
pp2[v] =
p2[u] - (p2[v] + 2 * w % mod * p1[v] % mod + w * w % mod * s[v] % mod);
pp1[v] = p1[u] - p1[v] - s[v] * w % mod;
ss[v] = n - s[v];
p2[v] += pp2[v] + 2 * w % mod * pp1[v] % mod + w * w % mod * ss[v] % mod;
p2[v] %= mod;
p1[v] += pp1[v] + (n - s[v]) * w % mod;
p1[v] %= mod;
dfs(v, u);
}
}
int getLca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int x = dep[u] - dep[v];
int i;
for (i = 0; i < 20; i++)
if (x & (1 << i)) u = fa[u][i];
if (u == v) return v;
for (i = 19; i >= 0; i--)
if (fa[u][i] && fa[v][i] && fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
return fa[u][0];
}
long long calLen(int u, int v) {
int i;
for (i = head[u]; i != -1; i = edges[i].next) {
if (edges[i].v == v) return edges[i].w;
}
}
long long cal1(int u, int v, int lca) {
long long a = ppp2[u];
if (1 == v) {
return f[u];
}
long long c = 0;
long long w = calLen(v, fa[v][0]);
w += lenFromRoot[u] - lenFromRoot[v];
w %= mod;
c += pp2[v] + 2 * w % mod * pp1[v] % mod + w * w % mod * ss[v] % mod;
c %= mod;
long long b = f[u] - a - c;
b %= mod;
if (b < 0) b += mod;
return 2 * (a + b) - f[u];
}
long long cal2(int u, int v, int lca) {
long long L = lenFromRoot[u] + lenFromRoot[v] - 2 * lenFromRoot[lca];
L %= mod;
long long a = 0;
a += ppp2[v] + 2 * L % mod * ppp1[v] % mod + L * L % mod * sss[v] % mod;
a %= mod;
return 2 * a - f[u];
}
int main() {
n = getInt();
memset(head, -1, sizeof(head));
int i;
for (i = 1; i < n; i++) {
int u = getInt();
int v = getInt();
int w = getInt();
add(u, v, w);
add(v, u, w);
}
DFS(1, 0);
for (i = 1; i <= n; i++) {
ppp2[i] = p2[i];
ppp1[i] = p1[i];
sss[i] = s[i];
}
dfs(1, 0);
int j;
for (j = 1; j < 20; j++)
for (i = 1; i <= n; i++) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
m = getInt();
while (m--) {
int u = getInt();
int v = getInt();
int lca = getLca(u, v);
long long ans;
if (lca == v)
ans = cal1(u, v, lca);
else
ans = cal2(u, v, lca);
ans %= mod;
if (ans < 0) ans += mod;
printf("%d\n", (int)ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T min(T &a, T &b) {
return a < b ? a : b;
}
template <class T>
inline T max(T &a, T &b) {
return a > b ? a : b;
}
template <class T>
void read(T &x) {
char ch;
while ((ch = getchar()) && !isdigit(ch))
;
x = ch - '0';
while ((ch = getchar()) && isdigit(ch)) x = x * 10 + ch - '0';
}
struct point {
int x, y;
point() {}
point(int _x, int _y) : x(_x), y(_y) {}
};
long long Pow(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long Pow(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
a = a * a;
}
return res;
}
const long long Mod = 1000000007;
const int N = 120000;
vector<int> E[N];
vector<long long> F[N];
int f[N][22], n, Dep[N];
long long dep[N], sum[N], sum2[N], size[N], upsize[N], upsum[N], upsum2[N];
void dfs(int w, int Fa, int c) {
f[w][0] = Fa;
dep[w] = sum[w] = (dep[Fa] + (long long)c) % Mod;
Dep[w] = Dep[Fa] + 1;
sum2[w] = dep[w] * dep[w] % Mod;
size[w] = 1;
for (int i = 0; i < E[w].size(); i++)
if (E[w][i] != Fa) {
dfs(E[w][i], w, F[w][i]);
size[w] = size[w] + size[E[w][i]];
sum[w] = (sum[w] + sum[E[w][i]]) % Mod;
sum2[w] = (sum2[w] + sum2[E[w][i]]) % Mod;
}
}
void dp() {
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
}
int lca(int x, int y) {
if (Dep[x] < Dep[y]) swap(x, y);
for (int i = 20; i >= 0; i--)
if (Dep[f[x][i]] >= Dep[y]) x = f[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
void dfs2(int w, int Fa, int c) {
for (int i = 0; i < E[w].size(); i++)
if (E[w][i] != Fa) {
upsize[E[w][i]] = (upsize[w] + size[w] - size[E[w][i]]) % Mod;
upsum[E[w][i]] =
((upsum[w] + upsize[w] * F[w][i]) % Mod + sum[w] - sum[E[w][i]] +
(dep[E[w][i]] - 2LL * dep[w]) * (size[w] - size[E[w][i]])) %
Mod;
upsum2[E[w][i]] = (upsum2[w] + (2LL * upsum[w] * F[w][i]) % Mod +
(F[w][i] * F[w][i]) % Mod * upsize[w] % Mod) %
Mod;
long long c;
c = (sum2[w] - sum2[E[w][i]] +
(2LL * (sum[w] - sum[E[w][i]]) * (dep[E[w][i]] - 2LL * dep[w])) %
Mod +
(dep[E[w][i]] - 2LL * dep[w]) * (dep[E[w][i]] - 2LL * dep[w]) % Mod *
(size[w] - size[E[w][i]])) %
Mod;
upsum2[E[w][i]] = (upsum2[E[w][i]] + c) % Mod;
dfs2(E[w][i], w, F[w][i]);
}
}
long long solve(int x, int y) {
int z = lca(x, y);
long long ans = 0;
if (x == y || z != y) {
ans = (sum2[y] + (2LL * sum[y] * (dep[x] - 2LL * dep[z])) % Mod +
(dep[x] - 2LL * dep[z]) * (dep[x] - 2LL * dep[z]) % Mod * size[y] %
Mod) %
Mod;
} else {
ans = (sum2[x] + (2LL * sum[x] * (dep[x] - 2LL * dep[x])) % Mod +
(dep[x] - 2LL * dep[x]) * (dep[x] - 2LL * dep[x]) % Mod * size[x] %
Mod) %
Mod;
ans = (ans + upsum2[x]) % Mod;
ans =
(ans - (upsum2[y] + 2LL * upsum[y] * (dep[x] - dep[y]) +
(dep[x] - dep[y]) * (dep[x] - dep[y]) % Mod * upsize[y] % Mod) %
Mod) %
Mod;
}
ans %= Mod;
return (ans + Mod) % Mod;
}
int main() {
scanf("%d", &n);
int x, y, m;
long long z;
for (int i = 1; i <= n - 1; i++)
scanf("%d%d%lld", &x, &y, &z), E[x].push_back(y), E[y].push_back(x),
F[x].push_back(z), F[y].push_back(z);
dfs(1, 0, 0);
dp();
dfs2(1, 0, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
long long ans = (solve(x, y) * 2LL - solve(x, 1)) % Mod;
printf("%lld\n", (ans + Mod) % Mod);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100 * 1000 + 5, LG = 19, mod = 1000 * 1000 * 1000 + 7;
long long n, q;
long long sz[N], h[N];
long long sumd[N], sumu[N], dpd[N], dpu[N];
pair<long long, long long> par[N][LG];
vector<pair<long long, long long> > adj[N];
void dfs1(long long v) {
sz[v] = 1;
for (auto p : adj[v]) {
long long u = p.first;
long long w = p.second;
if (u != par[v][0].first) {
h[u] = h[v] + 1;
par[u][0] = {v, w};
dfs1(u);
sz[v] += sz[u];
sumd[v] += sumd[u] + 1ll * w * sz[u];
sumd[v] %= mod;
long long t = 1ll * w * w;
t %= mod;
t *= sz[u];
t %= mod;
dpd[v] += 2ll * sumd[u] * w;
dpd[v] %= mod;
dpd[v] += t;
dpd[v] += dpd[u];
dpd[v] %= mod;
}
}
}
void dfs2(long long v) {
for (auto p : adj[v]) {
long long u = p.first;
long long w = p.second;
if (u != par[v][0].first) {
long long q = dpd[v] + dpu[v];
long long t = 1ll * w * w;
t %= mod;
t *= sz[u];
t %= mod;
q -= t - mod;
q -= (2ll * sumd[u] * w) % mod - mod;
q -= dpd[u] - mod;
q %= mod;
dpu[u] = q;
long long t2 = 1ll * w * w;
t2 %= mod;
t2 *= (n - sz[u]);
t2 %= mod;
dpu[u] += t2;
dpu[u] %= mod;
dpu[u] += 1ll * (mod + 1) * mod;
dpu[u] %= mod;
long long kft =
sumd[v] + sumu[v] - sumd[u] - 1ll * w * sz[u] + 1ll * mod * mod;
kft %= mod;
kft *= 2 * w;
kft %= mod;
dpu[u] += kft;
dpu[u] %= mod;
sumu[u] =
sumd[v] + sumu[v] - 1ll * sz[u] * w - sumd[u] + 1ll * (n - sz[u]) * w;
sumu[u] += 1ll * mod * mod;
sumu[u] %= mod;
dfs2(u);
}
}
}
pair<long long, long long> lcad(long long u, long long v) {
long long ans = 0;
if (h[u] > h[v]) {
swap(u, v);
}
for (long long i = LG - 1; i >= 0; i--) {
if (h[u] + (1 << i) <= h[v]) {
ans += par[v][i].second;
v = par[v][i].first;
}
}
if (u == v) {
return {ans, u};
}
for (long long i = LG - 1; i >= 0; i--) {
if (par[v][i].first != par[u][i].first) {
ans += par[v][i].second;
ans += par[u][i].second;
v = par[v][i].first;
u = par[u][i].first;
}
}
ans += par[v][0].second + par[u][0].second;
return {ans, par[v][0].first};
}
int32_t main() {
cin >> n;
for (long long i = 1; i < n; i++) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
par[1][0].first = 1;
dfs1(1);
dfs2(1);
cin >> q;
for (long long j = 1; j < LG; j++) {
for (long long i = 1; i <= n; i++) {
long long u = par[i][j - 1].first;
par[i][j].first = par[u][j - 1].first;
par[i][j].second = (par[i][j - 1].second + par[u][j - 1].second) % mod;
}
}
for (long long i = 0; i < q; i++) {
long long u, v;
cin >> u >> v;
pair<long long, long long> p = lcad(u, v);
long long x = p.first;
long long r = p.second;
x %= mod;
if (r == v) {
long long ans = dpd[u] + dpu[u];
long long e = 2ll * sumu[v];
e %= mod;
e *= x;
e %= mod;
ans -= 2ll * (e + dpu[v]) - 4ll * mod;
ans %= mod;
long long kft = 1ll * ((2ll * x * x) % mod) * (n - sz[v]);
kft %= mod;
ans -= kft - mod;
ans += mod;
ans %= mod;
cout << ans << endl;
} else {
long long ans = 2ll * mod - dpd[u] - dpu[u];
long long e = 2ll * sumd[v];
e %= mod;
e *= x;
e %= mod;
ans += 2ll * (e + dpd[v]);
ans %= mod;
ans += ((2ll * x * x) % mod) * sz[v];
ans %= mod;
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = (int)1e9 + 7;
const int N = (int)1e5 + 10;
const int L = 17;
int sum0[N], sum1[N], sum2[N], psum0[N], psum1[N], psum2[N], par[L][N], in[N],
out[N], curt, u, v, w, h[N], delta0[N], delta1[N], delta2[N], n, q;
vector<pair<int, int> > adj[N];
int add(int a, int b) { return (a + b) % M; }
int mult(int a, int b) { return (a * 1ll * b) % M; }
bool is_parent(int u, int v) { return (in[u] <= in[v]) && (out[v] <= out[u]); }
int sq_sum(int sum0, int sum1, int sum2, int w) {
return add(add(sum2, mult(sum1, mult(2, w))), mult(sum0, mult(w, w)));
}
void dfs(int v, int p = -1) {
in[v] = curt++, par[0][v] = ((p == -1) ? v : p), sum0[v] = 1, sum1[v] = 0,
sum2[v] = 0;
for (int i = 0; i < int(adj[v].size()); ++i) {
int u = adj[v][i].first, w = adj[v][i].second;
if (u == p) continue;
h[u] = add(h[v], w);
dfs(u, v);
sum0[v] = add(sum0[v], delta0[u] = sum0[u]);
sum1[v] = add(sum1[v], delta1[u] = add(sum1[u], mult(sum0[u], w)));
sum2[v] = add(sum2[v], delta2[u] = sq_sum(sum0[u], sum1[u], sum2[u], w));
}
out[v] = curt++;
}
void ndfs(int v, int p = -1) {
for (int i = 0; i < int(adj[v].size()); ++i) {
int u = adj[v][i].first, w = adj[v][i].second;
if (u == p) continue;
psum0[u] = add(psum0[v], add(sum0[v], M - delta0[u]));
psum1[u] = add(psum1[v], add(sum1[v], M - delta1[u]));
psum2[u] = add(psum2[v], add(sum2[v], M - delta2[u]));
psum2[u] = sq_sum(psum0[u], psum1[u], psum2[u], w);
psum1[u] = add(psum1[u], mult(psum0[u], w));
ndfs(u, v);
}
}
int lca(int u, int v) {
if (is_parent(u, v)) return u;
for (int j = L - 1; j >= 0; --j)
if (!is_parent(par[j][u], v)) u = par[j][u];
return par[0][u];
}
int main() {
int n;
cin >> n;
for (int i = 0; i + 1 < n; ++i) {
scanf("%d%d%d", &u, &v, &w), --u, --v;
adj[u].push_back(make_pair(v, w)), adj[v].push_back(make_pair(u, w));
}
dfs(0);
for (int j = 1; j < L; ++j) {
for (int i = 0; i < n; ++i) par[j][i] = par[j - 1][par[j - 1][i]];
}
ndfs(0);
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d%d", &u, &v), --u, --v;
w = add(add(h[u], h[v]), M - mult(2, h[lca(u, v)]));
if (!is_parent(v, u)) {
printf("%d\n", add(mult(2, sq_sum(sum0[v], sum1[v], sum2[v], w)),
M - add(psum2[u], sum2[u])));
} else {
printf("%d\n", add(M - mult(2, sq_sum(psum0[v], psum1[v], psum2[v], w)),
add(psum2[u], sum2[u])));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = (int)1e9 + 7;
const int N = (int)1e5 + 10;
const int L = 17;
int sum0[N], sum1[N], sum2[N], psum0[N], psum1[N], psum2[N], par[L][N], in[N],
out[N], curt, u, v, w, h[N], delta0[N], delta1[N], delta2[N], n, q;
vector<pair<int, int> > adj[N];
int add(int a, int b) { return (a + b) % M; }
int mult(int a, int b) { return (a * (long long)b) % M; }
bool is_parent(int u, int v) { return (in[u] <= in[v]) && (out[v] <= out[u]); }
int sq_sum(int sum0, int sum1, int sum2, int w) {
return add(add(sum2, mult(sum1, mult(2, w))), mult(sum0, mult(w, w)));
}
void dfs(int v, int p = -1) {
in[v] = curt++, par[0][v] = ((p == -1) ? v : p), sum0[v] = 1, sum1[v] = 0,
sum2[v] = 0;
for (int i = 0; i < ((int)(adj[v]).size()); ++i) {
int u = adj[v][i].first, w = adj[v][i].second;
if (u == p) continue;
h[u] = add(h[v], w);
dfs(u, v);
sum0[v] = add(sum0[v], delta0[u] = sum0[u]);
sum1[v] = add(sum1[v], delta1[u] = add(sum1[u], mult(sum0[u], w)));
sum2[v] = add(sum2[v], delta2[u] = sq_sum(sum0[u], sum1[u], sum2[u], w));
}
out[v] = curt++;
}
void ndfs(int v, int p = -1) {
for (int i = 0; i < ((int)(adj[v]).size()); ++i) {
int u = adj[v][i].first, w = adj[v][i].second;
if (u == p) continue;
psum0[u] = add(psum0[v], add(sum0[v], M - delta0[u]));
psum1[u] = add(psum1[v], add(sum1[v], M - delta1[u]));
psum2[u] = add(psum2[v], add(sum2[v], M - delta2[u]));
psum2[u] = sq_sum(psum0[u], psum1[u], psum2[u], w);
psum1[u] = add(psum1[u], mult(psum0[u], w));
ndfs(u, v);
}
}
int lca(int u, int v) {
if (is_parent(u, v)) return u;
for (int j = L - 1; j >= 0; --j)
if (!is_parent(par[j][u], v)) u = par[j][u];
return par[0][u];
}
int main() {
scanf("%d", &n);
for (int i = 0; i + 1 < n; ++i) {
scanf("%d%d%d", &u, &v, &w), --u, --v;
adj[u].push_back(make_pair(v, w)), adj[v].push_back(make_pair(u, w));
}
dfs(0);
for (int j = 1; j < L; ++j)
for (int i = 0; i < n; ++i) par[j][i] = par[j - 1][par[j - 1][i]];
ndfs(0);
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d%d", &u, &v), --u, --v;
w = add(add(h[u], h[v]), M - mult(2, h[lca(u, v)]));
if (!is_parent(v, u))
printf("%d\n", add(mult(2, sq_sum(sum0[v], sum1[v], sum2[v], w)),
M - add(psum2[u], sum2[u])));
else
printf("%d\n", add(M - mult(2, sq_sum(psum0[v], psum1[v], psum2[v], w)),
add(psum2[u], sum2[u])));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100010;
const long long mod = 1e9 + 7;
vector<long long> adj[N], adjed[N];
long long parent[N][18], parentsum[N], edgecost[N], sum[N], sumsq[N],
counter = 0, sumo[N], sumsqo[N];
long long n, used[N], pin[N], pout[N], size[N];
void dfs(long long node) {
used[node] = 1;
size[node] = 1;
sum[node] = 0;
sumsq[node] = 0;
pin[node] = counter++;
for (long long i = 1; i < 18; ++i) {
parent[node][i] = parent[parent[node][i - 1]][i - 1];
}
long long t;
for (long long i = 0; i < adj[node].size(); ++i) {
t = adj[node][i];
if (used[t] == 0) {
parent[t][0] = node;
parentsum[t] = (parentsum[node] + edgecost[adjed[node][i]]) % mod;
dfs(t);
size[node] += size[t];
sum[node] =
(sum[node] + sum[t] + size[t] * edgecost[adjed[node][i]]) % mod;
sumsq[node] = (sumsq[node] + sumsq[t] +
(2 * ((sum[t] * edgecost[adjed[node][i]]) % mod))) %
mod;
sumsq[node] =
(sumsq[node] +
(size[t] *
((edgecost[adjed[node][i]] * edgecost[adjed[node][i]]) % mod)) %
mod) %
mod;
}
}
pout[node] = counter++;
}
void dfs2(long long node, long long s, long long sq, long long t) {
used[node] = 1;
sumo[node] = (s - sum[node] + ((n - 2 * size[node]) * t) % mod) % mod;
sumsqo[node] = (sq - sumsq[node] - (size[node] * ((t * t) % mod)) % mod -
2 * ((sum[node] * t) % mod)) %
mod;
sumsqo[node] =
(sumsqo[node] + ((n - size[node]) * ((t * t) % mod)) % mod +
(2 * ((t * (sumo[node] - ((n - size[node]) * t) % mod)) % mod)) % mod) %
mod;
long long m;
for (long long i = 0; i < adj[node].size(); ++i) {
m = adj[node][i];
if (used[m] == 0) {
dfs2(m, (sumo[node] + sum[node]) % mod,
(sumsq[node] + sumsqo[node]) % mod, edgecost[adjed[node][i]]);
}
}
}
long long ancestor(long long A, long long b) {
if (pin[A] <= pin[b] && pout[b] <= pout[A]) return 1;
return 0;
}
long long go_up(long long A, long long b) {
for (long long i = 18 - 1; i >= 0; i--) {
if (!ancestor(parent[A][i], b)) {
A = parent[A][i];
}
}
return A;
}
long long LCA(long long A, long long b) {
long long result = -1;
if (ancestor(A, b)) {
result = A;
} else if (ancestor(b, A)) {
result = b;
} else {
result = parent[go_up(A, b)][0];
}
return result;
}
int main() {
scanf("%lld", &n);
long long x, y, cost;
for (long long i = 0; i < n - 1; ++i) {
scanf("%lld %lld %lld", &x, &y, &cost);
adj[x].push_back(y);
adj[y].push_back(x);
adjed[x].push_back(i);
adjed[y].push_back(i);
edgecost[i] = cost;
}
memset(used, 0, sizeof(used));
parent[1][0] = 1;
parentsum[1] = 0;
used[1] = 1;
dfs(1);
memset(used, 0, sizeof(used));
dfs2(1, sum[1], sumsq[1], 0);
long long q, u, v;
scanf("%lld", &q);
for (long long i = 0; i < q; ++i) {
scanf("%lld %lld", &u, &v);
long long p = LCA(u, v);
long long s, ans = 0,
l = (parentsum[u] + parentsum[v] - 2 * parentsum[p]) % mod;
y = (ancestor(v, u)) ? 1 : -1;
if (y == -1) {
s = (sumsq[v] + 2 * (sum[v] * l) % mod +
(size[v] * ((l * l) % mod)) % mod) %
mod;
ans = (ans + s - (sumsqo[u] + sumsq[u] - s)) % mod;
} else {
s = (sumsqo[v] + 2 * ((sumo[v] * l) % mod) +
((n - size[v]) * ((l * l) % mod)) % mod) %
mod;
ans = (ans - s + (sumsqo[u] + sumsq[u] - s)) % mod;
}
printf("%lld\n", (ans + mod) % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const long double pi = acos(-1.0);
const int M = (int)1e9 + 7;
const int N = (int)1e5 + 10;
const int L = 17;
int sum0[N], sum1[N], sum2[N], psum0[N], psum1[N], psum2[N], par[L][N], in[N],
out[N], curt, u, v, w, h[N], delta0[N], delta1[N], delta2[N], n, q;
vector<pair<int, int> > adj[N];
int add(int a, int b) {
int c = a + b;
return (c >= M) ? (c - M) : c;
}
int mult(int a, int b) { return (a * (long long)b) % M; }
bool is_parent(int u, int v) { return (in[u] <= in[v]) && (out[v] <= out[u]); }
void dfs(int v, int p = -1) {
in[v] = curt++, par[0][v] = ((p == -1) ? v : p), sum0[v] = 1, sum1[v] = 0,
sum2[v] = 0;
for (int i = 0; i < ((int)(adj[v]).size()); ++i) {
int u = adj[v][i].first, w = adj[v][i].second;
if (u == p) continue;
h[u] = add(h[v], w);
dfs(u, v);
sum0[v] = add(sum0[v], delta0[u] = sum0[u]);
sum1[v] = add(sum1[v], delta1[u] = add(sum1[u], mult(sum0[u], w)));
sum2[v] =
add(sum2[v], delta2[u] = add(add(sum2[u], mult(sum1[u], mult(2, w))),
mult(sum0[u], mult(w, w))));
}
out[v] = curt++;
}
void ndfs(int v, int p = -1) {
for (int i = 0; i < ((int)(adj[v]).size()); ++i) {
int u = adj[v][i].first, w = adj[v][i].second;
if (u == p) continue;
psum0[u] = add(psum0[v], add(sum0[v], M - delta0[u]));
psum1[u] = add(psum1[v], add(sum1[v], M - delta1[u]));
psum2[u] = add(psum2[v], add(sum2[v], M - delta2[u]));
psum2[u] = add(psum2[u],
add(mult(psum1[u], mult(2, w)), mult(psum0[u], mult(w, w))));
psum1[u] = add(psum1[u], mult(psum0[u], w));
ndfs(u, v);
}
}
int lca(int u, int v) {
if (is_parent(u, v)) return u;
for (int j = L - 1; j >= 0; --j)
if (!is_parent(par[j][u], v)) u = par[j][u];
return par[0][u];
}
int main() {
scanf("%d", &n);
for (int i = 0; i + 1 < n; ++i) {
scanf("%d%d%d", &u, &v, &w), --u, --v;
adj[u].push_back(make_pair(v, w)), adj[v].push_back(make_pair(u, w));
}
dfs(0);
for (int j = 1; j < L; ++j)
for (int i = 0; i < n; ++i) par[j][i] = par[j - 1][par[j - 1][i]];
ndfs(0);
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d%d", &u, &v), --u, --v;
w = add(add(h[u], h[v]), M - mult(2, h[lca(u, v)]));
if (!is_parent(v, u)) {
printf("%d\n", add(mult(2, add(add(sum2[v], mult(sum1[v], mult(2, w))),
mult(sum0[v], mult(w, w)))),
M - add(psum2[u], sum2[u])));
} else {
printf("%d\n",
add(M - mult(2, add(add(psum2[v], mult(psum1[v], mult(2, w))),
mult(psum0[v], mult(w, w)))),
add(psum2[u], sum2[u])));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool getmin(T *a, const T &b) {
if (b < *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline bool getmax(T *a, const T &b) {
if (b > *a) {
*a = b;
return true;
}
return false;
}
template <class T>
inline void read(T *a) {
char c;
while (isspace(c = getchar())) {
}
bool flag = 0;
if (c == '-')
flag = 1, *a = 0;
else
*a = c - 48;
while (isdigit(c = getchar())) *a = *a * 10 + c - 48;
if (flag) *a = -*a;
}
const int mo = 1000000007;
template <class T>
T pow(T a, T b, int c = mo) {
T res = 1;
for (T i = 1; i <= b; i <<= 1, a = 1LL * a * a % c)
if (b & i) res = 1LL * res * a % c;
return res;
}
const int N = 101000;
struct node {
int s0, s1, s2;
int tg;
} tree[N * 4];
struct edge_node {
int p, nextt, w;
} edge[N * 2];
int cnt;
int head[N];
void ae(int a, int b, int c) {
edge[++cnt].p = b;
edge[cnt].nextt = head[a];
edge[cnt].w = c;
head[a] = cnt;
}
int l[N], r[N], idx;
int n, m;
void add(node &A, int x) {
A.tg = (A.tg + x) % mo;
A.s2 =
((A.s2 + 1LL * x * x % mo * A.s0 % mo) % mo + 2LL * x * A.s1 % mo) % mo;
A.s1 = (A.s1 + 1LL * x * A.s0 % mo) % mo;
}
void down(node &A, node &L, node &R) {
if (A.tg) {
add(L, A.tg);
add(R, A.tg);
A.tg = 0;
}
}
void update(node &A, const node &L, const node &R) {
A.s1 = (L.s1 + R.s1) % mo;
A.s2 = (L.s2 + R.s2) % mo;
}
int ans[N];
vector<pair<int, int> > q[N];
void modify(int u, int L, int R, int l, int r, int p) {
if (l <= L && r >= R) {
add(tree[u], p);
return;
}
down(tree[u], tree[u * 2], tree[u * 2 + 1]);
int mid = (L + R) >> 1;
if (r <= mid)
modify(u * 2, L, mid, l, r, p);
else if (l > mid)
modify(u * 2 + 1, mid + 1, R, l, r, p);
else
modify(u * 2, L, mid, l, mid, p),
modify(u * 2 + 1, mid + 1, R, mid + 1, r, p);
update(tree[u], tree[u * 2], tree[u * 2 + 1]);
}
int ask(int u, int L, int R, int l, int r) {
if (l <= L && r >= R) return tree[u].s2;
down(tree[u], tree[u * 2], tree[u * 2 + 1]);
int mid = (L + R) >> 1;
if (r <= mid)
return ask(u * 2, L, mid, l, r);
else if (l > mid)
return ask(u * 2 + 1, mid + 1, R, l, r);
else
return (ask(u * 2, L, mid, l, mid) +
ask(u * 2 + 1, mid + 1, R, mid + 1, r)) %
mo;
}
void dfs(int u, int fa, int d) {
l[u] = ++idx;
modify(1, 1, n, idx, idx, d);
for (int k = head[(u)]; k; k = edge[k].nextt) {
int v = edge[k].p;
if (v != fa) dfs(v, u, (d + edge[k].w) % mo);
}
r[u] = idx;
}
void solve(int u, int fa) {
for (int k = head[(u)]; k; k = edge[k].nextt) {
int v = edge[k].p;
if (v == fa) continue;
modify(1, 1, n, 1, n, edge[k].w);
modify(1, 1, n, l[v], r[v], 2LL * (mo - edge[k].w) % mo);
solve(v, u);
modify(1, 1, n, 1, n, mo - edge[k].w);
modify(1, 1, n, l[v], r[v], 2LL * edge[k].w % mo);
}
for (int i = 0; i < q[u].size(); ++i) {
int x = q[u][i].first, y = q[u][i].second;
ans[y] =
(2LL * ask(1, 1, n, l[x], r[x]) % mo - ask(1, 1, n, 1, n) + mo) % mo;
}
}
void build(int u, int L, int R) {
tree[u].s0 = R - L + 1;
if (L == R) return;
int mid = (L + R) >> 1;
build(u * 2, L, mid);
build(u * 2 + 1, mid + 1, R);
}
int main() {
cin >> n;
for (int i = (1); i <= (n - 1); ++i) {
int x, y, z;
read(&x);
read(&y);
read(&z);
ae(x, y, z);
ae(y, x, z);
}
build(1, 1, n);
dfs(1, 0, 0);
cin >> m;
for (int i = (1); i <= (m); ++i) {
int x, y;
read(&x);
read(&y);
q[x].push_back(std::make_pair(y, i));
}
solve(1, 0);
for (int i = (1); i <= (m); ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
struct hashInt {
int x;
hashInt() {}
hashInt(int _x) : x(_x) {}
inline hashInt operator+(const hashInt &y) const {
int z = x + y.x;
if (z >= mod) z -= mod;
if (z < 0) z += mod;
return hashInt(z);
}
inline hashInt operator-(const hashInt &y) const {
int z = x - y.x;
if (z >= mod) z -= mod;
if (z < 0) z += mod;
return hashInt(z);
}
inline hashInt operator*(const hashInt &y) const {
return hashInt((long long)x * y.x % mod);
}
};
struct edge {
int next, node;
hashInt w;
} e[100100 << 1 | 1];
int head[100100 + 1], tot = 0;
inline void addedge(int a, int b, int w) {
e[++tot].next = head[a];
head[a] = tot, e[tot].node = b, e[tot].w = w;
}
struct DP {
hashInt sum, sqr;
DP() {}
DP(int _s, int _q) : sum(_s), sqr(_q) {}
DP(hashInt _s, hashInt _q) : sum(_s), sqr(_q) {}
} up[100100 + 1], down[100100 + 1], downex[100100 + 1];
int n, size[100100 + 1], q;
inline hashInt delta(const DP &x, int n, hashInt b) {
return x.sqr + b * b * n + b * 2 * x.sum;
}
void preUp(int x, int f) {
size[x] = 1, up[x].sum = up[x].sqr = 0;
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
preUp(node, x);
size[x] += size[node];
up[x].sum = up[x].sum + up[node].sum + e[i].w * size[node];
up[x].sqr = up[x].sqr + delta(up[node], size[node], e[i].w);
}
}
void preDown(int x, int f) {
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
DP cur;
cur.sum = down[x].sum + up[x].sum - up[node].sum - e[i].w * size[node];
cur.sqr = down[x].sqr + up[x].sqr - delta(up[node], size[node], e[i].w);
downex[node] = cur;
down[node].sum = cur.sum + e[i].w * (n - size[node]);
down[node].sqr = delta(cur, n - size[node], e[i].w);
preDown(node, x);
}
}
int p[18 + 1][100100 + 1], logn, dep[100100 + 1];
hashInt dis[100100 + 1];
void preDA(int x, int f) {
p[0][x] = f;
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
dep[node] = dep[x] + 1;
dis[node] = dis[x] + e[i].w;
preDA(node, x);
}
}
inline int LCA(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
for (int i = logn; i >= 0; --i)
if (dep[x] <= dep[p[i][y]]) y = p[i][y];
if (x == y) return x;
for (int i = logn; i >= 0; --i)
if (p[i][x] != p[i][y]) x = p[i][x], y = p[i][y];
return p[0][x];
}
int main(int argc, char *argv[]) {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
addedge(x, y, w), addedge(y, x, w);
}
preUp(1, 0);
preDown(1, 0);
dep[1] = 1, preDA(1, 0);
logn = (int)(log((double)n) / log(2.0));
for (int i = 1; i <= logn; ++i)
for (int j = 1; j <= n; ++j) p[i][j] = p[i - 1][p[i - 1][j]];
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int p = LCA(x, y);
hashInt d = dis[x] + dis[y] - dis[p] * 2;
hashInt ans = 0;
if (p == y) {
ans = delta(down[y], n - size[y], d);
ans = up[x].sqr + down[x].sqr - ans * 2;
} else {
ans = delta(up[y], size[y], d);
ans = ans * 2 - up[x].sqr - down[x].sqr;
}
printf("%d\n", ans.x);
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100001;
vector<pair<int, int> > g[nmax], t[nmax];
int n, q, ans[nmax], c, l[nmax], r[nmax], d[nmax], sa[3 * nmax], sb[3 * nmax],
col[nmax * 3];
bool dd[nmax];
int modul = 1000000007;
void build(int s, int ll, int rr) {
if (ll == rr) {
sa[s] = d[ll];
sb[s] = ((long long)(d[ll]) * d[ll]) % modul;
return;
}
build(2 * s, ll, (ll + rr) / 2);
build(2 * s + 1, (ll + rr) / 2 + 1, rr);
sa[s] = (sa[2 * s] + sa[2 * s + 1]) % modul;
sb[s] = (sb[2 * s] + sb[2 * s + 1]) % modul;
}
void dfs(int i) {
l[i] = ++c;
for (int j = 0; j < g[i].size(); j++)
if (l[g[i][j].first] == 0) {
d[c + 1] = (d[l[i]] + g[i][j].second) % modul;
dfs(g[i][j].first);
}
r[i] = c;
}
void progress(int s, int ll, int rr) {
if (ll == rr || col[s] == 0) return;
int p = col[s];
col[2 * s] = (col[2 * s] + p) % modul;
int uu = ((long long)p * (long long)((ll + rr) / 2 - ll + 1)) % modul;
sb[2 * s] =
(sb[2 * s] +
((long long)p * (uu + (2 * sa[2 * s]) % modul) % modul) % modul) %
modul;
sa[2 * s] = (sa[2 * s] + uu) % modul;
col[2 * s + 1] = (col[2 * s + 1] + p) % modul;
uu = ((long long)p * (long long)(rr - (ll + rr) / 2)) % modul;
sb[2 * s + 1] =
(sb[2 * s + 1] +
((long long)p * (uu + (2 * sa[2 * s + 1]) % modul) % modul) % modul) %
modul;
sa[2 * s + 1] = (sa[2 * s + 1] + uu) % modul;
col[s] = 0;
}
void update(int s, int ll, int rr, int u, int v, int p) {
if (rr < u || v < ll) return;
progress(s, ll, rr);
if (u <= ll && rr <= v) {
int uu = ((long long)p * (long long)(rr - ll + 1)) % modul;
sb[s] = (sb[s] +
((long long)p * (long long)(uu + (2 * sa[s]) % modul) % modul) %
modul) %
modul;
sa[s] = (sa[s] + uu) % modul;
if (ll != rr) col[s] = p;
return;
}
update(s * 2, ll, (ll + rr) / 2, u, v, p);
update(s * 2 + 1, (ll + rr) / 2 + 1, rr, u, v, p);
sa[s] = (sa[2 * s] + sa[2 * s + 1]) % modul;
sb[s] = (sb[2 * s] + sb[2 * s + 1]) % modul;
}
int get(int s, int ll, int rr, int u, int v) {
if (rr < u || v < ll) return 0;
progress(s, ll, rr);
if (u <= ll && rr <= v) return sb[s];
return (get(2 * s, ll, (ll + rr) / 2, u, v) +
get(2 * s + 1, (ll + rr) / 2 + 1, rr, u, v)) %
modul;
}
void solve(int i) {
dd[i] = true;
for (int j = 0; j < t[i].size(); j++) {
pair<int, int> u = t[i][j];
ans[u.second] = ((2 * get(1, 1, n, l[u.first], r[u.first])) % modul -
get(1, 1, n, 1, n) + modul) %
modul;
}
for (int j = 0; j < g[i].size(); j++) {
pair<int, int> u = g[i][j];
if (!dd[u.first]) {
update(1, 1, n, 1, n, u.second);
update(1, 1, n, l[u.first], r[u.first],
(modul - (2 * u.second) % modul) % modul);
solve(u.first);
update(1, 1, n, 1, n, (modul - u.second) % modul);
update(1, 1, n, l[u.first], r[u.first], (2 * u.second) % modul);
}
}
}
int main() {
scanf("%d", &n);
int x, y, z;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
g[x].push_back(pair<int, int>(y, z));
g[y].push_back(pair<int, int>(x, z));
}
scanf("%d", &q);
dfs(1);
build(1, 1, n);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
t[x].push_back(pair<int, int>(y, i));
}
solve(1);
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100001;
vector<pair<int, int> > g[nmax], t[nmax];
int n, q, ans[nmax], c, l[nmax], r[nmax], d[nmax], sa[10 * nmax], sb[10 * nmax],
col[nmax * 10];
bool dd[nmax];
int modul = 1000000007;
void build(int s, int ll, int rr) {
if (ll == rr) {
sa[s] = d[ll];
sb[s] = ((long long)(d[ll]) * d[ll]) % modul;
return;
}
build(2 * s, ll, (ll + rr) / 2);
build(2 * s + 1, (ll + rr) / 2 + 1, rr);
sa[s] = (sa[2 * s] + sa[2 * s + 1]) % modul;
sb[s] = (sb[2 * s] + sb[2 * s + 1]) % modul;
}
void dfs(int i) {
l[i] = ++c;
for (int j = 0; j < g[i].size(); j++)
if (l[g[i][j].first] == 0) {
d[c + 1] = (d[l[i]] + g[i][j].second) % modul;
dfs(g[i][j].first);
}
r[i] = c;
}
void progress(int s, int ll, int rr) {
if (col[s] == 0) return;
int p = col[s];
col[2 * s] = (col[2 * s] + p) % modul;
int uu = ((long long)p * (long long)((ll + rr) / 2 - ll + 1)) % modul;
sb[2 * s] =
(sb[2 * s] +
((long long)p * (uu + (2 * sa[2 * s]) % modul) % modul) % modul) %
modul;
sa[2 * s] = (sa[2 * s] + uu) % modul;
col[2 * s + 1] = (col[2 * s + 1] + p) % modul;
uu = ((long long)p * (long long)(rr - (ll + rr) / 2)) % modul;
sb[2 * s + 1] =
(sb[2 * s + 1] +
((long long)p * (uu + (2 * sa[2 * s + 1]) % modul) % modul) % modul) %
modul;
sa[2 * s + 1] = (sa[2 * s + 1] + uu) % modul;
col[s] = 0;
}
void update(int s, int ll, int rr, int u, int v, int p) {
if (rr < u || v < ll) return;
progress(s, ll, rr);
if (u <= ll && rr <= v) {
int uu = ((long long)p * (long long)(rr - ll + 1)) % modul;
sb[s] = (sb[s] +
((long long)p * (long long)(uu + (2 * sa[s]) % modul) % modul) %
modul) %
modul;
sa[s] = (sa[s] + uu) % modul;
if (ll != rr) col[s] = p;
return;
}
update(s * 2, ll, (ll + rr) / 2, u, v, p);
update(s * 2 + 1, (ll + rr) / 2 + 1, rr, u, v, p);
sa[s] = (sa[2 * s] + sa[2 * s + 1]) % modul;
sb[s] = (sb[2 * s] + sb[2 * s + 1]) % modul;
}
int get(int s, int ll, int rr, int u, int v) {
if (rr < u || v < ll) return 0;
progress(s, ll, rr);
if (u <= ll && rr <= v) return sb[s];
return (get(2 * s, ll, (ll + rr) / 2, u, v) +
get(2 * s + 1, (ll + rr) / 2 + 1, rr, u, v)) %
modul;
}
void solve(int i) {
dd[i] = true;
for (int j = 0; j < t[i].size(); j++) {
pair<int, int> u = t[i][j];
ans[u.second] = ((2 * get(1, 1, n, l[u.first], r[u.first])) % modul -
get(1, 1, n, 1, n) + modul) %
modul;
}
for (int j = 0; j < g[i].size(); j++) {
pair<int, int> u = g[i][j];
if (!dd[u.first]) {
update(1, 1, n, 1, n, u.second);
update(1, 1, n, l[u.first], r[u.first],
(modul - (2 * u.second) % modul) % modul);
solve(u.first);
update(1, 1, n, 1, n, (modul - u.second) % modul);
update(1, 1, n, l[u.first], r[u.first], (2 * u.second) % modul);
}
}
}
int main() {
scanf("%d", &n);
int x, y, z;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
g[x].push_back(pair<int, int>(y, z));
g[y].push_back(pair<int, int>(x, z));
}
scanf("%d", &q);
dfs(1);
build(1, 1, n);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
t[x].push_back(pair<int, int>(y, i));
}
solve(1);
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int M = 5007;
const int inf = 1e9 + 7;
const long long base = 1e18;
const double pi = acos(-1);
const double ep = 1e-9;
int n;
vector<pair<int, int> > adj[N];
long long pa[N][20], f[N], f2[N];
long long L[N], L2[N], child[N];
long long length[N], depth[N];
void DFS(int u) {
child[u] = 1;
for (int j = 0; j < adj[u].size(); j++) {
int v = adj[u][j].first;
long long c = adj[u][j].second;
if (pa[v][0] == 0) {
pa[v][0] = u;
length[v] = ((long long)length[u] + c) % inf;
depth[v] = depth[u] + 1;
for (int i = 1; i < log(depth[v]) / log(2) + 1; i++)
pa[v][i] = pa[pa[v][i - 1]][i - 1];
DFS(v);
child[u] += child[v];
long long c2 = (long long)c * c % inf;
f2[u] = ((long long)f2[u] + f2[v] + ((long long)2 * f[v] * c) % inf +
(child[v] * c2) % inf) %
inf;
f[u] = ((long long)f[u] + f[v] + ((long long)child[v] * c) % inf) % inf;
}
}
}
int LCA(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
while (depth[v] > depth[u]) {
int k = log(depth[v] - depth[u]) / log(2);
v = pa[v][k];
}
if (u == v) return u;
while (pa[u][0] != pa[v][0] && pa[u][0] > 0) {
int lo = 0, hi = log(depth[u]) / log(2), g, res = -1;
do {
g = (lo + hi) >> 1;
if (pa[u][g] != pa[v][g]) {
res = g;
lo = g + 1;
} else
hi = g - 1;
} while (lo <= hi);
if (res == -1) break;
u = pa[u][res];
v = pa[v][res];
}
return pa[u][0];
}
int dist(int u, int v) {
int t = LCA(u, v);
return ((long long)length[u] - length[t] + length[v] - length[t]) % inf;
}
void duyet(int u) {
for (int j = 0; j < adj[u].size(); j++) {
int v = adj[u][j].first;
long long c = adj[u][j].second;
if (pa[v][0] == u) {
long long c2 = (long long)c * c % inf;
L[v] = (L[u] - (f[v] + c * child[v]) % inf) % inf;
long long tmp =
(L2[u] -
(f2[v] + ((long long)2 * f[v] * c) % inf + child[v] * c2) % inf) %
inf;
L2[v] = (tmp + ((long long)2 * L[v] * c) % inf + (n - child[v]) * c2);
L[v] = (L[v] + ((long long)n - child[v]) * c + f[v]) % inf;
L2[v] = (L2[v] + f2[v]) % inf;
duyet(v);
}
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
adj[u].push_back(make_pair(v, c));
adj[v].push_back(make_pair(u, c));
}
pa[1][0] = -1;
DFS(1);
L[1] = f[1];
L2[1] = f2[1];
duyet(1);
int test;
cin >> test;
while (test-- > 0) {
int u, v;
scanf("%d%d", &u, &v);
long long res = 0;
long long c = dist(u, v);
long long c2 = (long long)c * c % inf;
if (LCA(u, v) == v) {
long long tmp =
(L2[v] - f2[v] + ((long long)2 * c * (L[v] - f[v])) % inf +
((long long)n - child[v]) * c2 % inf) %
inf;
res = ((long long)L2[u] - tmp - tmp) % inf;
} else {
long long tmp =
(f2[v] + ((long long)2 * c * f[v]) % inf + (long long)child[v] * c2) %
inf;
res = (tmp - (L2[u] - tmp)) % inf;
}
res = (res + inf) % inf;
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 8e18;
const int LOG = 17;
long long par[LOG][N], sub[N], sumsub[N], sumout[N], H[N], dp_down[N], dp_up[N],
St[N], Fi[N], ptr, n;
long long dis[N];
vector<pair<long long, long long> > G[N];
inline long long zarb(long long a, long long b) { return (a * b) % mod; }
inline long long jam(long long a, long long b) {
long long tot = a + b;
return tot % mod;
}
inline long long taf(long long a, long long b) {
long long ans = (a - b + 10 * mod) % mod;
return ans;
}
inline long long P2(long long x) { return x * x % mod; }
void dfs_down(int v, int P) {
St[v] = ++ptr;
sub[v] = 1;
H[v] = H[P] + 1;
par[0][v] = P;
for (int T = 1; T < LOG; T++) {
par[T][v] = par[T - 1][par[T - 1][v]];
}
for (auto y : G[v]) {
long long u = y.first, cost = y.second, x = P2(cost);
if (u == P) continue;
dis[u] = dis[v] + cost;
dfs_down(u, v);
sub[v] += sub[u];
dp_down[v] = jam(dp_down[v], dp_down[u]);
dp_down[v] = jam(dp_down[v], zarb(x, sub[u]));
dp_down[v] = jam(dp_down[v], zarb(2 * cost, sumsub[u]));
sumsub[v] = jam(sumsub[v], jam(sumsub[u], zarb(sub[u], cost)));
}
Fi[v] = ptr;
}
void dfs_up(int v, int P = 0) {
for (auto y : G[v]) {
long long u = y.first, cost = y.second, x = P2(cost);
if (u == P) continue;
long long cu = jam(dp_up[v], dp_down[v]);
cu = taf(cu, dp_down[u]);
cu = taf(cu, zarb(x, sub[u]));
cu = taf(cu, zarb(2 * cost, sumsub[u]));
long long M = jam(sumsub[u], zarb(sub[u], cost));
sumout[u] = taf(jam(sumsub[v], sumout[v]), M);
sumout[u] = jam(sumout[u], zarb(cost, n - sub[u]));
cu = jam(cu, zarb(n - sub[u], x));
cu = jam(cu, zarb(2 * cost, taf(sumout[u], zarb(n - sub[u], cost))));
dp_up[u] = cu;
dfs_up(u, v);
}
}
long long LCA(long long v, long long u) {
if (H[v] > H[u]) {
swap(u, v);
}
long long del = H[u] - H[v];
for (int T = 0; T < LOG; T++) {
if (del & (1 << T)) {
u = par[T][u];
}
}
if (v == u) return v;
for (int T = LOG - 1; ~T; T--) {
if (par[T][v] != par[T][u]) {
u = par[T][u];
v = par[T][v];
}
}
return par[0][v];
}
inline long long dist(int v, int u) {
return dis[v] + dis[u] - 2 * dis[LCA(u, v)];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i < n; i++) {
long long a, b, c;
cin >> a >> b >> c;
G[a].push_back(make_pair(b, c));
G[b].push_back(make_pair(a, c));
}
sub[0] = n;
dfs_down(1, 0);
dfs_up(1, 0);
int q;
cin >> q;
while (q--) {
int v, u;
cin >> u >> v;
if (St[v] <= St[u] && Fi[v] >= Fi[u]) {
long long kol = dp_down[u] + dp_up[u];
long long cu = dp_down[u] + dp_up[u];
long long masir = (dis[u] - dis[v]) % mod;
long long kam = (dp_up[v] + zarb(P2(masir), (n - sub[v])) +
zarb(zarb(2, masir), sumout[v])) %
mod;
cu = (cu - kam + mod) % mod;
cout << (2 * cu - kol + 3 * mod) % mod << "\n";
} else {
long long kol = (dp_down[u] + dp_up[u]) % mod;
long long masir = dist(u, v) % mod;
long long cu =
(dp_down[v] + zarb(P2(masir), sub[v]) + 2 * zarb(masir, sumsub[v])) %
mod;
cout << (2 * cu - kol + 3 * mod) % mod << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
const int N = 100007;
const int LOG = 20;
long long in[N], out[N], sIn[N], sOut[N], dep[N];
int n, timer, size[N], tin[N], tout[N], par[N], up[LOG][N];
vector<pair<int, int> > G[N];
long long calc(long long w, long long in, long long sum, int cnt) {
return (in + cnt * w % MOD * w + 2 * sum % MOD * w) % MOD;
}
void dfs(int u, int p = 1, long long d = 0) {
tin[u] = timer++;
size[u] = 1;
dep[u] = d;
par[u] = p;
up[0][u] = p;
for (int i = 0; i < LOG - 1; ++i) {
up[i + 1][u] = up[i][up[i][u]];
}
for (auto pp : G[u]) {
int to = pp.first;
long long w = pp.second;
if (to != p) {
dfs(to, u, (d + w) % MOD);
size[u] += size[to];
sIn[u] = (sIn[u] + sIn[to] + w * size[to]) % MOD;
in[u] += calc(w, in[to], sIn[to], size[to] - 1) + w * w;
in[u] %= MOD;
}
}
tout[u] = timer++;
}
void dfsOut(int u, long long pw) {
int p = par[u];
if (u != 1) {
long long sibIn = in[p] - calc(pw, in[u], sIn[u], size[u] - 1) - pw * pw;
long long sibSum = sIn[p] - sIn[u] - pw * size[u];
int sibCnt = size[p] - 1 - size[u];
out[u] = calc(pw, out[p], sOut[p], n - size[p]);
out[u] += calc(pw, sibIn, sibSum, sibCnt);
out[u] += pw * pw;
out[u] %= MOD;
sOut[u] = (sOut[p] + sibSum + sibCnt * pw + (n - size[p] + 1) * pw) % MOD;
if (sOut[u] < 0) sOut[u] += MOD;
}
for (auto pp : G[u]) {
int to = pp.first;
long long w = pp.second;
if (to != p) dfsOut(to, w);
}
}
inline bool parent(int parent, int child) {
return (tin[parent] <= tin[child] && tout[child] <= tout[parent]);
}
int lca(int u, int v) {
if (parent(u, v)) return u;
if (parent(v, u)) return v;
for (int k = 19; k >= 0; --k) {
int w = up[k][u];
if (!parent(w, v)) u = w;
}
return par[u];
}
long long getDist(int u, int v) {
int w = lca(u, v);
return (dep[u] + dep[v] - 2 * dep[w] + 2 * MOD) % MOD;
}
void solve() {
scanf("%d", &n);
for (int i = 0; i < (n - 1); ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
}
dfs(1);
dfsOut(1, 0);
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
long long ans;
long long d = getDist(u, v);
if (!parent(v, u)) {
cerr << "1 ";
ans =
-in[u] - out[u] + 2 * calc(d, in[v], sIn[v], size[v] - 1) + 2 * d * d;
} else {
cerr << "2 ";
ans = in[u] + out[u] - 2 * calc(d, out[v], sOut[v], n - size[v]);
}
ans %= MOD;
if (ans < 0) ans += MOD;
printf("%lld\n", ans);
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int sum(int a, int b) {
add(a, b);
return a;
}
int mult(int a, int b) { return (1ll * a * b) % mod; }
int n, up[20][N], timer, tin[N], tout[N], q, sz[N], len[N], cost[N];
vector<pair<int, int> > g[N];
pair<int, int> dp[N], d[N], shit[N];
bool P(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
void dfs(int v = 1, int p = 1) {
tin[v] = ++timer;
up[0][v] = p;
for (int i = 1; i < 20; i++) up[i][v] = up[i - 1][up[i - 1][v]];
sz[v] = 1;
for (auto to : g[v]) {
if (to.first != p) {
len[to.first] = sum(len[v], to.second);
cost[to.first] = to.second;
dfs(to.first, v);
sz[v] += sz[to.first];
add(d[v].first, sum(d[to.first].first, mult(to.second, sz[to.first])));
int now = sum(d[to.first].second,
mult(sz[to.first], mult(to.second, to.second)));
add(now, mult(2, mult(to.second, d[to.first].first)));
add(d[v].second, now);
}
}
tout[v] = ++timer;
}
void go(int v = 1, int p = 1, pair<int, int> up = make_pair(0, 0)) {
shit[v] = up;
dp[v] = make_pair(sum(d[v].first, up.first), sum(d[v].second, up.second));
for (auto to : g[v]) {
if (to.first != p) {
pair<int, int> now = dp[v];
add(now.first,
mod - sum(d[to.first].first, mult(sz[to.first], to.second)));
int temp = sum(d[to.first].second,
mult(sz[to.first], mult(to.second, to.second)));
add(temp, mult(2, mult(to.second, d[to.first].first)));
add(now.second, mod - temp);
temp = sum(mult(2, mult(to.second, now.first)),
mult(n - sz[to.first], mult(to.second, to.second)));
add(now.second, temp);
add(now.first, mult(to.second, n - sz[to.first]));
go(to.first, v, now);
}
}
}
int lca(int a, int b) {
if (P(a, b)) return a;
if (P(b, a)) return b;
for (int i = 19; i >= 0; i--) {
int x = up[i][a];
if (!P(x, b)) a = x;
}
return up[0][a];
}
int dist(int a, int b) {
int c = lca(a, b);
int ans = sum(len[a], len[b]);
add(ans, mod - mult(2, len[c]));
return ans;
}
int get(int a, int b) {
for (int i = 19; i >= 0; i--) {
int x = up[i][a];
if (!P(x, b)) a = x;
}
return a;
}
int main() {
ios_base::sync_with_stdio(0);
clock_t start = clock();
cin >> n;
for (int i = 1, u, v, c; i < n; i++) {
cin >> u >> v >> c;
g[u].push_back(make_pair(v, c));
g[v].push_back(make_pair(u, c));
}
dfs();
go();
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
int di = dist(a, b);
int ans = 0;
if (!P(b, a) || a == b) {
ans = sum(d[b].second, mult(sz[b], mult(di, di)));
add(ans, mult(2, mult(di, d[b].first)));
ans = sum(ans, ans);
add(ans, mod - dp[a].second);
} else {
ans = dp[a].second;
int now = sum(shit[b].second, mult(n - sz[b], mult(di, di)));
add(now, mult(2, mult(di, shit[b].first)));
add(ans, mod - now);
ans = sum(ans, ans);
add(ans, mod - dp[a].second);
}
cout << ans << endl;
}
double duration = ((double)clock() - start) / (double)CLOCKS_PER_SEC;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct node {
long long lazy;
long long sum, sumsq;
} node;
vector<pair<int, long long> > G[100100];
vector<int> queries[100100];
map<pair<int, long long>, long long> M;
int uq[100100];
int vq[100100];
int lft[100100];
int rgt[100100];
node S[4 * 100100];
int idx, n;
node ZERO;
void push(int x, int l, int r) {
long long v = S[x].lazy;
int mid = (l + r) / 2;
long long siz1 = mid - l + 1, siz2 = r - (mid + 1) + 1;
S[x * 2].lazy = (S[x * 2].lazy + v) % 1000000007;
S[x * 2].sumsq = (S[x * 2].sumsq + 2 * ((v * S[x * 2].sum) % 1000000007) +
(siz1 * ((v * v) % 1000000007)) % 1000000007) %
1000000007;
S[x * 2].sum = (S[x * 2].sum + (siz1 * v) % 1000000007) % 1000000007;
S[x * 2 + 1].lazy = (S[x * 2 + 1].lazy + v) % 1000000007;
S[x * 2 + 1].sumsq =
(S[x * 2 + 1].sumsq + 2 * ((v * S[x * 2 + 1].sum) % 1000000007) +
(siz2 * ((v * v) % 1000000007)) % 1000000007) %
1000000007;
S[x * 2 + 1].sum = (S[x * 2 + 1].sum + (siz2 * v) % 1000000007) % 1000000007;
S[x].lazy = 0;
}
void update(int x, int l, int r, int i, int j, long long v) {
if ((j < l) or (r < i)) return;
if ((i <= l) and (r <= j)) {
S[x].lazy = (S[x].lazy + v) % 1000000007;
long long siz = r - l + 1;
S[x].sumsq = (S[x].sumsq + 2 * ((v * S[x].sum) % 1000000007) +
(siz * ((v * v) % 1000000007)) % 1000000007) %
1000000007;
S[x].sum = (S[x].sum + (siz * v) % 1000000007) % 1000000007;
return;
}
push(x, l, r);
int mid = (l + r) / 2;
update(x * 2, l, mid, i, j, v);
update(x * 2 + 1, mid + 1, r, i, j, v);
node Q1 = S[x * 2];
node Q2 = S[x * 2 + 1];
S[x].sum = (Q2.sum + Q1.sum) % 1000000007;
S[x].sumsq = (Q2.sumsq + Q1.sumsq) % 1000000007;
}
node query(int x, int l, int r, int i, int j) {
if ((j < l) or (r < i)) return ZERO;
if ((i <= l) and (r <= j)) return S[x];
push(x, l, r);
int mid = (l + r) / 2;
node Q1 = query(x * 2, l, mid, i, j);
node Q2 = query(x * 2 + 1, mid + 1, r, i, j);
Q2.sum = (Q2.sum + Q1.sum) % 1000000007;
Q2.sumsq = (Q2.sumsq + Q1.sumsq) % 1000000007;
return Q2;
}
void dfs0(int x, int pi, long long dist) {
idx++;
lft[x] = idx, rgt[x] = idx;
update(1, 1, n, idx, idx, dist);
for (int j = (0); j < (G[x].size()); j++) {
int y = G[x][j].first;
long long w = G[x][j].second;
if (y == pi) continue;
dfs0(y, x, (dist + w) % 1000000007);
lft[x] = (((lft[x]) < (lft[y])) ? (lft[x]) : (lft[y]));
rgt[x] = (((rgt[x]) > (rgt[y])) ? (rgt[x]) : (rgt[y]));
}
}
void dfs1(int x, int pi) {
node Q = query(1, 1, n, 1, n);
for (int j = (0); j < (queries[x].size()); j++) {
int y = queries[x][j];
long long T = S[1].sumsq;
node Q = query(1, 1, n, lft[y], rgt[y]);
long long ans = (2 * Q.sumsq - T + 1000000007) % 1000000007;
M[make_pair(x, y)] = ans;
}
for (int j = (0); j < (G[x].size()); j++) {
int y = G[x][j].first;
long long w = G[x][j].second;
if (y == pi) continue;
update(1, 1, n, 1, n, w);
update(1, 1, n, lft[y], rgt[y], (2 * 1000000007 - 2 * w) % 1000000007);
dfs1(y, x);
update(1, 1, n, lft[y], rgt[y], (2 * w) % 1000000007);
update(1, 1, n, 1, n, 1000000007 - w);
}
}
int main() {
ZERO.sum = 0;
ZERO.sumsq = 0;
int x, y, u, v;
idx = 0;
scanf("%d", &n);
long long w;
for (int j = (1); j <= (n - 1); j++) {
scanf("%d %d %I64d", &x, &y, &w);
G[x].push_back(make_pair(y, w));
G[y].push_back(make_pair(x, w));
}
for (int j = (0); j < (4 * 100100); j++) {
S[j].sum = 0;
S[j].sumsq = 0;
}
dfs0(1, -1, 0);
int q;
cin >> q;
for (int j = (1); j <= (q); j++) {
scanf("%d %d", &uq[j], &vq[j]);
queries[uq[j]].push_back(vq[j]);
}
dfs1(1, -1);
for (int j = (1); j <= (q); j++) {
printf("%I64d\n", M[make_pair(uq[j], vq[j])]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
vector<pair<int, int>> mp[100005];
int d[100005], p[100005][20];
void init() {
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i <= n; i++) p[i][j] = p[p[i][j - 1]][j - 1];
}
int lca(int a, int b) {
if (d[a] > d[b]) swap(a, b);
int f = d[b] - d[a];
for (int i = 0; (1 << i) <= f; i++)
if ((1 << i) & f) b = p[b][i];
if (a != b) {
for (int i = (int)log2(n); i >= 0; i--)
if (p[a][i] != p[b][i]) {
a = p[a][i];
b = p[b][i];
}
a = p[a][0];
}
return a;
}
long long dsum[100005], tsum[100005], dsum2[100005], tsum2[100005], dis[100005];
int sz[100005];
void dfs(int x, int pa) {
d[x] = d[pa] + 1;
sz[x] = 1;
p[x][0] = pa;
for (auto p : mp[x])
if (p.first != pa) {
int v = p.first, w = p.second;
dis[v] = dis[x] + w;
dfs(v, x);
sz[x] += sz[v];
dsum[x] += (dsum[v] + (long long)sz[v] * w % 1000000007) % 1000000007;
dsum[x] %= 1000000007;
dsum2[x] += dsum2[v] +
(long long)w * w % 1000000007 * sz[v] % 1000000007 +
2LL * w % 1000000007 * dsum[v] % 1000000007;
dsum2[x] %= 1000000007;
}
}
void dfs2(int x, int pa, long long s, long long s2) {
for (auto p : mp[x])
if (p.first != pa) {
int v = p.first;
long long w = p.second;
long long dsumv =
(dsum[v] + (long long)sz[v] * w % 1000000007) % 1000000007;
long long other = (dsum[x] - dsumv + 1000000007) % 1000000007 + s;
other %= 1000000007;
tsum[v] = other + w * (n - sz[v]) % 1000000007;
tsum[v] %= 1000000007;
long long dsum2v = dsum2[v] +
(long long)w * w % 1000000007 * sz[v] % 1000000007 +
2LL * w % 1000000007 * dsum[v] % 1000000007;
long long tmp = (dsum2[x] - dsum2v + 1000000007) % 1000000007 + s2;
tsum2[v] = tmp + w * w % 1000000007 * (n - sz[v]) % 1000000007 +
2LL * w % 1000000007 * other % 1000000007;
dfs2(v, x, tsum[v], tsum2[v]);
}
}
int main() {
scanf("%d", &n);
for (int i = 0, u, v, w; i < n - 1; i++) {
scanf("%d%d%d", &u, &v, &w);
mp[u].push_back({v, w});
mp[v].push_back({u, w});
}
dfs(1, 0);
init();
dfs2(1, 0, 0, 0);
int q;
scanf("%d", &q);
for (int i = 0, u, v; i < q; i++) {
scanf("%d%d", &u, &v);
int fa = lca(u, v);
long long ans = 0;
if (fa == v) {
long long w = dis[u] - dis[v];
w %= 1000000007;
long long z =
tsum2[v] +
(long long)w * w % 1000000007 * (n - sz[v] + 1) % 1000000007 +
2LL * w % 1000000007 * tsum[v] % 1000000007;
z %= 1000000007;
z += 1000000007 - w * w % 1000000007;
z %= 1000000007;
ans = (dsum2[u] + tsum2[u] - z) - z;
} else {
long long w = dis[v] + dis[u] - 2 * dis[fa];
w %= 1000000007;
long long z = dsum2[v] +
(long long)w * w % 1000000007 * sz[v] % 1000000007 +
2LL * w % 1000000007 * dsum[v] % 1000000007;
z %= 1000000007;
ans = z - (dsum2[u] + tsum2[u] - z);
}
ans = ans % 1000000007 + 1000000007;
ans %= 1000000007;
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
struct P {
int to;
long long dis;
};
vector<P> v[maxn];
unordered_map<int, int> mp[maxn];
vector<long long> psum[maxn], sqsum[maxn];
vector<int> sz[maxn];
long long sqval[maxn];
int anc[17][maxn], dep[maxn];
int tin[maxn], tout[maxn], tick;
void dfs0(int x, int f, int d) {
tin[x] = tick++;
dep[x] = d;
anc[0][x] = f;
for (int i = 1; i < 17; i++) anc[i][x] = anc[i - 1][anc[i - 1][x]];
for (auto i : v[x])
if (f != i.to) dfs0(i.to, x, (i.dis + d) % 1000000007);
tout[x] = tick++;
}
inline bool isfa(int x, int y) {
return tin[x] <= tin[y] && tout[x] >= tout[y];
}
int LCA(int x, int y) {
if (isfa(x, y)) return x;
if (isfa(y, x)) return y;
for (int i = 16; i >= 0; i--)
if (!isfa(anc[i][x], y)) x = anc[i][x];
return anc[0][x];
}
int getlen(int x, int y) {
int lca = LCA(x, y), ret = (dep[x] + dep[y] - 2 * dep[lca]) % 1000000007;
if (ret < 0) ret += 1000000007;
return ret;
}
inline long long cal_add_s(const P &i, int id) {
return sqsum[i.to][id] + (i.dis * i.dis % 1000000007) * sz[i.to][id] +
2 * i.dis * psum[i.to][id];
}
inline long long cal_add_p(const P &i, int id) {
return psum[i.to][id] + sz[i.to][id] * i.dis;
}
int n, cnt[maxn];
void dfs(int x, int id) {
if (psum[x][id] != -1) return;
sz[x][id] = 1;
long long &ans1 = psum[x][id];
long long &ans2 = sqsum[x][id];
ans1 = 0;
if (v[x].size() == 1) return;
for (auto i : v[x])
if (i.to != v[x][id].to) {
int id2 = mp[i.to][x];
dfs(i.to, id2);
ans1 = (ans1 + cal_add_p(i, id2)) % 1000000007;
ans2 = (ans2 + cal_add_s(i, id2)) % 1000000007;
sz[x][id] += sz[i.to][id2];
}
if (++cnt[x] == 2) {
int id2 = mp[v[x][id].to][x];
long long tot1 = ans1 + cal_add_p(v[x][id], id2);
tot1 %= 1000000007;
long long tot2 = ans2 + cal_add_s(v[x][id], id2);
tot2 %= 1000000007;
int totsz = sz[x][id] + sz[v[x][id].to][id2];
for (int i = 0; i < v[x].size(); i++)
if (psum[x][i] == -1) {
int id3 = mp[v[x][i].to][x];
assert(psum[v[x][i].to][id3] != -1);
psum[x][i] = tot1 - cal_add_p(v[x][i], id3) % 1000000007;
if (psum[x][i] < 0) psum[x][i] += 1000000007;
sqsum[x][i] = tot2 - cal_add_s(v[x][i], id3) % 1000000007;
if (sqsum[x][i] < 0) sqsum[x][i] += 1000000007;
sz[x][i] = totsz - sz[v[x][i].to][id3];
}
}
}
long long getval(int x) {
long long ret = 0;
for (auto i : v[x]) {
int id = mp[i.to][x];
dfs(i.to, id);
ret = (ret + cal_add_s(i, id)) % 1000000007;
}
return ret;
}
long long query(int u, int v) {
long long ret = 0LL;
if (!isfa(v, u)) {
ret = -sqval[u] + 1000000007;
int id = mp[v][anc[0][v]];
long long dis = getlen(u, v), add = (dis * dis % 1000000007) * sz[v][id];
add += sqsum[v][id];
add += 2 * dis * psum[v][id];
add %= 1000000007;
return (ret + 2 * add) % 1000000007;
} else if (v == 1)
return sqval[u];
else {
ret = sqval[u];
int v2 = anc[0][v], id = mp[v2][v];
long long dis = dep[u] - dep[v2];
if (dis < 0) dis += 1000000007;
long long sub = (dis * dis % 1000000007) * sz[v2][id];
sub += sqsum[v2][id];
sub += 2 * dis * psum[v2][id];
sub %= 1000000007;
return ((ret - 2 * sub) % 1000000007 + 1000000007) % 1000000007;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
long long dis;
scanf("%d%d%I64d", &x, &y, &dis);
v[x].push_back((P){y, dis});
v[y].push_back((P){x, dis});
}
for (int i = 1; i <= n; i++) {
psum[i].resize(v[i].size());
sqsum[i].resize(v[i].size());
sz[i].resize(v[i].size());
for (int j = 0; j < v[i].size(); j++)
mp[i][v[i][j].to] = j, psum[i][j] = -1;
}
dfs0(1, 1, 0);
for (int i = 1; i <= n; i++) sqval[i] = getval(i);
int Q;
scanf("%d", &Q);
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%I64d\n", query(x, y));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = int(1e9 + 7);
struct edge {
int s, t, d, n;
} e[200010];
int n, q, h[100010], f[100010][6], g[100010][20], gg[100010][20], dp[100010];
int sqr_mod(int x) { return 1LL * x * x % mo; }
void dfs(int x, int fa) {
f[x][3] = 1;
for (int i = h[x], y, d; y = e[i].t, d = e[i].d, i; i = e[i].n)
if (y != fa) {
dfs(y, x);
f[x][1] =
(f[x][1] + f[y][1] + 2LL * f[y][2] * d + 1LL * sqr_mod(d) * f[y][3]) %
mo;
f[x][2] = (f[x][2] + f[y][2] + 1LL * d * f[y][3]) % mo;
f[x][3] += f[y][3];
}
}
void dfs(int x, int fa, int d) {
if (fa) {
f[x][4] = ((1LL * (n - 4 * f[x][3]) * sqr_mod(d) +
(2LL * f[fa][5] + 2LL * f[fa][2] - 4LL * f[x][2]) * d +
f[fa][4] + f[fa][1] - f[x][1]) %
mo +
mo) %
mo;
f[x][5] =
((1LL * (n - 2 * f[x][3]) * d + f[fa][5] + f[fa][2] - f[x][2]) % mo +
mo) %
mo;
}
g[x][0] = fa, gg[x][0] = d, dp[x] = dp[fa] + 1;
for (int i = h[x]; i; i = e[i].n)
if (e[i].t != fa) dfs(e[i].t, x, e[i].d);
}
void LCA(int x, int y, int &t, int &d) {
if (dp[x] > dp[y]) swap(x, y);
for (int i = 19; i >= 0; i--)
if (dp[x] <= dp[g[y][i]]) d = (d + gg[y][i]) % mo, y = g[y][i];
if (x == y) return void(t = x);
for (int i = 19; i >= 0; i--)
if (g[x][i] != g[y][i])
d = ((d + gg[x][i]) % mo + gg[y][i]) % mo, x = g[x][i], y = g[y][i];
d = ((d + gg[x][0]) % mo + gg[y][0]) % mo, t = g[x][0];
}
void work() {
scanf("%d", &n);
for (int i = 1, s, t, d, tot = 0; i < n; i++) {
scanf("%d %d %d", &s, &t, &d);
e[++tot] = (edge){s, t, d, h[s]}, h[s] = tot;
e[++tot] = (edge){t, s, d, h[t]}, h[t] = tot;
}
dfs(1, 0), dfs(1, 0, 0);
for (int i = 1; i <= n; i++) f[i][0] = (f[i][1] + f[i][4]) % mo;
for (int j = 1; j < 20; j++)
for (int i = 1; i <= n; i++)
g[i][j] = g[g[i][j - 1]][j - 1],
gg[i][j] = (gg[i][j - 1] + gg[g[i][j - 1]][j - 1]) % mo;
scanf("%d", &q);
for (int i = 1, x, y, t, d, ans; i <= q; i++) {
scanf("%d %d", &x, &y), d = 0;
LCA(x, y, t, d);
if (t == y)
ans = (((f[x][1] + f[x][4] - f[y][4] - 2LL * d * f[y][5] -
1LL * (n - f[y][3]) * sqr_mod(d)) %
mo * 2LL -
f[x][0]) %
mo +
mo) %
mo;
else
ans = (((f[y][1] + 2LL * d * f[y][2] + 1LL * f[y][3] * sqr_mod(d)) % mo *
2LL -
f[x][0]) %
mo +
mo) %
mo;
printf("%d\n", ans);
}
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int MODP(long long x) {
int r = x % 1000000007;
if (r < 0) r += 1000000007;
return r;
}
void testGen() {
freopen("biginput1.txt", "w", stdout);
fclose(stdout);
}
int n;
struct weighted_tree {
vector<vector<pair<int, int> > > adj;
vector<pair<int, int> > pi;
vector<int> depth;
int n;
int root;
void reset(int n) {
this->n = n;
adj.resize(n + 1);
for (auto i = 1; i <= n; ++i) adj[i].clear();
pi.resize(n + 1);
depth.resize(n + 1);
for (auto i = 1; i <= n; ++i) {
pi[i] = make_pair(-1, -1);
depth[i] = 0;
}
}
weighted_tree() {}
weighted_tree(int n) { reset(n); }
void dfs(int u) {
for (auto &e : adj[u]) {
int v = e.first;
int c = e.second;
if (pi[v].first == -1) {
pi[v] = make_pair(u, c);
depth[v] = depth[u] + 1;
dfs(v);
}
}
}
void set_root(int u) {
root = u;
pi[root].first = -2;
dfs(root);
}
void add_edge(int u, int v, int c) {
adj[u].push_back(make_pair(v, c));
adj[v].push_back(make_pair(u, c));
}
};
struct lca {
vector<vector<pair<int, int> > > anc;
weighted_tree &t;
lca(weighted_tree &tree) : t(tree) {
anc.resize(t.n + 1);
for (auto i = 1; i <= t.n; ++i) {
if (i != t.root) {
anc[i].push_back(t.pi[i]);
}
}
for (int k = 1;; ++k) {
bool ok = false;
for (auto i = 1; i <= t.n; ++i) {
if (anc[i].size() >= k) {
int j = anc[i][k - 1].first;
if (anc[j].size() >= k) {
int x = anc[j][k - 1].first;
int c = min(anc[i][k - 1].second, anc[j][k - 1].second);
anc[i].push_back(make_pair(x, c));
ok = true;
}
}
}
if (!ok) break;
}
}
pair<int, int> get_lca(int u, int v) {
if (t.depth[u] > t.depth[v]) {
swap(u, v);
}
if (t.depth[v] > t.depth[u]) {
for (auto i = anc[v].size() - 1; i >= 0; --i) {
int w = anc[v][i].first;
if (t.depth[w] >= t.depth[u]) {
pair<int, int> p = get_lca(u, w);
p.second = min(anc[v][i].second, p.second);
return p;
}
}
} else {
if (u == v) {
return make_pair(u, 2E9L);
}
for (auto i = anc[u].size() - 1; i >= 0; --i) {
int x = anc[u][i].first;
int y = anc[v][i].first;
if (x != y || i == 0) {
pair<int, int> p = get_lca(x, y);
p.second = min(anc[u][i].second, p.second);
p.second = min(anc[v][i].second, p.second);
return p;
}
}
}
return make_pair(-1, -1);
}
};
bool visit[100100];
weighted_tree tree;
int sumWeight[100100];
int cntNode[100100];
int sumDist[100100];
int sumSqrDist[100100];
int sumAllSqrDist[100100];
int sumAllDist[100100];
int getDistInc(int w, int v) {
return MODP((long long)cntNode[v] * w + sumDist[v]);
}
int getSqrDistInc(int w, int v) {
int sqrDistInc = MODP((long long)w * w);
sqrDistInc = MODP((long long)sqrDistInc * cntNode[v]);
sqrDistInc = MODP(sqrDistInc + (long long)2 * w * sumDist[v]);
sqrDistInc = MODP(sqrDistInc + sumSqrDist[v]);
return sqrDistInc;
}
void dfs(int u) {
visit[u] = true;
cntNode[u] = 1;
sumDist[u] = 0;
sumSqrDist[u] = 0;
for (auto &e : tree.adj[u]) {
int v = e.first, w = e.second;
if (v != tree.pi[u].first && !visit[v]) {
sumWeight[v] = MODP(sumWeight[u] + w);
dfs(v);
cntNode[u] += cntNode[v];
sumDist[u] = MODP(sumDist[u] + getDistInc(w, v));
sumSqrDist[u] = MODP(sumSqrDist[u] + getSqrDistInc(w, v));
}
}
}
void dfsSumAllDist(int u) {
visit[u] = true;
for (auto &e : tree.adj[u]) {
int v = e.first, w = e.second;
if (v != tree.pi[u].first && !visit[v]) {
int nOutside = n - cntNode[v];
int retSumDist = sumAllDist[u];
retSumDist = MODP(retSumDist - getDistInc(w, v));
int retSumSqrDist = sumAllSqrDist[u];
retSumSqrDist = MODP(retSumSqrDist - getSqrDistInc(w, v));
int inc = MODP((long long)w * w);
inc = MODP((long long)inc * nOutside);
inc = MODP(inc + (long long)2 * w * retSumDist);
retSumSqrDist = MODP(retSumSqrDist + inc);
retSumDist = MODP(retSumDist + (long long)w * nOutside);
retSumDist = MODP(retSumDist + sumDist[v]);
sumAllDist[v] = retSumDist;
retSumSqrDist = MODP(retSumSqrDist + sumSqrDist[v]);
sumAllSqrDist[v] = retSumSqrDist;
dfsSumAllDist(v);
}
}
}
int main() {
scanf("%d", &n);
tree.reset(n);
int a, b, c;
for (auto repeat_var = 0; repeat_var < n - 1; ++repeat_var) {
scanf("%d%d%d", &a, &b, &c);
tree.add_edge(a, b, c);
}
tree.set_root(1);
memset(visit, 0, sizeof(visit));
sumWeight[1] = 0;
dfs(1);
memset(visit, 0, sizeof(visit));
sumAllSqrDist[1] = sumSqrDist[1];
sumAllDist[1] = sumDist[1];
dfsSumAllDist(1);
lca tree_lca(tree);
int q;
scanf("%d", &q);
int u, v;
for (auto repeat_var = 0; repeat_var < q; ++repeat_var) {
scanf("%d%d", &u, &v);
int ret;
if (u == v) {
ret = MODP(2 * sumSqrDist[u] - sumAllSqrDist[u]);
} else {
int x = tree_lca.get_lca(u, v).first;
if (x == v) {
int w = MODP(sumWeight[u] - sumWeight[v]);
int nOutside = n - cntNode[v];
ret = 0;
ret = MODP(sumAllSqrDist[v] - sumSqrDist[v]);
int retSumDist = MODP(sumAllDist[v] - sumDist[v]);
int inc = MODP((long long)w * w);
inc = MODP((long long)inc * nOutside);
inc = MODP(inc + (long long)2 * w * retSumDist);
ret = MODP(ret + inc);
ret = MODP(sumAllSqrDist[u] - 2 * ret);
} else {
int w = MODP(sumWeight[u] - sumWeight[x]);
w = MODP(w + sumWeight[v] - sumWeight[x]);
int inc = MODP((long long)w * w);
inc = MODP((long long)inc * cntNode[v]);
inc = MODP(inc + (long long)2 * w * sumDist[v]);
ret = MODP(sumSqrDist[v] + inc);
ret = MODP(2 * ret - sumAllSqrDist[u]);
}
}
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int N, Q;
set<pair<int, int> > g[100001];
int t0[100001], t1[100001], t2[100001];
int p[100001];
template <typename T>
class RMQ {
public:
std::vector<T> data;
std::vector<std::vector<int> > block;
std::vector<int> sblock;
std::vector<int> lookup;
int lg;
int min(int a, int b) { return data[b] < data[a] ? b : a; }
RMQ() {}
RMQ(std::vector<T> &t) {
data = t;
int N = data.size();
lg = (sizeof(N) << 3) - __builtin_clz(N);
block.assign((N + lg - 1) / lg, std::vector<int>(lg, 0));
for (int i = 0; i < N; i++) {
if (i % lg == 0) block[i / lg][0] = i;
block[i / lg][0] = min(i, block[i / lg][0]);
}
for (int j = 1; j < lg; j++)
for (int i = 0; i < block.size(); i++)
block[i][j] = min(
block[i][j - 1],
block[i + (i + (1 << (j - 1)) < block.size() ? (1 << (j - 1)) : 0)]
[j - 1]);
sblock.assign(N, 0);
std::vector<int> st;
for (int i = 0; i < block.size(); i++) {
st.clear();
for (int j = i * lg; j < N && j < i * lg + lg; j++) {
while (!st.empty() && data[j] < data[st.back()]) st.pop_back();
sblock[j] = 1 << (i * lg + lg - j - 1);
if (!st.empty()) sblock[j] |= sblock[st.back()];
st.push_back(j);
}
}
lookup.assign(1 << lg, 0);
for (int i = 1, ans = lg - 1, checker = 2; i < (1 << lg); ++i) {
if (checker <= i) {
ans--;
checker <<= 1;
}
lookup[i] = ans;
}
}
int q(int l, int r) {
if (r < l) swap(l, r);
int l1 = l / lg + 1;
int r1 = r / lg - 1;
int ans = l;
int t;
if (l1 <= r1) {
t = lg - lookup[r1 - l1 + 1] - 1;
ans = min(ans, min(block[l1][t], block[r1 - (1 << t) + 1][t]));
}
t = l1 * lg - 1 < r ? l1 * lg - 1 : r;
ans = min(ans, lookup[sblock[t] & (~(((1 << (l - (l1 * lg - lg))) - 1)
<< (l1 * lg - l)))] +
l1 * lg - lg);
t = r;
l = l > r1 * lg + lg ? l : r1 * lg + lg;
ans = min(ans, lookup[sblock[t] & (~(((1 << (l - (r1 * lg + lg))) - 1)
<< (r1 * lg + (lg << 1) - l)))] +
r1 * lg + lg);
return ans;
}
};
template <typename T>
class segment_tree {
public:
vector<T> data;
vector<T> tt;
int N;
int construct(int root, int cl, int cr) {
if (cl == cr) return tt[root] = cl;
int t1 = construct(root * 2, cl, (cl + cr) / 2);
int t2 = construct(root * 2 + 1, (cl + cr) / 2 + 1, cr);
return tt[root] = data[t2] < data[t1] ? t2 : t1;
}
int query(int root, int cl, int cr, int l, int r) {
if (cl > r || cr < l) return N;
if (l <= cl && cr <= r) return tt[root];
int t1 = query(root * 2, cl, (cl + cr) / 2, l, r);
int t2 = query(root * 2 + 1, (cl + cr) / 2 + 1, cr, l, r);
return data[t2] < data[t1] ? t2 : t1;
}
inline int q(int l, int r) {
if (r < l) swap(l, r);
return query(1, 0, N - 1, l, r);
}
segment_tree(){};
segment_tree(vector<T> a) {
N = a.size();
data = a;
data.push_back(INT_MAX);
tt.resize(4 * N);
construct(1, 0, N - 1);
}
};
class least_common_ancestor {
public:
int N;
vector<vector<int> > g;
vector<int> invf;
vector<int> f;
vector<int> ll;
RMQ<int> rmq;
void inorder(int s = 0, int d = 0) {
ll.push_back(d);
invf[ll.size() - 1] = s;
f[s] = ll.size() - 1;
for (int i = 0; i < g[s].size(); i++) {
inorder(g[s][i], d + 1);
ll.push_back(d);
invf[ll.size() - 1] = s;
}
}
least_common_ancestor(){};
least_common_ancestor(vector<vector<int> > t) {
g = t;
N = g.size();
f.resize(N);
invf.resize(2 * N - 1);
inorder();
rmq = RMQ<int>(ll);
ll.clear();
g.clear();
}
int q(int a, int b) { return invf[rmq.q(f[a], f[b])]; }
};
void fix(int s) {
for (pair<int, int> i : g[s]) {
g[i.first].erase(g[i.first].lower_bound(make_pair(s, 0)));
p[i.first] = s;
fix(i.first);
}
}
int add(int a, int b) {
int ret = a + b;
if (ret >= MOD) ret -= MOD;
return ret;
}
int mul(int a, int b) { return (a * 1ll * b) % MOD; }
int ddd[100001];
least_common_ancestor lca;
int dist(int a, int b) {
return add(add(ddd[a], ddd[b]), MOD - mul(2, ddd[1 + lca.q(a - 1, b - 1)]));
}
set<pair<int, int> > q[100001];
vector<int> ans;
void dfs1(int s, int d = 0) {
t0[s] = 1;
ddd[s] = d;
for (pair<int, int> i : g[s]) {
dfs1(i.first, add(d, i.second));
t0[s] = add(t0[s], t0[i.first]);
t1[s] = add(t1[s], mul(t0[i.first], i.second));
t1[s] = add(t1[s], t1[i.first]);
t2[s] = add(t2[s], t2[i.first]);
t2[s] = add(t2[s], mul(t1[i.first], mul(2, i.second)));
t2[s] = add(t2[s], mul(t0[i.first], mul(i.second, i.second)));
}
}
set<pair<int, pair<int, int> > > st[100001];
void dfs(int s) {
for (pair<int, int> i : g[s]) {
int pt0 = t0[i.first];
int pt1 = t1[i.first];
pt1 = add(pt1, mul(t0[i.first], i.second));
int pt2 = t2[i.first];
pt2 = add(pt2, mul(t1[i.first], mul(2, i.second)));
pt2 = add(pt2, mul(t0[i.first], mul(i.second, i.second)));
t0[s] = add(t0[s], MOD - pt0);
t1[s] = add(t1[s], MOD - pt1);
t2[s] = add(t2[s], MOD - pt2);
int ppt0 = t0[s];
int ppt1 = t1[s];
ppt1 = add(ppt1, mul(t0[s], i.second));
int ppt2 = t2[s];
ppt2 = add(ppt2, mul(t1[s], mul(2, i.second)));
ppt2 = add(ppt2, mul(t0[s], mul(i.second, i.second)));
t0[i.first] = add(t0[i.first], ppt0);
t1[i.first] = add(t1[i.first], ppt1);
t2[i.first] = add(t2[i.first], ppt2);
dfs(i.first);
t0[i.first] = add(t0[i.first], MOD - ppt0);
t1[i.first] = add(t1[i.first], MOD - ppt1);
t2[i.first] = add(t2[i.first], MOD - ppt2);
t0[s] = add(t0[s], pt0);
t1[s] = add(t1[s], pt1);
t2[s] = add(t2[s], pt2);
}
for (pair<int, int> i : g[s])
if (st[i.first].size() > st[s].size()) swap(st[i.first], st[s]);
for (pair<int, int> i : g[s]) {
st[s].insert(st[i.first].begin(), st[i.first].end());
st[i.first].clear();
}
for (set<pair<int, pair<int, int> > >::iterator it =
st[s].lower_bound(make_pair(s, make_pair(0, 0)));
it != st[s].end() && it->first == s; it++) {
if (s == 1) continue;
int ooo = dist(p[s], it->second.first);
ans[it->second.second] =
add(ans[it->second.second],
MOD - mul(2, add(t2[p[s]], add(mul(t1[p[s]], mul(2, ooo)),
mul(t0[p[s]], mul(ooo, ooo))))));
}
for (pair<int, int> i : q[s]) {
if (i.first == s || lca.q(s - 1, i.first - 1) + 1 != i.first) {
ans[i.second] = MOD - t2[s];
continue;
}
ans[i.second] = t2[s];
st[s].insert(make_pair(i.first, make_pair(s, i.second)));
}
}
vector<vector<int> > g1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
for (int i = 1, a, b, c; i < N; i++) {
cin >> a >> b >> c;
g[a].insert(make_pair(b, c));
g[b].insert(make_pair(a, c));
}
g1.resize(N + 1);
cin >> Q;
ans.resize(Q);
for (int i = 0, u, v; i < Q; i++) {
cin >> u >> v;
q[u].insert(make_pair(v, i));
}
fix(1);
for (int i = 1; i <= N; i++)
for (pair<int, int> j : g[i]) g1[i - 1].push_back(j.first - 1);
lca = least_common_ancestor(g1);
dfs1(1);
dfs(1);
for (int s = 1; s <= N; s++)
for (pair<int, int> i : q[s]) {
if (s != i.first && lca.q(s - 1, i.first - 1) + 1 == i.first) continue;
int ooo = dist(s, i.first);
ans[i.second] =
add(ans[i.second],
mul(2, add(t2[i.first], add(mul(t1[i.first], mul(2, ooo)),
mul(t0[i.first], mul(ooo, ooo))))));
}
for (int i : ans) cout << i << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long base = 1000000007;
const int MAXN = 100100;
long long sumsq[MAXN], sum2[MAXN];
long long dist1[MAXN];
long long sumsqrest[MAXN], sum2rest[MAXN];
int ac[MAXN][20];
long long sz[MAXN];
vector<pair<int, int> > v[MAXN];
int n;
int tim, tin[MAXN], tout[MAXN];
void dfs(int x, int pr) {
tin[x] = tim;
tim++;
ac[x][0] = pr;
for (int i = 1; i < 20; i++) ac[x][i] = ac[ac[x][i - 1]][i - 1];
sz[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i].first;
int add = v[x][i].second;
if (to == pr) continue;
dist1[to] = dist1[x] + add;
dist1[to] %= base;
dfs(to, x);
sz[x] += sz[to];
sum2[x] += (sum2[to] + 2 * add * sz[to]);
sum2[x] %= base;
sumsq[x] += sumsq[to];
sumsq[x] %= base;
sumsq[x] += (sum2[to] * add);
sumsq[x] %= base;
sumsq[x] += sz[to] * add % base * add % base;
sumsq[x] %= base;
}
tout[x] = tim;
tim++;
}
void dfs2(int x, int pr) {
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i].first;
int add = v[x][i].second;
if (to == pr) continue;
long long szh = n - sz[to];
long long sumsqh = sumsqrest[x] - (sum2[to] * add) - sumsq[to];
sumsqh += base * base;
sumsqh %= base;
sumsqh -= sz[to] * add % base * add % base;
sumsqh %= base;
long long sum2h = sum2rest[x] - 2 * sz[to] * add % base - sum2[to];
sum2h += base * base;
sum2h %= base;
sumsqrest[to] = sumsq[to];
sum2rest[to] = sum2[to];
sum2rest[to] += (sum2h + 2 * add * szh);
sum2rest[to] %= base;
sumsqrest[to] += sumsqh;
sumsqrest[to] %= base;
sumsqrest[to] += (sum2h * add);
sumsqrest[to] %= base;
sumsqrest[to] += szh * add % base * add % base;
sumsqrest[to] %= base;
dfs2(to, x);
}
}
bool is_ac(int a, int b) { return (tin[a] <= tin[b] && tout[b] <= tout[a]); }
int lca(int a, int b) {
if (is_ac(a, b)) return a;
if (is_ac(b, a)) return b;
for (int i = 19; i >= 0; i--) {
if (!is_ac(ac[b][i], a)) b = ac[b][i];
}
return ac[b][0];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int aa, bb, cc;
scanf("%d%d%d", &aa, &bb, &cc);
v[aa].push_back(make_pair(bb, cc));
v[bb].push_back(make_pair(aa, cc));
}
tin[0] = -1;
tout[0] = (1 << 20);
dfs(1, 0);
sumsqrest[1] = sumsq[1];
sum2rest[1] = sum2[1];
dfs2(1, 0);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int aa, bb;
scanf("%d%d", &aa, &bb);
int o = lca(aa, bb);
long long dist = dist1[aa] + dist1[bb] - 2 * dist1[o];
long long F, S;
if (!is_ac(bb, aa)) {
F = sumsq[bb] + dist * sum2[bb] + sz[bb] * dist % base * dist % base;
F %= base;
S = sumsqrest[aa] - F;
S += base * base;
S %= base;
} else {
long long szr = n - sz[bb];
F = sumsqrest[aa] -
(sumsqrest[bb] - sumsq[bb] + szr * dist % base * dist % base +
(sum2rest[bb] - sum2[bb] + base) * dist % base);
F += base * base;
F %= base;
S = sumsqrest[aa] - F;
S += base * base;
S %= base;
}
long long ans = F - S;
ans += base * base;
ans %= base;
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double PI = acos(-1.0);
using namespace std;
int C[3][3];
class Tree {
public:
int head[200005], nxt[200005], e[200005], w[200005];
int dpson[200005][3], dpfa[200005][3];
int dp[200005][3];
int cnt;
void init(int n) {
cnt = 0;
for (int i = 0; i <= n; i++) head[i] = -1;
this->n = n;
}
inline void addEdge(int u, int v, int w) {
e[cnt] = v;
this->w[cnt] = w;
int tmp = head[u];
head[u] = cnt;
nxt[cnt++] = tmp;
}
int dis[200005];
int p[200005][20];
int dis1[200005];
int n;
int tot;
void dfs(int u, int fa, int d, int d1) {
dis[u] = d;
dis1[u] = d1;
p[u][0] = fa;
for (int i = 1; (1 << i) <= n; i++) {
if (~p[u][i - 1])
p[u][i] = p[p[u][i - 1]][i - 1];
else
p[u][i] = -1;
}
for (int i = head[u]; ~i; i = nxt[i]) {
int v = e[i];
if (v == fa) continue;
dfs(v, u, d + 1, (d1 + w[i]) % 1000000007);
}
}
int LCA(int u, int v) {
if (dis[u] > dis[v]) swap(u, v);
if (dis[u] < dis[v]) {
int offset = dis[v] - dis[u];
for (int i = 0; (1 << i) <= n; i++)
if (offset & (1 << i)) v = p[v][i];
}
if (u != v) {
for (int i = log2(n); i >= 0; i--) {
if (p[u][i] != p[v][i]) u = p[u][i], v = p[v][i];
}
u = p[u][0], v = p[v][0];
}
return u;
}
void update(int a[], int b[], int w) {
for (int j = 0; j <= 2; j++) {
int now = 1;
for (int l = 0; l <= j; l++) {
Add(a[j], 1ll * C[j][l] * b[j - l] % 1000000007 * now % 1000000007);
now = 1ll * now * w % 1000000007;
}
}
}
void dfs(int u, int fa) {
for (int i = 0; i <= 2; i++) dpson[u][i] = 0;
dpson[u][0] = 1;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = e[i];
if (v == fa) continue;
tofa[v] = w[i];
dfs(v, u);
update(dpson[u], dpson[v], w[i]);
}
}
int stack[200005];
int tmp[3];
int tofa[200005];
void dfs1(int u, int fa, int idx) {
if (idx != -1)
tofa[u] = w[idx];
else
tofa[u] = 0;
if (fa != -1) {
update(dpfa[u], dpfa[fa], tofa[fa]);
for (int i = 0; i <= 2; i++) {
dp[idx][i] = dpson[u][i];
dp[idx ^ 1][i] = dpfa[u][i];
}
}
for (int i = 0; i <= 2; i++) tmp[i] = 0;
int tot = 0;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = e[i];
if (v == fa) continue;
for (int j = 0; j <= 2; j++) Add(dpfa[v][j], tmp[j]);
update(tmp, dpson[v], w[i]);
stack[tot++] = i;
}
for (int i = 0; i <= 2; i++) tmp[i] = 0;
for (int x = tot - 1; x >= 0; x--) {
int i = stack[x];
int v = e[i];
if (v == fa) continue;
for (int j = 0; j <= 2; j++) Add(dpfa[v][j], tmp[j]);
update(tmp, dpson[v], w[i]);
}
for (int i = head[u]; ~i; i = nxt[i]) {
int v = e[i];
if (v == fa) continue;
dfs1(v, u, i);
}
}
int sum[200005][3];
void Add(int &ans, int v) {
ans += v;
if (ans >= 1000000007) ans -= 1000000007;
}
void dpSum() {
dfs(1, -1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 2; j++) dpfa[i][j] = 0;
if (i > 1) dpfa[i][0] = 1;
}
dfs1(1, -1, -1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 2; j++) sum[i][j] = 0;
for (int j = head[i]; ~j; j = nxt[j]) update(sum[i], dp[j], w[j]);
}
}
} lca;
int main(void) {
C[0][0] = 1;
for (int i = 1; i <= 2; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
int n;
scanf("%d", &n);
lca.init(n);
for (int i = 0; i < n - 1; i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
lca.addEdge(u, v, w);
lca.addEdge(v, u, w);
}
lca.dfs(1, -1, 0, 0);
lca.dpSum();
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d %d", &u, &v);
int ans = -lca.sum[u][2];
int f = lca.LCA(u, v);
int d = (0ll + lca.dis1[u] + lca.dis1[v] - 2 * lca.dis1[f]) % 1000000007;
int ret = 0;
if (v == 1)
ret = lca.sum[u][2];
else if (f == v) {
int res[3] = {0};
lca.update(res, lca.dpfa[v], (d + lca.tofa[v]) % 1000000007);
ret = lca.sum[u][2] - res[2];
ret = (ret % 1000000007 + 1000000007) % 1000000007;
} else {
int res[3] = {0};
lca.update(res, lca.dpson[v], d);
ret = res[2];
}
ans += 2 * ret % 1000000007;
ans = (ans % 1000000007 + 1000000007) % 1000000007;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int mod = 1000000007;
int df1[maxn], df2[maxn];
int a[maxn], b[maxn];
struct pi {
int sum1, sum2;
int lazy;
int le, ri;
} pp[maxn << 2];
struct pppi {
int to;
int cost;
} pp2;
vector<pppi> g[maxn];
struct ppi {
int to;
int id;
} pp1;
vector<ppi> gg[maxn];
int cnt;
void dfs(int u, int pa, int w) {
df1[u] = ++cnt;
a[cnt] = w;
int p = g[u].size();
for (int i = 0; i < p; i++) {
if (g[u][i].to != pa) {
dfs(g[u][i].to, u, (w + g[u][i].cost) % mod);
}
}
df2[u] = cnt;
}
void build(int tot, int l, int r) {
pp[tot].le = l;
pp[tot].ri = r;
pp[tot].lazy = 0;
if (l == r) {
pp[tot].sum1 = a[l];
pp[tot].sum2 = ((long long)a[l] * a[l]) % mod;
return;
}
build(2 * tot, l, (l + r) / 2);
build(2 * tot + 1, (l + r) / 2 + 1, r);
pp[tot].sum1 = pp[2 * tot].sum1 + pp[2 * tot + 1].sum1;
pp[tot].sum1 %= mod;
pp[tot].sum2 = pp[2 * tot].sum2 + pp[2 * tot + 1].sum2;
pp[tot].sum2 %= mod;
}
void update(int tot) {
if (pp[tot].le != pp[tot].ri) {
pp[2 * tot].lazy += pp[tot].lazy;
pp[2 * tot + 1].lazy += pp[tot].lazy;
pp[2 * tot].lazy %= mod;
pp[2 * tot + 1].lazy %= mod;
}
pp[tot].sum2 = pp[tot].sum2 +
(2 * (((long long)pp[tot].lazy * pp[tot].sum1) % mod)) % mod;
pp[tot].sum2 %= mod;
pp[tot].sum2 += (((long long)pp[tot].lazy * pp[tot].lazy) % mod *
(pp[tot].ri - pp[tot].le + 1)) %
mod;
pp[tot].sum2 %= mod;
pp[tot].sum1 +=
((long long)pp[tot].lazy * (pp[tot].ri - pp[tot].le + 1)) % mod;
pp[tot].sum1 %= mod;
pp[tot].lazy = 0;
}
void merg(int tot, int l, int r, int p) {
if (pp[tot].le >= l && pp[tot].ri <= r) {
pp[tot].lazy += p;
pp[tot].lazy %= mod;
return;
}
pp[2 * tot].lazy += pp[tot].lazy;
pp[2 * tot + 1].lazy += pp[tot].lazy;
pp[2 * tot].lazy %= mod;
pp[2 * tot + 1].lazy %= mod;
pp[tot].lazy = 0;
int mid = (pp[tot].le + pp[tot].ri) / 2;
if (l <= mid) merg(2 * tot, l, r, p);
if (r > mid) merg(2 * tot + 1, l, r, p);
update(2 * tot);
update(2 * tot + 1);
pp[tot].sum1 = pp[2 * tot].sum1 + pp[2 * tot + 1].sum1;
pp[tot].sum1 %= mod;
pp[tot].sum2 = pp[2 * tot].sum2 + pp[2 * tot + 1].sum2;
pp[tot].sum2 %= mod;
}
int n;
int query(int tot, int l, int r, int s) {
s += pp[tot].lazy;
s %= mod;
if (pp[tot].le >= l && pp[tot].ri <= r) {
int s1 = (((long long)pp[tot].sum1 * 2) % mod * s) % mod;
s1 += (((long long)s * s) % mod * (pp[tot].ri - pp[tot].le + 1)) % mod;
s1 %= mod;
s1 += pp[tot].sum2;
s1 %= mod;
return s1;
}
int s1 = 0;
int mid = (pp[tot].le + pp[tot].ri) / 2;
if (l <= mid) s1 += query(2 * tot, l, r, s);
if (r > mid) s1 += query(2 * tot + 1, l, r, s);
s1 %= mod;
return s1;
}
int work[maxn];
void dfs3(int u, int pa) {
int p = (int)gg[u].size();
int s, s1;
s = query(1, 1, cnt, 0);
for (int i = 0; i < p; i++) {
s1 = query(1, df1[gg[u][i].to], df2[gg[u][i].to], 0);
s1 = (2 * s1) % mod - s;
s1 %= mod;
s1 = (s1 + mod) % mod;
work[gg[u][i].id] = s1;
}
p = (int)g[u].size();
for (int i = 0; i < p; i++) {
if (g[u][i].to != pa) {
merg(1, df1[g[u][i].to], df2[g[u][i].to], -g[u][i].cost);
if (df1[g[u][i].to] > 1) merg(1, 1, df1[g[u][i].to] - 1, g[u][i].cost);
if (df2[g[u][i].to] < cnt)
merg(1, df2[g[u][i].to] + 1, cnt, g[u][i].cost);
dfs3(g[u][i].to, u);
merg(1, df1[g[u][i].to], df2[g[u][i].to], g[u][i].cost);
if (df1[g[u][i].to] > 1) merg(1, 1, df1[g[u][i].to] - 1, -g[u][i].cost);
if (df2[g[u][i].to] < cnt)
merg(1, df2[g[u][i].to] + 1, cnt, -g[u][i].cost);
}
}
}
int main() {
int i, m;
int a, b, c;
cin >> n;
for (i = 0; i < n - 1; i++) {
scanf("%d%d%d", &a, &b, &c);
pp2.to = b;
pp2.cost = c;
g[a].push_back(pp2);
pp2.to = a;
g[b].push_back(pp2);
}
cin >> m;
for (i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
pp1.to = b;
pp1.id = i;
gg[a].push_back(pp1);
}
dfs(1, -1, 0);
build(1, 1, cnt);
dfs3(1, -1);
for (i = 0; i < m; i++) printf("%d\n", work[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char c;
while (c = getchar(), (c < '0' || c > '9') && (c != '-'))
;
bool flag = (c == '-');
if (flag) c = getchar();
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
return flag ? -x : x;
}
void output(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
int len = 0, data[10];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
putchar('\n');
}
const int maxn = 100000;
const int maxsize = 262144;
const int mod = 1000000007;
int n, counter;
vector<pair<int, int> > g[maxn], q[maxn];
int seq[maxn], dfn[maxn], dfn2[maxn], parent[maxn], depth[maxn];
int Left[maxsize], Right[maxsize];
long long s1[maxsize], s2[maxsize], delta[maxsize];
long long ans[maxn];
void dfs(int x, int last, int d) {
seq[counter] = x;
dfn[x] = counter++;
parent[x] = last;
depth[x] = d;
for (int i = 0; i < g[x].size(); i++)
if (g[x][i].first != last)
dfs(g[x][i].first, x, (d + g[x][i].second) % mod);
dfn2[x] = counter;
}
void build(int p, int l, int r) {
Left[p] = l;
Right[p] = r;
if (l == r) {
s1[p] = depth[seq[l]];
s2[p] = s1[p] * s1[p] % mod;
} else {
int mid = (l + r) / 2;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
s1[p] = (s1[p * 2] + s1[p * 2 + 1]) % mod;
s2[p] = (s2[p * 2] + s2[p * 2 + 1]) % mod;
}
}
void check(int p) {
if (!delta[p]) return;
long long len = Right[p] - Left[p] + 1;
s2[p] = (s2[p] + s1[p] * delta[p] * 2) % mod;
s2[p] = (s2[p] + delta[p] * delta[p] % mod * len) % mod;
s1[p] = (s1[p] + delta[p] * len) % mod;
if (len > 1) {
delta[p * 2] = (delta[p * 2] + delta[p]) % mod;
delta[p * 2 + 1] = (delta[p * 2 + 1] + delta[p]) % mod;
}
delta[p] = 0;
}
void add(int p, int l, int r, long long d) {
if (l > r) return;
check(p);
if (Left[p] == l && Right[p] == r) {
delta[p] = (delta[p] + d) % mod;
return;
}
int mid = (Left[p] + Right[p]) / 2;
if (r <= mid)
add(p * 2, l, r, d);
else if (l > mid)
add(p * 2 + 1, l, r, d);
else {
add(p * 2, l, mid, d);
add(p * 2 + 1, mid + 1, r, d);
}
check(p * 2);
check(p * 2 + 1);
s1[p] = (s1[p * 2] + s1[p * 2 + 1]) % mod;
s2[p] = (s2[p * 2] + s2[p * 2 + 1]) % mod;
}
long long getsum(int p, int l, int r) {
check(p);
if (Left[p] == l && Right[p] == r) return s2[p];
int mid = (Left[p] + Right[p]) / 2;
if (r <= mid) return getsum(p * 2, l, r);
if (l > mid) return getsum(p * 2 + 1, l, r);
return getsum(p * 2, l, mid) + getsum(p * 2 + 1, mid + 1, r);
}
void solve(int x) {
for (int i = 0; i < q[x].size(); i++) {
int y = q[x][i].first, num = q[x][i].second;
ans[num] = (getsum(1, dfn[y], dfn2[y] - 1) * 2 - getsum(1, 0, n - 1)) % mod;
if (ans[num] < 0) ans[num] += mod;
}
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i].first, w = g[x][i].second;
if (y == parent[x]) continue;
add(1, dfn[y], dfn2[y] - 1, -w);
add(1, 0, dfn[y] - 1, w);
add(1, dfn2[y], n - 1, w);
solve(y);
add(1, dfn[y], dfn2[y] - 1, w);
add(1, 0, dfn[y] - 1, -w);
add(1, dfn2[y], n - 1, -w);
}
}
int main() {
n = get();
for (int i = 1; i < n; i++) {
int x = get() - 1, y = get() - 1, w = get();
g[x].push_back(make_pair(y, w));
g[y].push_back(make_pair(x, w));
}
int m = get();
for (int i = 0; i < m; i++) {
int x = get() - 1, y = get() - 1;
q[x].push_back(make_pair(y, i));
}
counter = 0;
dfs(0, -1, 0);
build(1, 0, n - 1);
memset(delta, 0, sizeof(delta));
solve(0);
for (int i = 0; i < m; i++) output(ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int primero = 1 << 18;
const int tope = 1 << 19;
pair<int, int> minimo[tope];
void insertar(int pos, pair<int, int> val) {
pos += primero;
minimo[pos] = val;
while (pos > 1) {
pos /= 2;
minimo[pos] = min(minimo[2 * pos], minimo[2 * pos + 1]);
}
}
pair<int, int> minimoentre(int pos0, int pos1) {
pos0 += primero;
pos1 += primero;
if (pos0 > pos1) swap(pos0, pos1);
if (pos0 == pos1) return minimo[pos0];
pair<int, int> mini = min(minimo[pos0], minimo[pos1]);
while (pos0 + 1 < pos1) {
if (pos0 % 2 == 0) mini = min(mini, minimo[pos0 + 1]);
pos0 /= 2;
if (pos1 % 2 == 1) mini = min(mini, minimo[pos1 - 1]);
pos1 /= 2;
}
return mini;
}
long long int modulo = 1e9 + 7;
long long int suma[1000000];
void inserta(int pos, long long int val) {
while (pos < 1000000) {
suma[pos] = (suma[pos] + val) % modulo;
pos += pos & -pos;
}
}
long long int sumaantes(int pos) {
long long int s = 0;
while (pos) {
s = (s + suma[pos]) % modulo;
pos -= pos & -pos;
}
return s;
}
int n;
vector<pair<int, int> > g[1000000];
int padre[1000000];
int posle[1000000];
int posri[1000000];
long long int cuantos[1000000];
long long int sumad[1000000];
long long int sumad2[1000000];
int posact = 1;
long long int sumadtodos[1000000];
long long int sumad2todos[1000000];
int posleminimo[1000000];
int posminimo = 1;
void computa(int u, long long int sumadp, long long int sumad2p, int prof) {
sumadtodos[u] = (sumad[u] + sumadp) % modulo;
sumad2todos[u] = (sumad2[u] + sumad2p) % modulo;
vector<pair<int, int> > &ar = g[u];
posleminimo[u] = posminimo;
insertar(posminimo++, pair<int, int>(prof, u));
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i].first;
long long int d = ar[i].second;
long long int cuantosaux = n - cuantos[v];
long long int sumadaux =
(sumadtodos[u] - (sumad[v] + cuantos[v] * d)) % modulo;
long long int sumad2aux =
(sumad2todos[u] -
(sumad2[v] + cuantos[v] * d % modulo * d + 2 * d * sumad[v])) %
modulo;
computa(
v, (sumadaux + cuantosaux * d) % modulo,
(sumad2aux + cuantosaux * d % modulo * d + 2 * d * sumadaux) % modulo,
prof + 1);
insertar(posminimo++, pair<int, int>(prof, u));
}
}
void eliminapadre(int u, int p) {
cuantos[u] = 1;
posle[u] = posact++;
padre[u] = p;
vector<pair<int, int> > &ar = g[u];
vector<pair<int, int> > nextar;
int dpadre = 0;
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i].first;
long long int d = ar[i].second;
if (v != p) {
nextar.push_back(ar[i]);
eliminapadre(v, u);
cuantos[u] += cuantos[v];
sumad[u] = (sumad[u] + sumad[v] + cuantos[v] * d) % modulo;
sumad2[u] = (sumad2[u] + sumad2[v] + cuantos[v] * d % modulo * d +
2 * d * sumad[v]) %
modulo;
} else
dpadre = d;
}
ar = nextar;
posri[u] = posact++;
inserta(posle[u], dpadre);
inserta(posri[u], -dpadre);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, c;
cin >> u >> v >> c;
g[u].push_back(pair<int, int>(v, c));
g[v].push_back(pair<int, int>(u, c));
}
eliminapadre(1, 0);
computa(1, 0, 0, 0);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
int w = minimoentre(posleminimo[u], posleminimo[v]).second;
long long int d = (sumaantes(posle[u]) - sumaantes(posle[w]) +
sumaantes(posle[v]) - sumaantes(posle[w])) %
modulo;
long long int sol;
if (posle[v] < posle[u] and posle[u] < posri[v]) {
long long int cuantosaux = n - cuantos[v];
long long int sumadaux = (sumadtodos[v] - sumad[v]) % modulo;
long long int sumad2aux = (sumad2todos[v] - sumad2[v]) % modulo;
sol = (sumad2todos[u] - 2 * (sumad2aux + cuantosaux * d % modulo * d +
2 * d * sumadaux % modulo)) %
modulo;
} else {
sol = (-sumad2todos[u] + 2 * (sumad2[v] + cuantos[v] * d % modulo * d +
2 * d * sumad[v] % modulo)) %
modulo;
}
cout << (sol % modulo + modulo) % modulo << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 1e5 + 10, MAXx = 4 * MAXn, MOD = 1e9 + 7;
long long n, q, st[MAXn], ft[MAXn], now, h[MAXn], ans[MAXn];
vector<pair<long long, long long> > g[MAXn], query[MAXn];
struct node {
int l, r, lc, rc;
long long lazy;
pair<long long, long long> val;
node() {
lazy = l = r = lc = rc = 0;
val = pair<long long, long long>(0, 0);
}
void id(int v) {
lc = 2 * v;
rc = 2 * v + 1;
}
int size() { return r - l; }
bool leaf() { return size() == 1; }
bool unity(int lq, int rq) { return max(l, lq) < min(r, rq); }
int unitys(int lq, int rq) { return min(r, rq) - max(l, lq); }
bool init(int lq, int rq) { return lq <= l && r <= rq; }
};
node seg[MAXx];
inline pair<long long, long long> merge(pair<long long, long long> p1,
long long k, long long cnt) {
k %= MOD;
p1.first %= MOD;
p1.second %= MOD;
return pair<long long, long long>(
(((p1.first + ((((k * k) % MOD) * cnt) % MOD)) % MOD) +
((((2 * k) % MOD) * p1.second) % MOD) + MOD) %
MOD,
(p1.second + ((k * cnt) % MOD) + MOD) % MOD);
}
void build(int v, int l, int r) {
seg[v].id(v);
seg[v].l = l;
seg[v].r = r;
if (seg[v].leaf()) {
seg[v].val.first = (h[seg[v].l] * h[seg[v].l]) % MOD;
seg[v].val.second = h[seg[v].l];
return;
}
int med = (l + r) / 2;
build(seg[v].lc, l, med);
build(seg[v].rc, med, r);
seg[v].val.first = seg[seg[v].lc].val.first + seg[seg[v].rc].val.first;
seg[v].val.second = seg[seg[v].lc].val.second + seg[seg[v].rc].val.second;
}
void add(int v, int l, int r, long long k) {
if (!seg[v].unity(l, r)) return;
if (seg[v].init(l, r)) {
seg[v].lazy += k + MOD;
seg[v].lazy %= MOD;
seg[v].val = merge(seg[v].val, k, seg[v].size());
return;
}
add(seg[v].lc, l, r, k);
add(seg[v].rc, l, r, k);
seg[v].val.first = seg[seg[v].lc].val.first + seg[seg[v].rc].val.first;
seg[v].val.second = seg[seg[v].lc].val.second + seg[seg[v].rc].val.second;
seg[v].val = merge(seg[v].val, seg[v].lazy, seg[v].size());
}
pair<long long, long long> get(int v, int l, int r) {
if (!seg[v].unity(l, r)) return pair<long long, long long>(0, 0);
if (seg[v].init(l, r)) {
return seg[v].val;
}
pair<long long, long long> hp1 = get(seg[v].lc, l, r),
hp2 = get(seg[v].rc, l, r);
pair<long long, long long> res = pair<long long, long long>(
(hp1.first + hp2.first) % MOD, (hp1.second + hp2.second) % MOD);
res = merge(res, seg[v].lazy, seg[v].unitys(l, r));
return res;
}
void dfs(int v, int par, long long hi) {
st[v] = now++;
h[st[v]] = hi;
for (int i = 0; i < g[v].size(); i++)
if (g[v][i].first != par)
dfs(g[v][i].first, v, (hi + g[v][i].second) % MOD);
ft[v] = now;
}
void dfsans(int v, int par) {
for (int i = 0; i < query[v].size(); i++) {
int ind = query[v][i].second, node = query[v][i].first;
ans[ind] -= (get(1, 0, now).first + MOD) % MOD;
ans[ind] = (ans[ind] + MOD) % MOD;
ans[ind] += (2 * get(1, st[node], ft[node]).first) % MOD;
ans[ind] = (ans[ind] + MOD) % MOD;
}
for (int i = 0; i < g[v].size(); i++) {
long long node = g[v][i].first, weight = g[v][i].second;
if (node != par) {
add(1, 0, st[node], weight);
add(1, st[node], ft[node], (MOD - weight));
add(1, ft[node], now, weight);
dfsans(node, v);
add(1, ft[node], now, (MOD - weight));
add(1, st[node], ft[node], weight);
add(1, 0, st[node], (MOD - weight));
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, c;
cin >> u >> v >> c;
g[u].push_back(pair<long long, long long>(v, c));
g[v].push_back(pair<long long, long long>(u, c));
}
cin >> q;
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
query[u].push_back(pair<long long, long long>(v, i));
}
dfs(1, 0, 0);
build(1, 0, now);
dfsans(1, 0);
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005, MAXM = 17, Mod = 1000000007;
int sz[MAXN], fa[MAXN][MAXM], dep[MAXN], q[MAXN], n, m, x, y, c, lca;
long long s[MAXN], sons[MAXN], sonsq[MAXN], fs[MAXN], fsq[MAXN], dis, ans;
struct Edge {
int y, c;
Edge *next;
} pool[MAXN << 1], *mem = pool, *first[MAXN] = {0};
inline void addedge(int a, int b, int c) {
mem->y = b;
mem->c = c;
mem->next = first[a];
first[a] = mem++;
mem->y = a;
mem->c = c;
mem->next = first[b];
first[b] = mem++;
}
void dfs(int cur, int depth, int sum) {
dep[cur] = depth;
s[cur] = sum;
for (int log = 1; (1 << log) <= depth; ++log)
fa[cur][log] = fa[fa[cur][log - 1]][log - 1];
sz[cur] = 1;
for (Edge *j = first[cur]; j; j = j->next)
if (j->y != fa[cur][0]) {
fa[j->y][0] = cur;
dfs(j->y, depth + 1, (sum + j->c) % Mod);
sz[cur] += sz[j->y];
sons[cur] =
(sons[cur] + (sons[j->y] + (long long)sz[j->y] * j->c % Mod)) % Mod;
sonsq[cur] += sonsq[j->y] + (j->c * sons[j->y] % Mod) * 2LL % Mod +
((long long)j->c * j->c % Mod) * sz[j->y] % Mod;
sonsq[cur] %= Mod;
}
}
void bfs() {
int head = 0, tail = 0, cur;
long long tmp, sum;
q[tail++] = 1;
fs[1] = 0;
fsq[1] = 0;
while (head != tail) {
cur = q[head++];
for (Edge *j = first[cur]; j; j = j->next)
if (j->y != fa[cur][0]) {
tmp = sonsq[j->y] + (j->c * sons[j->y] % Mod) * 2LL % Mod +
((long long)j->c * j->c % Mod) * sz[j->y] % Mod;
sum = (((long long)sz[j->y] * j->c % Mod) + sons[j->y]) % Mod;
fs[j->y] =
fs[cur] + sons[cur] - sum + (long long)j->c * (n - sz[j->y]) % Mod;
fs[j->y] %= Mod;
fsq[j->y] = fsq[cur] + sonsq[cur] - tmp +
((fs[cur] + sons[cur] - sum) * j->c % Mod) * 2LL % Mod +
((long long)j->c * j->c % Mod) * (n - sz[j->y]) % Mod;
fsq[j->y] %= Mod;
q[tail++] = j->y;
}
}
}
int getLCA(int a, int b) {
int i, log;
if (dep[a] < dep[b]) {
a = a + b;
b = a - b;
a = a - b;
}
for (log = 0; (1 << (log + 1)) <= dep[a]; ++log)
;
for (i = log; i >= 0; --i)
if ((1 << i) <= dep[a] && dep[fa[a][i]] >= dep[b]) a = fa[a][i];
if (a == b) return a;
for (i = log; i >= 0; --i)
if (dep[a] >= (1 << i) && fa[a][i] != fa[b][i]) a = fa[a][i], b = fa[b][i];
return fa[a][0];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &x, &y, &c);
addedge(x, y, c);
}
dfs(1, 0, 0);
bfs();
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
lca = getLCA(x, y);
if (lca == y) {
dis = s[x] - s[y];
ans = (sonsq[x] + fsq[x] -
(2LL *
(fsq[y] + (fs[y] * dis % Mod) * 2LL % Mod +
(dis * dis % Mod) * (n - sz[y])) %
Mod)) %
Mod;
} else {
dis = (s[x] + s[y] - 2 * s[lca]) % Mod;
ans = ((2LL *
(sonsq[y] + (2LL * (sons[y] * dis % Mod) % Mod) +
(dis * dis % Mod) * sz[y] % Mod) %
Mod) -
(sonsq[x] + fsq[x])) %
Mod;
}
printf("%I64d\n", (ans + Mod) % Mod);
}
return 0;
}
|
#include <bits/stdc++.h>
inline long long getint() {
register long long num = 0, sgn = 1;
register char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') sgn = 0;
for (; isdigit(ch); ch = getchar()) num = (num << 3) + (num << 1) + ch - '0';
return sgn ? num : -num;
}
long long n, head[100010], next[100010 << 1], to[100010 << 1], tot = 0,
val[100010 << 1];
long long anc[100010][17 + 1];
long long dep[100010], ad[100010], ad2[100010], siz[100010], ds[100010],
ds2[100010], dis[100010];
inline void addedge(long long u, long long v, long long w) {
next[++tot] = head[u];
to[tot] = v;
val[tot] = w;
head[u] = tot;
next[++tot] = head[v];
to[tot] = u;
val[tot] = w;
head[v] = tot;
}
inline long long sq(long long x) { return 1LL * x * x % 1000000007; }
void dfs(long long u) {
siz[u] = 1;
for (register long long i = head[u], v = to[i]; ~i; v = to[i = next[i]]) {
if (anc[u][0] == v) continue;
anc[v][0] = u;
dep[v] = dep[u] + 1;
dis[v] = (dis[u] + val[i]) % 1000000007;
dfs(v);
siz[u] += siz[v];
ds[u] = (0LL + ds[u] + ds[v] + 1LL * siz[v] * val[i]) % 1000000007;
ds2[u] = (0LL + ds2[u] + ds2[v] + (2LL * val[i] * ds[v]) % 1000000007 +
(1LL * siz[v] * sq(val[i])) % 1000000007) %
1000000007;
}
}
void dfs2(long long u) {
for (register long long i = head[u], v = to[i]; ~i; v = to[i = next[i]]) {
if (anc[u][0] == v) continue;
ad[v] = (ad[u] + (n - 2LL * siz[v]) * val[i]) % 1000000007;
ad2[v] =
(ad2[u] +
2LL * val[i] * ((ad[u] - 2LL * ds[v] - siz[v] * val[i]) % 1000000007) +
(n - 2LL * siz[v]) * ((val[i] * val[i]) % 1000000007)) %
1000000007;
dfs2(v);
}
}
inline void init() {
dep[1] = 1;
dfs(1);
ad[1] = ds[1];
ad2[1] = ds2[1];
dfs2(1);
for (long long i = 1; i <= 17; i++)
for (long long j = 1; j <= n; j++) anc[j][i] = anc[anc[j][i - 1]][i - 1];
}
inline long long LCA(long long x, long long y) {
long long _x = x, _y = y;
if (dep[x] < dep[y]) x ^= y ^= x ^= y;
for (long long i = 17; ~i; i--)
if (dep[anc[x][i]] >= dep[y]) x = anc[x][i];
if (x == y) return x;
for (long long i = 17; ~i; i--)
if (anc[x][i] != anc[y][i]) x = anc[x][i], y = anc[y][i];
return anc[x][0];
}
signed main() {
n = getint();
memset(head, -1, sizeof(head));
for (long long i = 1, u, v, w; i < n; i++) {
u = getint();
v = getint();
w = getint();
addedge(u, v, w);
}
init();
for (long long q = getint(), u, v, lca; q; q--) {
u = getint();
v = getint();
lca = LCA(u, v);
long long ans = 0;
if (lca == v) {
ans = (dis[u] - dis[v]) % 1000000007;
ans = (((n - siz[v]) * sq(ans) * 1LL) % 1000000007 +
2LL * ans * (ad[v] - ds[v]) +
1LL * ((ad2[v] - ds2[v])) % 1000000007) %
1000000007;
ans = (ad2[u] - 2LL * ans) % 1000000007;
} else {
ans = (dis[u] + dis[v] - 2LL * dis[lca]) % 1000000007;
ans = (siz[v] * sq(ans) + 2LL * ans * ds[v] + ds2[v]) % 1000000007;
ans = (2LL * ans - ad2[u]) % 1000000007;
}
printf("%lld\n",
((ans + 1000000007) % 1000000007 + 1000000007) % 1000000007);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline int read() {
int w = 1, s = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return w * s;
}
struct node {
int to, next, w;
} e[1000100];
struct data {
long long a, b, c;
} Sub[200010], All[200010];
int n, h[1000100], tot, fa[100010][21], dep[100010], Q, dis[100010];
inline data operator-(data p, data q) {
return (data){(p.a - q.a + mod) % mod, (p.b - q.b + mod) % mod,
(p.c - q.c + mod) % mod};
}
inline void add(int from, int to, int w) {
e[++tot].next = h[from];
h[from] = tot;
e[tot].to = to;
e[tot].w = w;
}
inline data Merge(data p, data q, long long d) {
data res;
res.a = (p.a + q.a) % mod;
res.b = (p.b + q.b + q.a * d) % mod;
res.c = (p.c + q.c + d * d % mod * q.a % mod + q.b * d % mod * 2 % mod) % mod;
return res;
}
inline void DFS1(int now, int ffa) {
Sub[now].a = 1;
fa[now][0] = ffa;
dep[now] = dep[ffa] + 1;
for (register int i = h[now]; i; i = e[i].next) {
int to = e[i].to;
if (to == ffa) continue;
dis[to] = (dis[now] + e[i].w) % mod;
DFS1(to, now);
Sub[now] = Merge(Sub[now], Sub[to], e[i].w);
}
}
inline void DFS2(int now, int ffa) {
for (register int i = h[now]; i; i = e[i].next) {
int to = e[i].to;
if (to == ffa) continue;
All[to].a = n;
All[to].b = (Sub[to].b + e[i].w * (n - Sub[to].a) % mod +
(All[now].b - Sub[to].b - Sub[to].a * e[i].w % mod)) %
mod;
if (All[to].b < 0) All[to].b += mod;
long long tmp1 = All[now].c - Sub[to].c -
1ll * e[i].w * e[i].w % mod * Sub[to].a % mod -
2ll * e[i].w * Sub[to].b % mod;
tmp1 %= mod;
tmp1 += mod;
tmp1 %= mod;
long long tmp2 = (All[now].b - Sub[to].b - Sub[to].a * e[i].w % mod);
tmp2 %= mod;
tmp2 += mod;
tmp2 %= mod;
All[to].c =
(Sub[to].c + 1ll * e[i].w * e[i].w % mod * (n - Sub[to].a) % mod +
tmp1 + 2ll * tmp2 * e[i].w % mod) %
mod;
DFS2(to, now);
}
}
inline void Init() {
for (register int i = 1; i <= 19; ++i)
for (register int j = 1; j <= n; ++j) fa[j][i] = fa[fa[j][i - 1]][i - 1];
}
inline int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (register int i = 19; i >= 0; --i)
if (dep[fa[u][i]] >= dep[v]) u = fa[u][i];
if (u == v) return u;
for (register int i = 19; i >= 0; --i)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
inline int getdis(int u, int v) {
int L = lca(u, v);
long long tmp = (long long)dis[u] + dis[v] - 2ll * dis[L];
tmp %= mod;
tmp += mod;
tmp %= mod;
return tmp;
}
inline int Query(int u, int v) {
int L = lca(u, v);
if (L != v) {
long long d = getdis(u, v);
long long tmp1 =
(Sub[v].c + d * d % mod * Sub[v].a % mod + 2ll * Sub[v].b * d % mod) %
mod;
long long tmp2 = (All[u].c - tmp1 + mod) % mod;
return (tmp1 - tmp2 + mod) % mod;
} else {
long long d = getdis(u, v);
data t = All[v] - Sub[v];
long long tmp2 =
(t.c + d * d % mod * t.a % mod + 2ll * t.b * d % mod) % mod;
long long tmp1 = (All[u].c - tmp2 + mod) % mod;
return (tmp1 - tmp2 + mod) % mod;
}
}
int main() {
n = read();
for (register int i = 1; i < n; ++i) {
int u = read(), v = read(), w = read();
add(u, v, w);
add(v, u, w);
}
DFS1(1, 0);
All[1] = Sub[1];
DFS2(1, 0);
Init();
Q = read();
for (register int i = 1; i <= Q; ++i) {
int u = read(), v = read();
cout << Query(u, v) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10, lg = 19, mod = 1e9 + 7;
long long n, q, cnt[N], down[N], up[N], up2[N], down2[N], high[N], dp[N][lg],
dis[N][lg];
pair<long long, long long> par[N];
vector<pair<long long, long long> > adj[N];
inline long long SUM(long long a, long long b) {
long long res = a + b;
while (res > mod) res -= mod;
while (res < 0) res += mod;
return res;
}
inline long long MUL(long long a, long long b) {
long long res = a * b;
res %= mod;
if (res < 0) res += mod;
return res;
}
void make_par(long long v, long long p, long long h) {
par[v].first = p;
high[v] = h;
cnt[v] = 1;
for (pair<long long, long long> i : adj[v])
if (i.first != p) {
par[i.first].second = i.second;
make_par(i.first, v, h + 1);
cnt[v] += cnt[i.first];
}
}
void make_down(long long v) {
for (pair<long long, long long> i : adj[v]) {
long long u = i.first, w = i.second;
if (u != par[v].first) {
make_down(u);
down[v] = SUM(down[v], SUM(MUL(cnt[u], w), down[u]));
}
}
}
void make_down2(long long v) {
for (pair<long long, long long> i : adj[v]) {
long long u = i.first, w = i.second;
if (u != par[v].first) {
make_down2(u);
down2[v] = SUM(down2[v], SUM(MUL(MUL(w, w), cnt[u]),
SUM(MUL(2 * w, down[u]), down2[u])));
}
}
}
void make_up(long long v) {
if (v) {
long long p = par[v].first;
up[v] =
SUM(SUM(up[p], SUM(down[p], -SUM(down[v], MUL(cnt[v], par[v].second)))),
MUL(SUM(n, -cnt[v]), par[v].second));
}
for (pair<long long, long long> i : adj[v])
if (i.first != par[v].first) make_up(i.first);
}
void make_up2(long long v) {
if (v) {
long long p = par[v].first;
long long w = par[v].second;
long long tmp = SUM(SUM(down[p], -down[v]), -MUL(cnt[v], w));
up2[v] = SUM(SUM(up2[p], MUL(MUL((n - cnt[p]), w), w)), MUL(2 * w, up[p]));
up2[v] =
SUM(up2[v],
SUM(SUM(SUM(SUM(SUM(down2[p], -down2[v]), -MUL(MUL(w, w), cnt[v])),
-MUL(2 * w, down[v])),
MUL(MUL(w, w), (cnt[p] - cnt[v]))),
MUL(2 * w, tmp)));
}
for (pair<long long, long long> i : adj[v])
if (i.first != par[v].first) make_up2(i.first);
}
long long go_up(long long v, long long dis) {
long long u = 0;
while (dis) {
if (dis & 1) v = dp[v][u];
u++;
dis /= 2;
}
return v;
}
long long LCA(long long v, long long u) {
if (high[v] < high[u]) swap(v, u);
v = go_up(v, high[v] - high[u]);
if (v == u) return v;
for (long long i = lg - 1; i >= 0; i--)
if (dp[v][i] != dp[u][i]) {
v = dp[v][i];
u = dp[u][i];
}
return par[v].first;
}
long long get_dis(long long v, long long d) {
long long res = 0, u = 0;
while (d) {
if (d & 1) res = SUM(res, dis[v][u]), v = dp[v][u];
u++;
d /= 2;
}
return res;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i < n; i++) {
long long v, u, w;
cin >> v >> u >> w;
v--;
u--;
adj[v].push_back({u, w});
adj[u].push_back({v, w});
}
make_par(0, 0, 0);
make_down(0);
make_down2(0);
make_up(0);
make_up2(0);
for (long long i = 0; i < n; i++) dp[i][0] = par[i].first;
for (long long j = 1; j < lg; j++)
for (long long i = 0; i < n; i++) dp[i][j] = dp[dp[i][j - 1]][j - 1];
for (long long i = 0; i < n; i++) dis[i][0] = par[i].second;
for (long long j = 1; j < lg; j++)
for (long long i = 0; i < n; i++)
dis[i][j] = dis[i][j - 1] + dis[dp[i][j - 1]][j - 1];
cin >> q;
for (long long i = 0; i < q; i++) {
long long u, v, p, w;
cin >> u >> v;
u--;
v--;
p = LCA(v, u);
w = get_dis(v, high[v] - high[p]) + get_dis(u, high[u] - high[p]);
if (p != v) {
long long S =
SUM(SUM(down2[v], MUL(MUL(cnt[v], w), w)), MUL(2 * w, down[v]));
long long S2 = SUM(SUM(up2[u], down2[u]), -S);
long long res = SUM(S, -S2);
cout << res << '\n';
} else {
long long S = SUM(SUM(SUM(SUM(down2[u], up2[u]), -up2[v]),
-MUL(MUL(SUM(n, -cnt[v]), w), w)),
-MUL(2 * w, up[v]));
long long S2 = SUM(SUM(up2[u], down2[u]), -S);
long long res = SUM(S, -S2);
cout << res << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int e[100005 * 2], h[100005], pre[100005 * 2], cou;
long long d[100005 * 2];
inline void Addedge(int from, int to, int ds) {
cou++;
e[cou] = to, d[cou] = ds;
pre[cou] = h[from];
h[from] = cou;
}
int fa[100005][20], dep[100005], maxd, lg;
int n;
void initlca() {
int i, j;
lg = 18;
for (j = 1; j <= lg; j++)
for (i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
inline int lca(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
int i;
for (i = lg; i >= 0; i--)
if (dep[fa[v][i]] >= dep[u]) v = fa[v][i];
if (u == v) return u;
for (i = lg; i >= 0; i--)
if (fa[v][i] != fa[u][i]) u = fa[u][i], v = fa[v][i];
return fa[v][0];
}
long long up[100005], dn[100005], su[100005], sd[100005], dis[100005],
sz[100005], s1[100005], s2[100005];
inline long long cal(long long a, long long b, long long c, long long d) {
return (a + 2 * b * c + c * c % 1000000007 * d) % 1000000007;
}
void dfs1(int x) {
int i, v;
for (i = h[x]; i; i = pre[i]) {
v = e[i];
if (fa[x][0] != v) {
fa[v][0] = x;
dis[v] = (dis[x] + d[i]) % 1000000007;
dep[v] = dep[x] + 1;
dfs1(v);
sz[x] += sz[v];
sd[x] = (sd[x] + sd[v] + sz[v] * d[i]) % 1000000007;
dn[x] = (dn[x] + cal(dn[v], sd[v], d[i], sz[v])) % 1000000007;
}
}
sz[x]++;
}
void dfs2(int x) {
int i, v;
s1[x] = (up[x] + dn[x]) % 1000000007;
s2[x] = (su[x] + sd[x]) % 1000000007;
for (i = h[x]; i; i = pre[i]) {
v = e[i];
if (fa[x][0] != v) {
su[v] = ((s2[x] - sd[v] - sz[v] * d[i]) % 1000000007 + 1000000007) %
1000000007;
up[v] = cal(
((s1[x] - cal(dn[v], sd[v], d[i], sz[v])) % 1000000007 + 1000000007) %
1000000007,
su[v], d[i], n - sz[v]);
su[v] = (su[v] + d[i] * (n - sz[v])) % 1000000007;
dfs2(v);
}
}
}
int main() {
int i, t1, t2, t3, q;
long long ds, ans;
cin >> n;
for (i = 1; i < n; i++) {
scanf("%d%d%d", &t1, &t2, &t3);
Addedge(t1, t2, t3);
Addedge(t2, t1, t3);
}
dep[1] = 1, fa[1][0] = 1;
dfs1(1);
dfs2(1);
initlca();
cin >> q;
while (q--) {
scanf("%d%d", &t1, &t2);
t3 = lca(t1, t2);
if (t3 != t2) {
ds = ((dis[t1] - dis[t3] + dis[t2] - dis[t3]) + 1000000007) % 1000000007;
ans = ((s1[t1] - 2 * cal(dn[t2], sd[t2], ds, sz[t2])) + 1000000007) %
1000000007;
printf("%I64d\n", (-ans + 1000000007) % 1000000007);
} else {
ds = (dis[t1] - dis[t2] + 1000000007) % 1000000007;
ans = ((cal(up[t2], su[t2], ds, n - sz[t2]) * 2 - s1[t1]) + 1000000007) %
1000000007;
printf("%I64d\n", (-ans + 1000000007) % 1000000007);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, y, z, num;
const int MAXN = 100005;
const int mod = 1e9 + 7;
int b[MAXN];
int nxt[2 * MAXN], cost[2 * MAXN], a[2 * MAXN];
int fa[MAXN][25];
int be[MAXN], en[MAXN];
long long sum, len, m, dep[MAXN];
int dist[MAXN], sumx[MAXN];
int ans, ans1, ans2;
int sum1[MAXN], sum2[MAXN], siz1[MAXN], siz2[MAXN], sum21[MAXN], sum22[MAXN];
void add(int x, int y, int z) {
++num;
a[num] = y;
nxt[num] = b[x];
cost[num] = z;
b[x] = num;
}
int lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
for (int i = 20; i >= 0; --i) {
if ((1 << i) & (dep[y] - dep[x])) y = fa[y][i];
}
if (x == y) return x;
for (int i = 20; i >= 0; --i) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
void dfs(int x, int ga) {
++sum;
be[x] = sum;
fa[x][0] = ga;
dep[x] = dep[ga] + 1;
for (int i = 1; i <= 20; ++i) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = b[x]; i != 0; i = nxt[i]) {
int y = a[i];
if (y == ga) continue;
dist[y] = dist[x] + cost[i];
dist[y] %= mod;
dfs(y, x);
}
en[x] = sum;
}
void worksub(int x) {
int dq;
siz1[x] = 1;
sum1[x] = 0;
sum21[x] = 0;
for (int i = b[x]; i != 0; i = nxt[i]) {
int y = a[i];
if (y == fa[x][0]) continue;
worksub(y);
dq = sum21[y];
dq += 2LL * cost[i] * sum1[y] % mod;
dq %= mod;
dq += 1LL * cost[i] * cost[i] % mod * siz1[y] % mod;
dq %= mod;
sum21[x] += dq;
sum21[x] %= mod;
sum1[x] += sum1[y];
sum1[x] %= mod;
sum1[x] += 1LL * cost[i] * siz1[y] % mod;
sum1[x] %= mod;
siz1[x] += siz1[y];
siz1[x] %= mod;
}
}
void workout(int x) {
int dq;
for (int i = b[x]; i != 0; i = nxt[i]) {
int y = a[i];
if (y == fa[x][0]) continue;
siz2[y] = siz2[x] + siz1[x] - siz1[y];
sum2[y] =
sum2[x] +
(sum1[x] - sum1[y] + mod - 1LL * siz1[y] * cost[i] % mod + mod) % mod;
sum2[y] %= mod;
sum2[y] += 1LL * cost[i] * siz2[x] % mod;
sum2[y] %= mod;
sum2[y] += 1LL * cost[i] * (siz1[x] - siz1[y]) % mod;
sum2[y] %= mod;
sum22[y] = sum22[x];
sum22[y] += 1LL * cost[i] * cost[i] % mod * siz2[x] % mod;
sum22[y] %= mod;
sum22[y] += 2LL * cost[i] * sum2[x] % mod;
sum22[y] %= mod;
sum22[y] += sum21[x];
sum22[y] %= mod;
sum22[y] = (sum22[y] - sum21[y] + mod) % mod;
sum22[y] =
(sum22[y] - 1LL * cost[i] * cost[i] % mod * siz1[y] % mod + mod) % mod;
sum22[y] = (sum22[y] - 2LL * cost[i] * sum1[y] % mod + mod) % mod;
sum22[y] =
(sum22[y] + 1LL * cost[i] * cost[i] % mod * (siz1[x] - siz1[y]) % mod) %
mod;
sum22[y] = (sum22[y] + 2LL * cost[i] *
(sum1[x] - sum1[y] + mod -
1LL * siz1[y] * cost[i] % mod + mod) %
mod) %
mod;
workout(y);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
add(y, x, z);
}
dfs(1, 0);
worksub(1);
workout(1);
for (int i = 1; i <= n; ++i) sumx[i] = (sum21[i] + sum22[i]) % mod;
scanf("%d", &m);
while (m--) {
scanf("%d%d", &x, &y);
if (be[x] >= be[y] && be[x] <= en[y]) {
ans = sum22[y];
len = dist[x] - dist[y] + mod;
len %= mod;
ans += 1LL * len * len % mod * siz2[y] % mod;
ans %= mod;
ans += 2LL * len * sum2[y] % mod;
ans %= mod;
ans1 = sumx[x] - ans + mod;
ans1 %= mod;
ans2 = ans;
ans = ans1 - ans2 + mod;
ans %= mod;
} else {
ans = sum21[y];
z = lca(x, y);
len = dist[x] - dist[z];
len = (len + mod) % mod;
len += dist[y] - dist[z];
len = (len + mod) % mod;
ans += 1LL * len * len % mod * siz1[y] % mod;
ans %= mod;
ans += 2LL * len * sum1[y] % mod;
ans %= mod;
ans1 = ans;
ans2 = sumx[x] - ans + mod;
ans2 %= mod;
ans = ans1 - ans2 + mod;
ans %= mod;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, LOG = 20;
const long long mod = 1e9 + 7;
int n, q, st[N], fn[N], up[N][LOG], h[N], timer, idx[N];
vector<pair<int, int> > adj[N];
long long dp[N][2], sz[N][2], sum[N][2], d[N];
int add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
int mult(int a, int b) {
int ret = (1LL * a * b) % mod;
return add(ret, 0);
}
void dfs_down(int v, int p = -1) {
for (auto e : adj[v]) {
int u = e.first, w = e.second;
if (u == p) continue;
dfs_down(u, v);
dp[v][0] = add(dp[v][0], add(dp[u][0], add(mult(sz[u][0], mult(w, w)),
mult(2, mult(w, sum[u][0])))));
sum[v][0] = add(sum[v][0], add(sum[u][0], mult(w, sz[u][0])));
sz[v][0] += sz[u][0];
}
for (auto e : adj[v]) {
int u = e.first, w = e.second;
if (u == p) continue;
int val = add(dp[u][0],
add(mult(sz[u][0], mult(w, w)), mult(2, mult(w, sum[u][0]))));
int tmp = add(sum[u][0], mult(w, sz[u][0]));
dp[u][1] =
add(add(dp[v][0], -val), add(mult(w, mult(w, (sz[v][0] - sz[u][0]))),
mult(2, mult(w, add(sum[v][0], -tmp)))));
sum[u][1] = add(mult(w, sz[v][0] - sz[u][0]), add(sum[v][0], -tmp));
}
sz[v][0]++;
}
void dfs_up(int v, int p = -1) {
sz[v][1] = n + 1 - sz[v][0];
for (auto e : adj[v]) {
int u = e.first, w = e.second;
if (u == p) continue;
dp[u][1] = add(dp[u][1], add(dp[v][1], add(mult(sz[v][1], mult(w, w)),
mult(2, mult(w, sum[v][1])))));
sum[u][1] = add(sum[u][1], add(sum[v][1], mult(w, sz[v][1])));
dfs_up(u, v);
}
}
void setup(int v, int p = -1) {
st[v] = timer++;
idx[st[v]] = v;
for (int i = 1; i < LOG; i++) up[v][i] = up[up[v][i - 1]][i - 1];
for (auto e : adj[v]) {
int u = e.first, w = e.second;
if (u ^ p) d[u] = add(d[v], w), up[u][0] = v, h[u] = h[v] + 1, setup(u, v);
}
fn[v] = timer;
}
bool is_ancestor(int v, int u) { return (st[v] <= st[u]) && (fn[u] <= fn[v]); }
int lca(int v, int u) {
if (h[v] < h[u]) swap(v, u);
for (int i = LOG - 1; ~i; i--)
if (h[up[v][i]] >= h[u]) v = up[v][i];
if (v == u) return v;
for (int i = LOG - 1; ~i; i--)
if (up[v][i] != up[u][i]) v = up[v][i], u = up[u][i];
return up[v][0];
}
int dist(int v, int u) { return add(d[v], add(d[u], -mult(2, d[lca(v, u)]))); }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u, w;
cin >> v >> u >> w;
v--, u--;
adj[v].push_back({u, w});
adj[u].push_back({v, w});
}
dfs_down(0);
dfs_up(0);
setup(0);
cin >> q;
while (q--) {
int v, u;
cin >> v >> u;
v--, u--;
long long res = 0, w = dist(v, u);
if (!is_ancestor(u, v)) {
res = mult(-1, add(dp[v][0], dp[v][1]));
res = add(res, mult(2, add(mult(mult(w, w), sz[u][0]),
add(dp[u][0], mult(2, mult(w, sum[u][0]))))));
} else {
res = add(res, add(dp[v][0], dp[v][1]));
res = add(res, -mult(2, add(dp[u][1], add(mult(sz[u][1] - 1, mult(w, w)),
mult(sum[u][1], mult(2, w))))));
}
cout << res << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool maxit(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool minit(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline long long gint() {
char c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') {
f = -1;
}
c = getchar();
}
long long a = c - '0';
while ((c = getchar()) >= '0' && c <= '9') {
a = a * 10 + c - '0';
}
return a * f;
}
const int maxn = 100010, MOD = int(1e9 + 7);
int head[maxn], en[maxn << 1], nxt[maxn << 1], pri[maxn << 1], tot;
inline void add(int u, int v, int w) {
en[++tot] = v;
nxt[tot] = head[u];
head[u] = tot;
pri[tot] = w;
}
int n;
struct SegTree {
int A[maxn], sum1[maxn << 2], sum2[maxn << 2], add[maxn << 2];
inline void up(int s) {
sum1[s] = (sum1[s << 1] + sum1[s << 1 | 1]) % MOD;
sum2[s] = (sum2[s << 1] + sum2[s << 1 | 1]) % MOD;
}
void build(int s, int l, int r) {
if (l == r) {
sum1[s] = A[l];
sum2[s] = (long long)A[l] * A[l] % MOD;
return;
}
int mid = (l + r) >> 1;
build(s << 1, l, mid);
build(s << 1 | 1, mid + 1, r);
up(s);
}
int ql, qr, val;
inline void inc(int s, int l, int r, int val) {
add[s] = (add[s] + val) % MOD;
sum2[s] = (sum2[s] + 2LL * val * sum1[s] % MOD +
(r - l + 1LL) * val % MOD * val % MOD) %
MOD;
sum1[s] = (sum1[s] + (r - l + 1LL) * val) % MOD;
}
inline void down(int s, int l, int r) {
if (add[s]) {
int mid = (l + r) >> 1;
inc(s << 1, l, mid, add[s]);
inc(s << 1 | 1, mid + 1, r, add[s]);
add[s] = 0;
}
}
void update(int s, int l, int r) {
if (ql <= l && r <= qr) {
inc(s, l, r, val);
return;
}
down(s, l, r);
int mid = (l + r) >> 1;
if (ql <= mid) {
update(s << 1, l, mid);
}
if (mid < qr) {
update(s << 1 | 1, mid + 1, r);
}
up(s);
}
void query(int s, int l, int r) {
if (ql <= l && r <= qr) {
val = (val + sum2[s]) % MOD;
return;
}
down(s, l, r);
int mid = (l + r) >> 1;
if (ql <= mid) {
query(s << 1, l, mid);
}
if (mid < qr) {
query(s << 1 | 1, mid + 1, r);
}
}
int range(int ql, int qr) {
if (ql > qr) {
return 0;
}
this->ql = ql;
this->qr = qr;
val = 0;
query(1, 1, n);
return val;
}
void change(int ql, int qr, int val) {
if (ql > qr) {
return;
}
this->ql = ql;
this->qr = qr;
this->val = val;
update(1, 1, n);
}
} seg;
int ls[maxn], le[maxn], dfs_clock;
int dis[maxn];
vector<pair<int, int> > Q[maxn];
int ans[maxn];
inline void moveroot(int u, int v, int w) {
seg.change(ls[v], le[v], MOD - w);
seg.change(1, ls[v] - 1, w);
seg.change(le[v] + 1, n, w);
}
void dfstwo(int u, int fa) {
int ALL = seg.range(1, n);
for (typeof((Q[u]).begin()) it = (Q[u]).begin(), _end_ = (Q[u]).end();
it != _end_; ++it) {
int v = it->first;
ans[it->second] = (seg.range(ls[v], le[v]) * 2LL - ALL + MOD) % MOD;
}
for (int k = head[u]; k; k = nxt[k]) {
int v = en[k];
if (v == fa) continue;
moveroot(u, v, pri[k]);
dfstwo(v, u);
moveroot(u, v, MOD - pri[k]);
}
}
void dfs(int u, int fa) {
ls[u] = ++dfs_clock;
for (int k = head[u]; k; k = nxt[k]) {
int v = en[k];
if (v == fa) continue;
dis[v] = (dis[u] + pri[k]) % MOD;
dfs(v, u);
}
le[u] = dfs_clock;
}
int q;
int main() {
n = gint();
for (int i = 1; i < n; i++) {
int u = gint(), v = gint(), w = gint();
add(u, v, w);
add(v, u, w);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
seg.A[ls[i]] = dis[i];
}
seg.build(1, 1, n);
q = gint();
for (int i = 0; i < q; i++) {
int u = gint(), v = gint();
Q[u].push_back(make_pair(v, i));
}
dfstwo(1, 0);
for (int i = 0; i < q; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 100005, LG = 20;
const long long MOD = 1000000000 + 7;
vector<pair<int, int> > G[MN];
long long pod[MN], sumaPod[MN], resPod[MN], res[MN], D[MN], suma[MN];
long long sumaAll;
int dp[LG][MN], used[MN], pre[MN], post[MN];
int cnt;
int n;
void ala(int x, long long xd) {
D[x] = xd;
pod[x] = 1;
pre[x] = ++cnt;
int s = G[x].size();
for (int i = 0; i < s; ++i) {
if (!pod[G[x][i].first]) {
dp[0][G[x][i].first] = x;
ala(G[x][i].first, xd + G[x][i].second);
long long ck = G[x][i].second;
pod[x] += pod[G[x][i].first];
sumaPod[x] += (sumaPod[G[x][i].first] + ck * pod[G[x][i].first]);
sumaPod[x] %= MOD;
resPod[x] += (resPod[G[x][i].first] +
((G[x][i].second * sumaPod[G[x][i].first]) << 1) +
((ck * ck) % MOD) * pod[G[x][i].first]) %
MOD;
resPod[x] %= MOD;
}
}
post[x] = ++cnt;
}
void basia(int x, int p, long long c) {
used[x] = 1;
int s = G[x].size();
if (p) {
suma[x] =
(suma[p] + (((((long long)(n - (pod[x] << 1))) * c) % MOD) + MOD)) %
MOD;
res[x] = (res[p] -
(resPod[x] + (((c * sumaPod[x]) << 1) % MOD) +
((((c * c) % MOD) * pod[x]) % MOD)) +
MOD) %
MOD;
res[x] =
(resPod[x] +
((((res[x] +
(((c * (suma[p] - sumaPod[x] - ((c * (pod[x])) % MOD))) << 1) %
MOD) +
(((c * c) % MOD) * ((long long)(n - pod[x]))) % MOD) %
MOD) +
MOD) %
MOD)) %
MOD;
} else {
res[x] = resPod[x];
suma[x] = sumaPod[x];
}
for (int i = 0; i < s; ++i) {
if (!used[G[x][i].first])
basia(G[x][i].first, x, (long long)G[x][i].second);
}
}
bool child(int x, int y) { return (pre[x] >= pre[y] && post[x] <= post[y]); }
int lca(int x, int y) {
if (child(x, y)) return y;
if (child(y, x)) return x;
int s = LG - 1;
while (s >= 0) {
if (child(y, dp[s][x]))
--s;
else
x = dp[s][x];
}
x = dp[0][x];
return x;
}
long long d(int x, int y) { return D[x] + D[y] - ((D[lca(x, y)]) << 1); }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
G[a].push_back(make_pair(b, c));
G[b].push_back(make_pair(a, c));
sumaAll += c;
sumaAll %= MOD;
}
ala(1, 0LL);
basia(1, 0, 0LL);
dp[0][1] = 1;
for (int i = 1; i < LG; ++i)
for (int j = 1; j <= n; ++j) dp[i][j] = dp[i - 1][dp[i - 1][j]];
int q;
scanf("%d", &q);
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
long long x = d(a, b);
x %= MOD;
long long wynik;
if (child(a, b)) {
wynik =
((res[a] - (res[b] - resPod[b] + ((x * (suma[b] - sumaPod[b])) << 1) +
(((x * x) % MOD) * ((long long)((long long)n - pod[b])))))
<< 1) %
MOD -
res[a] + MOD;
wynik = ((wynik % MOD) + MOD) % MOD;
} else {
wynik =
((resPod[b] + ((sumaPod[b] * x) << 1) + (((x * x) % MOD) * pod[b]))
<< 1);
wynik = ((wynik % MOD) - res[a] + MOD) % MOD;
}
printf("%I64d\n", wynik);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 100;
const long long mod = 1e9 + 7;
long long sum1[maxn], sum2[maxn], size[maxn];
long long dfn[maxn], dfncnt, f[maxn][20], d[maxn][20], n, dep[maxn];
vector<long long> side[maxn], w[maxn];
long long trans(long long u, long long val) {
return (sum2[u] + size[u] * val % mod * val % mod + 2 * val * sum1[u] % mod) %
mod;
}
void dfs1(long long u, long long fa) {
f[u][0] = fa;
dfn[u] = ++dfncnt;
size[u] = 1;
dep[u] = dep[fa] + 1;
for (long long i = 0; i < side[u].size(); i++) {
long long v = side[u][i];
if (v == fa) continue;
dfs1(v, u);
size[u] += size[v];
d[v][0] = w[u][i];
sum1[u] = (sum1[u] + sum1[v] + w[u][i] * size[v] % mod) % mod;
sum2[u] = (sum2[u] + trans(v, w[u][i])) % mod;
}
}
void init() {
for (long long i = (1), iend = (19); i <= iend; i++)
for (long long j = (1), jend = (n); j <= jend; j++)
f[j][i] = f[f[j][i - 1]][i - 1];
for (long long i = (1), iend = (19); i <= iend; i++)
for (long long j = (1), jend = (n); j <= jend; j++)
d[j][i] = (d[j][i - 1] + d[f[j][i - 1]][i - 1]) % mod;
}
long long get_dis(long long u, long long v) {
long long ans = 0;
if (dep[u] < dep[v]) swap(u, v);
for (long long i = 19; i >= 0; i--)
if (dep[f[u][i]] >= dep[v]) ans = (ans + d[u][i]) % mod, u = f[u][i];
if (u == v) return ans;
for (long long i = 19; i >= 0; i--)
if (f[u][i] != f[v][i])
ans = (1ll * ans + d[u][i] + d[v][i]) % mod, u = f[u][i], v = f[v][i];
return (1ll * ans + d[u][0] + d[v][0]) % mod;
}
struct Query {
long long u, v, idx;
bool insubtree;
} q[maxn];
long long ans[maxn];
bool cmp(Query a, Query b) { return dfn[a.u] < dfn[b.u]; }
long long now = 1, t;
void dfs2(long long u, long long fa) {
while (now <= t && q[now].u == u) {
long long v = q[now].v, idx = q[now].idx;
if (q[now].insubtree) {
ans[idx] = (sum2[u] - 2 * trans(f[v][0], get_dis(f[v][0], u))) % mod;
ans[idx] = (ans[idx] + mod) % mod;
} else {
ans[idx] = (2 * trans(v, get_dis(u, v)) - sum2[u]) % mod;
ans[idx] = (ans[idx] + mod) % mod;
}
now++;
}
for (long long i = 0; i < side[u].size(); i++) {
long long v = side[u][i];
if (v == fa) continue;
long long bku1 = sum1[u], bku2 = sum2[u], bku3 = size[u];
long long bkv1 = sum1[v], bkv2 = sum2[v], bkv3 = size[v];
long long tmp1 = trans(v, w[u][i]),
tmp2 = trans(u, w[u][i]) - trans(v, 2 * w[u][i]);
tmp2 = (tmp2 % mod + mod) % mod;
sum1[u] = (bku1 - (bkv1 + w[u][i] * bkv3) % mod) % mod;
sum1[u] = (sum1[u] % mod + mod) % mod;
sum1[v] = ((bku1 - (bkv1 + w[u][i] * bkv3) % mod) +
(bku3 - bkv3) * w[u][i] % mod + bkv1) %
mod;
sum1[v] = (sum1[v] % mod + mod) % mod;
sum2[u] = (bku2 - tmp1) % mod;
sum2[u] = (sum2[u] % mod + mod) % mod;
sum2[v] = tmp2 + bkv2;
sum2[v] = (sum2[v] % mod + mod) % mod;
size[u] = bku3 - bkv3;
size[v] = bku3;
dfs2(v, u);
sum1[u] = bku1, sum2[u] = bku2, size[u] = bku3;
sum1[v] = bkv1, sum2[v] = bkv2, size[v] = bkv3;
}
}
signed main() {
ios::sync_with_stdio(0);
cin >> n;
for (long long i = (1), iend = (n - 1); i <= iend; i++) {
long long u, v, val;
cin >> u >> v >> val;
side[u].push_back(v);
w[u].push_back(val);
side[v].push_back(u);
w[v].push_back(val);
}
dfs1(1, 0);
init();
cin >> t;
for (long long i = (1), iend = (t); i <= iend; i++) {
cin >> q[i].u >> q[i].v;
q[i].idx = i;
if (dfn[q[i].v] <= dfn[q[i].u] &&
dfn[q[i].u] <= dfn[q[i].v] + size[q[i].v] - 1)
q[i].insubtree = 1;
}
sort(q + 1, q + 1 + t, cmp);
dfs2(1, 0);
for (long long i = (1), iend = (t); i <= iend; i++) {
cout << (ans[i] % mod + mod) % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct nnn {
int adj, next;
long long c;
};
const long long modn = (long long)1000000007;
int n, m, tot, tt, tno;
int g[300000];
nnn addr[300000];
long long f[300000], fs[300000], s[300000], pc[300000], lq[300000], sdi[300000],
spc[300000];
int sn[300000], sf[300000], ss[300000], tr[700000], td[700000], v[300000];
void ins(int x, int y, long long c) {
tot++;
addr[tot].adj = y;
addr[tot].c = c;
addr[tot].next = g[x];
g[x] = tot;
}
void dfs(int d, int dep, long long dist) {
dep++;
tt++;
sn[tt] = d;
sf[d] = tt;
ss[tt] = dep;
fs[d] = 0, f[d] = 0, pc[d] = 1;
dist %= modn;
lq[d] = dist;
v[d] = 1;
for (int p = g[d]; p != -1; p = addr[p].next) {
if (v[p[addr].adj]) continue;
dfs(addr[p].adj, dep, dist + addr[p].c);
fs[d] += (fs[addr[p].adj] + (addr[p].c * pc[addr[p].adj]) % modn) % modn;
fs[d] %= modn;
pc[d] = (pc[d] + pc[addr[p].adj]) % modn;
f[d] += (f[addr[p].adj] +
(pc[addr[p].adj] * ((addr[p].c * addr[p].c) % modn)) % modn +
((long long)2) * ((addr[p].c * fs[addr[p].adj]) % modn)) %
modn;
f[d] %= modn;
tt++;
sn[tt] = d;
ss[tt] = dep;
}
}
void dfs2(int d, long long sum, long long ed, long long npc, long long ndi) {
long long a = npc, b = ndi;
if (d != 1) {
long long thi = (f[d] + (pc[d] * ((ed * ed) % modn)) % modn +
((long long)2) * ((ed * fs[d]) % modn)) %
modn;
sum = (sum + ((long long)20000000) * modn - thi) % modn;
npc -= pc[d];
ndi = (ndi + ((long long)20000000) * modn - fs[d] - (pc[d] * ed) % modn) %
modn;
thi = (sum + (npc * ((ed * ed) % modn)) % modn +
((long long)2) * ((ed * ndi) % modn)) %
modn;
s[d] = thi;
sdi[d] = (ndi + (npc * ed) % modn) % modn;
spc[d] = npc;
b = ((npc * ed) % modn + ndi + fs[d]) % modn;
} else {
s[d] = 0;
npc = pc[d];
ndi = fs[d];
sdi[d] = 0;
spc[d] = 0;
a = npc;
b = ndi;
}
v[d] = 1;
for (int p = g[d]; p != -1; p = addr[p].next) {
if (v[addr[p].adj]) continue;
dfs2(addr[p].adj, s[d] + f[d], addr[p].c, a, b);
}
}
void inst(int d, int l, int r, int x, int c) {
if (l > r) return;
if (l == r) {
tr[d] = c;
td[d] = sn[x];
return;
}
int o = (l + r) >> 1, ll = 2 * d, rr = 2 * d + 1;
if (x <= o)
inst(ll, l, o, x, c);
else
inst(rr, o + 1, r, x, c);
if (tr[ll] < tr[rr]) {
tr[d] = tr[ll];
td[d] = td[ll];
} else {
tr[d] = tr[rr];
td[d] = td[rr];
}
}
int mfind(int d, int l, int r, int x, int y, int *id) {
if (l > r) return 1000000007;
if (l == x && r == y) {
*id = td[d];
return tr[d];
}
int o = (l + r) >> 1, ll = 2 * d, rr = 2 * d + 1;
if (y <= o) {
return mfind(ll, l, o, x, y, id);
}
if (x > o) {
return mfind(rr, o + 1, r, x, y, id);
}
int lid, rid;
int lp = mfind(ll, l, o, x, o, &lid),
rp = mfind(rr, o + 1, r, o + 1, y, &rid);
if (lp < rp) {
*id = lid;
return lp;
} else {
*id = rid;
return rp;
}
}
int main() {
int tn;
int ti, i, j, k, o;
int a, b;
double c, d;
scanf("%d", &n);
{
memset(g, -1, sizeof(g));
tot = 0;
for (i = 0; i < n - 1; i++) {
scanf("%d%d%d", &a, &b, &k);
ins(a, b, k);
ins(b, a, k);
}
tt = 0;
memset(v, 0, sizeof(v));
dfs(1, 0, 0);
memset(v, 0, sizeof(v));
dfs2(1, 0, 0, 0, 0);
for (i = 1; i <= tt; i++) {
inst(1, 1, tt, i, ss[i]);
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
mfind(1, 1, tt, (((sf[a]) < (sf[b])) ? (sf[a]) : (sf[b])),
max(sf[a], sf[b]), &k);
long long dd = (lq[a] + lq[b] + ((long long)20000000) * modn -
((long long)2) * lq[k]) %
modn;
if (k != b) {
long long temp = (f[b] + ((long long)2) * ((dd * fs[b]) % modn) +
((dd * dd) % modn * pc[b]) % modn) %
modn;
long long ans = (((long long)20000000) * modn - s[a] - f[a] +
((long long)2) * temp) %
modn;
printf("%I64d\n", ans);
if (ans == 48911997) printf("%d %d %d\n", a, b, k);
} else {
long long temp = (s[b] + ((long long)2) * ((dd * sdi[b]) % modn) +
((dd * dd) % modn * spc[b]) % modn) %
modn;
long long ans = (s[a] + f[a] + ((long long)20000000) * modn -
((long long)2) * temp) %
modn;
printf("%I64d\n", ans);
if (ans == 48911997) printf("%d %d %d\n", a, b, k);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace FGF {
long long n, m;
const int N = 1e5 + 5;
const int mo = 1e9 + 7;
long long fa[N][25], dep[N], dis[N], siz[N], sumd[N], sums[N], sq[N], d[N], ans;
int head[N], cnt;
struct edg {
int to, nxt;
long long w;
} e[N << 1];
void add(int u, int v, int w) {
cnt++;
e[cnt].to = v;
e[cnt].nxt = head[u];
head[u] = cnt;
e[cnt].w = w;
}
void dfs1(int u, int f) {
siz[u] = 1, dep[u] = dep[f] + 1, fa[u][0] = f;
for (int i = 1; i <= 18; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v != f) {
d[v] = (d[u] + e[i].w) % mo;
dfs1(v, u);
dis[u] = (dis[u] + (e[i].w * siz[v] % mo + dis[v]) % mo) % mo;
sq[u] = ((sq[u] + sq[v]) % mo + 2LL * e[i].w % mo * dis[v] % mo +
siz[v] * e[i].w % mo * e[i].w % mo) %
mo;
siz[u] += siz[v];
}
}
}
void dfs2(int u, int f) {
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v != f) {
long long sd = (sq[v] + 2LL * e[i].w % mo * dis[v] % mo +
siz[v] * e[i].w % mo * e[i].w % mo) %
mo;
long long d = (sumd[u] - dis[v] - siz[v] * e[i].w % mo + mo) % mo;
sums[v] = ((sums[u] - sd + 2LL * d * e[i].w % mo +
(n - siz[v]) * e[i].w % mo * e[i].w + sq[v]) %
mo +
mo) %
mo;
sumd[v] = (d + (n - siz[v]) * e[i].w % mo + dis[v]) % mo;
dfs2(v, u);
}
}
}
int getlca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int d = dep[u] - dep[v];
for (int i = 18; i >= 0; i--)
if (d & (1 << i)) u = fa[u][i];
if (u == v) return u;
for (int i = 18; i >= 0; i--)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
void work() {
scanf("%lld", &n);
int u, v, w;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w), add(v, u, w);
}
dfs1(1, 0);
sumd[1] = dis[1], sums[1] = sq[1];
dfs2(1, 0);
scanf("%lld", &m);
while (m--) {
scanf("%d%d", &u, &v);
int lca = getlca(u, v);
long long disuv = ((d[u] + d[v] - 2 * d[lca]) % mo + mo) % mo;
if (lca != v) {
long long suv =
(sq[v] + 2 * dis[v] * disuv % mo + siz[v] * disuv % mo * disuv % mo) %
mo;
ans = (2 * suv - sums[u] + mo) % mo;
} else {
long long outvs = (sums[v] - sq[v] + mo) % mo, outvd = sumd[v] - dis[v];
long long outs = (outvs + (n - siz[v]) * disuv % mo * disuv % mo +
2 * disuv * outvd % mo) %
mo;
ans = ((sums[u] - outs - outs) % mo + mo) % mo;
}
printf("%lld\n", ans);
}
}
} // namespace FGF
int main() {
FGF::work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
int fst[(200000 + 20)], vv[(400000 + 10)], nxt[(400000 + 10)],
cost[(400000 + 10)], e;
int n;
void init() {
memset(fst, -1, sizeof fst);
e = 0;
}
void add(int u, int v, int w) {
vv[e] = v, cost[e] = w, nxt[e] = fst[u], fst[u] = e++;
}
int dep[(200000 + 20)], s[(200000 + 20)], f[(200000 + 20)], ss[(200000 + 20)],
fs[(200000 + 20)], sz[(200000 + 20)];
int dis[(200000 + 20)];
int fa[(200000 + 20)][30];
void add(int &u, int v) {
u += v;
if (u >= 1000000007) u -= 1000000007;
}
int update(int s, int ss, int dis, int sz) {
int ret = s;
add(ret, (long long)2 * dis * ss % 1000000007);
add(ret, (long long)sz * dis % 1000000007 * dis % 1000000007);
return ret;
}
void dfs1(int u, int p) {
fa[u][0] = p;
dep[u] = dep[p] + 1;
ss[u] = 0, s[u] = 0;
sz[u] = 1;
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i];
if (v == p) continue;
add(dis[v], (dis[u] + cost[i]) % 1000000007);
dfs1(v, u);
sz[u] += sz[v];
add(ss[u], ((long long)ss[v] + (long long)cost[i] * sz[v]) % 1000000007);
add(s[u], update(s[v], ss[v], cost[i], sz[v]));
}
}
void dfs2(int u, int p) {
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i];
if (v == p) continue;
int tmp = ((long long)ss[v] + (long long)cost[i] * sz[v]) % 1000000007;
tmp = (1LL * ss[u] - tmp + 1000000007) % 1000000007;
add(tmp, fs[u]);
add(fs[v],
((long long)tmp + (long long)cost[i] * (n - sz[v]) % 1000000007) %
1000000007);
int tmp2 =
(1LL * f[u] + s[u] - update(s[v], ss[v], cost[i], sz[v])) % 1000000007;
tmp2 = (tmp2 + 1000000007) % 1000000007;
add(f[v], update(tmp2, tmp, cost[i], n - sz[v]));
dfs2(v, u);
}
}
void lca_init() {
for (int i = 1; i <= 20; ++i) {
for (int j = 1; j <= n; ++j) {
fa[j][i] = fa[fa[j][i - 1]][i - 1];
}
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int d = dep[u] - dep[v];
for (int j = 20; j >= 0; --j) {
if (d & (1 << j)) u = fa[u][j];
}
if (u == v) return u;
for (int j = 20; j >= 0; --j) {
if (fa[u][j] != fa[v][j]) u = fa[u][j], v = fa[v][j];
}
return fa[u][0];
}
void debug() {
for (int i = 1; i <= n; ++i) {
printf("i %d sz %d s %d ss %d f %d fs %d dis %d\n", i, sz[i], s[i], ss[i],
f[i], fs[i], dis[i]);
}
}
int main() {
scanf("%d", &n);
int u, v, w;
init();
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
dfs1(1, 0);
dfs2(1, 0);
lca_init();
int q;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &u, &v);
int p = lca(u, v);
if (p == u) {
int len = (dis[v] - dis[u] + 1000000007) % 1000000007;
int ans1 = update(s[v], ss[v], len, sz[v]);
int ans2 = (1LL * f[u] + s[u] - ans1) % 1000000007;
ans2 = (ans2 + 1000000007) % 1000000007;
add(ans1, 1000000007 - ans2);
printf("%d\n", ans1 % 1000000007);
} else if (p == v) {
int len = dis[u];
add(len, 1000000007 - dis[v]);
int ans2 = update(f[v], fs[v], len, n - sz[v]);
int ans1 = (1LL * f[u] + s[u] - ans2) % 1000000007;
ans1 = (ans1 + 1000000007) % 1000000007;
add(ans1, 1000000007 - ans2);
printf("%d\n", ans1 % 1000000007);
} else {
int len = dis[u];
add(len, dis[v]);
add(len, 1000000007 - (long long)2 * dis[p] % 1000000007);
int ans1 = update(s[v], ss[v], len, sz[v]);
int ans2 = (1LL * s[u] + f[u] - ans1) % 1000000007;
ans2 = (ans2 + 1000000007) % 1000000007;
add(ans1, 1000000007 - ans2);
printf("%d\n", ans1 % 1000000007);
}
}
}
|
#include <bits/stdc++.h>
const int MOD = (int)1e9 + 7;
const int N = 100000 + 5;
const int LOG = 18;
int inv(int x) {
if (x == 0) return 0;
return x == 1 ? 1 : (long long)(MOD - MOD / x) * inv(MOD % x) % MOD;
}
struct mod_int {
int x;
mod_int(int x_ = 0) : x(x_) {}
mod_int operator+(const mod_int &t) const {
mod_int ret(x + t.x);
if (ret.x >= MOD) ret.x -= MOD;
return ret;
}
mod_int operator-(const mod_int &t) const {
mod_int ret(x - t.x);
if (ret.x < 0) ret.x += MOD;
return ret;
}
mod_int operator*(const mod_int &t) const {
return mod_int((long long)x * t.x % MOD);
}
mod_int operator/(const mod_int &t) const {
return mod_int((long long)x * inv(t.x) % MOD);
}
mod_int operator+(int x) { return *this + mod_int(x); }
mod_int operator-(int x) { return *this - mod_int(x); }
mod_int operator*(int x) { return *this * mod_int(x); }
mod_int operator/(int x) { return *this / mod_int(x); }
};
mod_int A[N], B[N];
mod_int downA[N], downB[N];
mod_int sz[N];
std::vector<std::pair<int, int> > edges[N];
std::vector<std::pair<int, int> > queries[N];
int answer[N], n, m;
bool is_ancestor[N];
mod_int dis[N];
int depth[N], plca[LOG][N];
void prepare(int u, int fa) {
if (fa != -1) depth[u] = depth[fa] + 1;
plca[0][u] = fa;
for (int i = 1; i < LOG; ++i) {
plca[i][u] = -1;
if (plca[i - 1][u] != -1) plca[i][u] = plca[i - 1][plca[i - 1][u]];
}
sz[u] = mod_int(1);
for (std::pair<int, int> t : edges[u]) {
int v = t.first;
int w = t.second;
if (v == fa) continue;
dis[v] = dis[u] + w;
prepare(v, u);
sz[u] = sz[u] + sz[v];
A[u] = A[u] + A[v] + B[v] * 2 * w + sz[v] * w * w;
B[u] = B[u] + B[v] + sz[v] * w;
}
}
int jump(int u, int d) {
for (int i = 0; i < LOG; ++i)
if (d >> i & 1) u = plca[i][u];
return u;
}
int lca(int a, int b) {
if (depth[a] < depth[b]) std::swap(a, b);
a = jump(a, depth[a] - depth[b]);
if (a == b) return a;
for (int i = LOG - 1; i >= 0; --i) {
if (plca[i][a] != plca[i][b]) {
a = plca[i][a];
b = plca[i][b];
}
}
return plca[0][a];
}
mod_int get_dis(int a, int b) { return dis[a] + dis[b] - dis[lca(a, b)] * 2; }
void solve(int u, int fa) {
is_ancestor[u] = true;
for (std::pair<int, int> t : edges[u]) {
int v = t.first;
int w = t.second;
if (v == fa) continue;
mod_int a, b;
a = A[v] + B[v] * 2 * w + sz[v] * w * w;
b = B[v] + sz[v] * w;
downA[v] = downA[u] + A[u] - a;
downB[v] = downB[u] + B[u] - b;
downA[v] = downA[v] + downB[v] * 2 * w + (sz[0] - sz[v]) * w * w;
downB[v] = downB[v] + (sz[0] - sz[v]) * w;
solve(v, u);
}
for (std::pair<int, int> t : queries[u]) {
int v = t.first;
int id = t.second;
if (!is_ancestor[v]) {
mod_int a = A[v];
mod_int b = B[v];
mod_int w = get_dis(u, v);
a = a + b * 2 * w + sz[v] * w * w;
b = b + sz[v] * w;
answer[id] = (a - (downA[u] + A[u] - a)).x;
} else if (u != v) {
mod_int a = downA[v];
mod_int b = downB[v];
mod_int w = get_dis(u, v);
a = a + b * 2 * w + (sz[0] - sz[v]) * w * w;
b = b + (sz[0] - sz[v]) * w;
answer[id] = (downA[u] + A[u] - a * 2).x;
} else {
answer[id] = (A[u] - downA[u]).x;
}
}
is_ancestor[u] = false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
edges[a].push_back(std::make_pair(b, c));
edges[b].push_back(std::make_pair(a, c));
}
prepare(0, -1);
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
queries[a].push_back(std::make_pair(b, i));
}
solve(0, -1);
for (int i = 0; i < m; ++i) {
printf("%d\n", answer[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 100100;
struct Input {
int n, q;
vector<pair<int, int> > a[N];
int l[N], r[N];
bool read() {
if (scanf("%d", &n) != 1) return 0;
for (int i = int(0); i < int(n - 1); ++i) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
u--, v--;
a[u].push_back(make_pair(v, c));
a[v].push_back(make_pair(u, c));
}
cin >> q;
for (int i = int(0); i < int(q); ++i) {
scanf("%d%d", &l[i], &r[i]);
l[i]--, r[i]--;
}
return 1;
}
void init(const Input& input) { *this = input; }
};
const long long mod = 1000000007;
struct Data : Input {
long long ans[N];
void write() {
for (int i = int(0); i < int(q); ++i) {
cout << ans[i] % mod;
puts("");
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
long long sz[N];
int tw[20][N];
long long sum[20][N];
int h[N];
long long d1[N];
long long d2[N];
long long tot[N];
long long totd1[N];
int dfs(int v, int pr, int c, int h1) {
sz[v] = 1;
tw[0][v] = pr;
sum[0][v] = c;
h[v] = h1;
for (int i = int(0); i < int(((int)(a[v]).size())); ++i) {
int to = a[v][i].first;
if (to != pr) {
sz[v] += dfs(to, v, a[v][i].second, h1 + 1);
}
}
return sz[v];
}
pair<int, long long> up(int v, int h) {
long long res = 0;
for (int i = int(0); i < int(20); ++i) {
if (h & (1 << i)) {
(res += sum[i][v]) %= mod;
v = tw[i][v];
}
}
return make_pair(v, res);
}
int get_lca(int u, int v) {
if (h[u] > h[v]) swap(u, v);
v = up(v, h[v] - h[u]).first;
if (u == v) return u;
for (int i = int(20) - 1; i >= int(0); --i) {
if (tw[i][v] != tw[i][u]) {
u = tw[i][u], v = tw[i][v];
}
}
return tw[0][u];
}
long long get_v(int v, long long c) { return get_d2(sz[v], d1[v], d2[v], c); }
long long get_d2(long long sz, long long d1, long long d2, long long c) {
return (d2 + 2 * d1 * c % mod + c * c % mod * sz) % mod;
}
void calc_in(int v) {
d2[v] = 0ll;
d1[v] = 0ll;
for (int i = int(0); i < int(((int)(a[v]).size())); ++i) {
int to = a[v][i].first;
if (to != tw[0][v]) {
calc_in(to);
(d2[v] += get_v(to, a[v][i].second)) %= mod;
(d1[v] += d1[to] + sz[to] * a[v][i].second) %= mod;
}
}
}
void calc_tot(int v, long long dst1, long long dst2) {
tot[v] = (dst2 + d2[v]) % mod;
totd1[v] = (dst1 + d1[v]) % mod;
for (int i = int(0); i < int(((int)(a[v]).size())); ++i) {
int to = a[v][i].first;
if (to != tw[0][v]) {
long long ndst2 = dst2;
ndst2 += d2[v];
ndst2 -= get_v(to, a[v][i].second);
(ndst2 += mod) %= mod;
long long ndst1 = dst1;
ndst1 += d1[v];
ndst1 -= d1[to] + sz[to] * a[v][i].second % mod;
(ndst1 += 2 * mod) %= mod;
calc_tot(to, (ndst1 + (n - sz[to]) * a[v][i].second) % mod,
get_d2(n - sz[to], ndst1, ndst2, a[v][i].second));
}
}
}
long long get_sum(int u, int v) {
int lca = get_lca(u, v);
return up(u, h[u] - h[lca]).second + up(v, h[v] - h[lca]).second;
}
void solve() {
dfs(0, 0, 0, 0);
for (int i = int(1); i < int(20); ++i) {
for (int j = int(0); j < int(n); ++j) {
tw[i][j] = tw[i - 1][tw[i - 1][j]];
(sum[i][j] = sum[i - 1][j] + sum[i - 1][tw[i - 1][j]]) %= mod;
}
}
calc_in(0);
calc_tot(0, 0ll, 0ll);
for (int i = int(0); i < int(q); ++i) {
int u = l[i], v = r[i];
int lca = get_lca(u, v);
if (lca != v) {
(ans[i] = tot[u] - 2 * get_v(v, get_sum(u, v)) + 2 * mod) %= mod;
ans[i] = (mod - ans[i]) % mod;
} else {
(ans[i] = 2 * get_d2(n - sz[v], totd1[v] - d1[v] + mod,
tot[v] - d2[v] + mod, get_sum(u, v)) -
(tot[u] - d2[u] + mod) % mod - d2[u] + 2 * mod) %= mod;
ans[i] = (mod - ans[i]) % mod;
}
}
}
void print1() {
;
;
;
;
;
}
void print2() {
;
;
}
void print3() { ; }
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 400400;
int const mod = 1000000007;
void add(int &a, int b) {
if ((a += b) >= mod) a -= mod;
}
int prod(int a, int b) {
auto x = (unsigned long long)a * b;
unsigned int xh = x >> 32, xl = x, q, r;
asm("divl %4; \n\t" : "=a"(q), "=d"(r) : "d"(xh), "a"(xl), "r"(mod));
return r;
}
int sum[N], sq[N], down[N];
void apply(int v, int l, int r, int val) {
add(sq[v], prod(2, prod(sum[v], val)));
add(sq[v], prod(val, prod(val, r - l)));
add(sum[v], prod(val, r - l));
add(down[v], val);
}
void push(int v, int l, int r) {
int m = (l + r) / 2;
apply(2 * v + 1, l, m, down[v]);
apply(2 * v + 2, m, r, down[v]);
down[v] = 0;
}
void add(int v, int l, int r, int from, int to, int val) {
if (r <= from || to <= l) return;
if (from <= l && r <= to) {
apply(v, l, r, val);
return;
}
push(v, l, r);
int m = (l + r) / 2;
add(2 * v + 1, l, m, from, to, val);
add(2 * v + 2, m, r, from, to, val);
sum[v] = sum[2 * v + 1] + sum[2 * v + 2];
add(sum[v], 0);
sq[v] = sq[2 * v + 1] + sq[2 * v + 2];
add(sq[v], 0);
}
int get_sq(int v, int l, int r, int from, int to) {
if (r <= from || to <= l) return 0;
if (from <= l && r <= to) return sq[v];
push(v, l, r);
int m = (l + r) / 2;
int ans =
get_sq(2 * v + 1, l, m, from, to) + get_sq(2 * v + 2, m, r, from, to);
add(ans, 0);
return ans;
}
int n;
vector<pair<int, int>> g[N];
int tin[N], tout[N];
void dfs(int v, int par) {
static int timer = 0;
tin[v] = timer++;
for (auto e : g[v]) {
if (e.first != par) {
dfs(e.first, v);
add(0, 0, n, tin[e.first], tout[e.first], e.second);
}
}
tout[v] = timer;
}
int ans[N];
vector<pair<int, int>> qs[N];
void calc(int v, int par) {
for (auto q : qs[v]) {
int cur = get_sq(0, 0, n, tin[q.first], tout[q.first]);
int all = get_sq(0, 0, n, 0, n);
ans[q.second] = prod(2, cur);
add(ans[q.second], mod - all);
}
for (auto e : g[v]) {
if (e.first != par) {
add(0, 0, n, 0, n, e.second);
add(0, 0, n, tin[e.first], tout[e.first], mod - prod(2, e.second));
calc(e.first, v);
add(0, 0, n, 0, n, mod - e.second);
add(0, 0, n, tin[e.first], tout[e.first], prod(2, e.second));
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
--a, --b;
g[a].emplace_back(b, c);
g[b].emplace_back(a, c);
}
dfs(0, -1);
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
qs[u].emplace_back(v, i);
}
calc(0, -1);
for (int i = 0; i < q; ++i) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &first) {
char c;
bool neg = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') neg = 1, c = getchar();
first = c - 48;
while (isdigit(c = getchar())) first = first * 10 + c - 48;
if (neg) first = -first;
}
template <typename T>
inline void write(T first) {
if (first < 0) putchar('-'), first = -first;
if (first > 9) write(first / 10);
putchar(first % 10 + 48);
}
const long long N = 1e5, mod = 1e9 + 7;
long long n, q, Tin[N + 2], Tout[N + 2], cnt, A[N + 2], D0[N + 2], D1[N + 2],
L[4 * N + 2], Res[N + 2];
vector<pair<long long, long long> > Z[N + 2];
pair<long long, long long> T[4 * N + 2];
vector<pair<long long, long long> > g[N + 2];
void dfs(long long u, long long dad, long long S0, long long S1) {
Tin[u] = ++cnt;
A[cnt] = u;
D0[u] = S0;
D1[u] = S1;
for (auto &ed : g[u]) {
long long v = ed.first;
if (v == dad) continue;
long long w = ed.second;
dfs(v, u, (S0 + w) % mod, (S1 + 2 * S0 * w + w * w) % mod);
}
Tout[u] = cnt;
}
pair<long long, long long> operator+(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return {(a.first + b.first) % mod, (a.second + b.second) % mod};
}
void build(long long id, long long l, long long r) {
if (l == r) {
T[id] = {D0[A[l]], D1[A[l]]};
return;
}
build((id << 1), l, ((l + r) >> 1));
build((id << 1 | 1), ((l + r) >> 1) + 1, r);
T[id] = T[(id << 1)] + T[(id << 1 | 1)];
}
void down(long long id, long long l, long long r) {
if (!L[id]) return;
long long w = L[id];
L[id] = 0;
T[(id << 1)].second =
(T[(id << 1)].second + 2 * w * T[(id << 1)].first % mod +
w * w % mod * (((l + r) >> 1) - l + 1) % mod) %
mod;
T[(id << 1)].first =
(T[(id << 1)].first + w * (((l + r) >> 1) - l + 1)) % mod;
T[(id << 1 | 1)].second =
(T[(id << 1 | 1)].second + 2 * w * T[(id << 1 | 1)].first % mod +
w * w % mod * (r - ((l + r) >> 1)) % mod) %
mod;
T[(id << 1 | 1)].first =
(T[(id << 1 | 1)].first + w * (r - ((l + r) >> 1))) % mod;
L[(id << 1)] = (L[(id << 1)] + w) % mod;
L[(id << 1 | 1)] = (L[(id << 1 | 1)] + w) % mod;
}
void update(long long id, long long l, long long r, long long u, long long v,
long long w) {
if (l > v || r < u) return;
if (l >= u && r <= v) {
T[id].second =
(T[id].second + 2 * w * T[id].first + (w * w % mod) * (r - l + 1)) %
mod;
T[id].first = (T[id].first + w * (r - l + 1)) % mod;
L[id] = (L[id] + w) % mod;
return;
}
down(id, l, r);
update((id << 1), l, ((l + r) >> 1), u, v, w);
update((id << 1 | 1), ((l + r) >> 1) + 1, r, u, v, w);
T[id] = T[(id << 1)] + T[(id << 1 | 1)];
}
long long get(long long id, long long l, long long r, long long u,
long long v) {
if (l > v || r < u) return 0;
if (l >= u && r <= v) return T[id].second;
down(id, l, r);
return get((id << 1), l, ((l + r) >> 1), u, v) +
get((id << 1 | 1), ((l + r) >> 1) + 1, r, u, v);
}
void dfsto(long long u, long long dad) {
for (auto &qu : Z[u])
Res[qu.first] =
2 * get(1, 1, n, Tin[qu.second], Tout[qu.second]) - get(1, 1, n, 1, n);
for (auto &ed : g[u]) {
long long v = ed.first;
if (v == dad) continue;
long long w = ed.second;
update(1, 1, n, Tin[v], Tout[v], -w);
update(1, 1, n, 1, Tin[v] - 1, w);
update(1, 1, n, Tout[v] + 1, n, w);
dfsto(v, u);
update(1, 1, n, Tin[v], Tout[v], w);
update(1, 1, n, 1, Tin[v] - 1, -w);
update(1, 1, n, Tout[v] + 1, n, -w);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
read(n);
for (long long i = (1); i <= (n - 1); ++i) {
long long u, v, w;
read(u);
read(v);
read(w);
g[u].push_back({v, w});
g[v].push_back({u, w});
}
dfs(1, 1, 0, 0);
build(1, 1, n);
read(q);
for (long long i = (1); i <= (q); ++i) {
long long u, v;
read(u);
read(v);
Z[u].push_back({i, v});
}
dfsto(1, 1);
for (long long i = (1); i <= (q); ++i)
write(((Res[i] % mod) + mod) % mod), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 214514;
const int mod = 1e9 + 7;
struct edge {
int v, nt;
long long w;
} e[N << 1];
long long sz[N], f1[N], f2[N], g1[N], g2[N], d[N];
int hd[N], s[N], in[N], fa[N], tp[N], de[N];
long long Z(long long x) { return (x % mod + mod) % mod; }
int tot, n, q, po;
void add(int x, int y, long long z) {
e[++tot] = {y, hd[x], z};
hd[x] = tot;
}
void dfs1(int x, int f) {
sz[x] = 1;
fa[x] = f;
long long z;
de[x] = de[f] + 1;
for (int i = hd[x], to; i; i = e[i].nt) {
to = e[i].v, z = e[i].w;
if (to == f) continue;
d[to] = d[x] + z;
dfs1(to, x);
sz[x] += sz[to];
f1[x] = (f1[x] + sz[to] * z + f1[to]);
f2[x] = (f2[x] + z * z % mod * sz[to] % mod + 2 * z % mod * f1[to] % mod +
f2[to]);
f1[x] = Z(f1[x]), f2[x] = Z(f2[x]);
if (sz[s[x]] < sz[to]) s[x] = to;
}
}
void dfs2(int x, int tf) {
tp[x] = tf;
long long z;
in[x] = ++po;
for (int i = hd[x], to; i; i = e[i].nt)
if (e[i].v != fa[x]) {
to = e[i].v, z = e[i].w;
g1[to] = (g1[x] + (n - 2 * sz[to]) * z);
g2[to] = (g2[x] + (g1[x] - 2 * f1[to]) * 2 * z % mod +
(n - 4 * sz[to]) * z % mod * z % mod);
g1[to] = Z(g1[to]), g2[to] = Z(g2[to]);
if (to == s[x])
dfs2(to, tf);
else
dfs2(to, to);
}
}
int lca(int x, int y) {
while (tp[x] != tp[y]) {
if (de[tp[x]] < de[tp[y]]) swap(x, y);
x = fa[tp[x]];
}
return de[x] < de[y] ? x : y;
}
int main() {
scanf("%d", &n);
long long z;
for (int i = 1, x, y; i < n; i++)
scanf("%d%d%lld", &x, &y, &z), add(x, y, z), add(y, x, z);
dfs1(1, 0);
g1[1] = f1[1], g2[1] = f2[1], dfs2(1, 1);
scanf("%d", &q);
for (int i = 1, x, y; i <= q; i++) {
scanf("%d%d", &x, &y);
int f = lca(x, y);
z = (d[x] + d[y] - 2 * d[f] + mod) % mod;
if (f == y)
printf("%lld\n",
Z(g2[x] - 2ll * (g2[y] - f2[y] + (g1[y] - f1[y]) * z * 2ll % mod +
z * z % mod * (n - sz[y]))));
else
printf("%lld\n", Z(2ll * (f2[y] + 2ll * f1[y] % mod * z +
z * z % mod * sz[y] % mod) -
g2[x]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
vector<pair<int, long long> > v[100004];
int parent[100004], level[100004];
long long dist[100004], size[100004], first[100004], f_[100004], g[100004],
g_[100004];
int n;
int P[100004][30];
long long mu(long long x1, long long x2) { return (x1 * x2) % M; }
void preprocess(void) {
int i, m;
int j = n;
for (i = 0; i <= j; i++)
for (m = 0; (1 << m) <= j; m++) P[i][m] = -1;
for (i = 1; i <= j; i++) P[i][0] = parent[i];
for (m = 1; 1 << m <= j; m++)
for (i = 1; i <= j; i++)
if (P[i][m - 1] != -1) P[i][m] = P[P[i][m - 1]][m - 1];
}
int lca(int p, int q) {
int tmp, log, i;
if (level[p] < level[q]) tmp = p, p = q, q = tmp;
for (log = 1; 1 << log <= level[p]; log++)
;
log--;
for (i = log; i >= 0; i--)
if (level[p] - (1 << i) >= level[q]) p = P[p][i];
if (p == q) return p;
for (i = log; i >= 0; i--)
if (P[p][i] != -1 && P[p][i] != P[q][i]) p = P[p][i], q = P[q][i];
return parent[p];
}
void dfs(int node, int par) {
size[node] = 1;
for (int j = 0; j < v[node].size(); j++) {
int ver = v[node][j].first;
if (ver != par) {
level[ver] = 1 + level[node];
parent[ver] = node;
dist[ver] = (dist[node] + v[node][j].second) % M;
dfs(ver, node);
size[node] += size[ver];
first[node] =
(first[node] + first[ver] + v[node][j].second * size[ver]) % M;
g[node] = (g[node] + g[ver] + 2 * first[ver] * v[node][j].second +
mu(v[node][j].second, v[node][j].second) * size[ver]) %
M;
}
}
}
void dfs1(int node, int par, long long d) {
f_[node] =
(f_[par] + first[par] - first[node] + d * (n - 2 * size[node])) % M;
g_[node] = (g_[par] + g[par] - g[node] + mu(d, d) * (n - 4 * size[node]) +
d * (2 * first[par] + 2 * f_[par] - 4 * first[node])) %
M;
for (int j = 0; j < v[node].size(); j++) {
int ver = v[node][j].first;
if (ver != par) dfs1(ver, node, v[node][j].second);
}
}
long long ans(int u1, int v1) {
int lc = lca(u1, v1);
long long sum = 0;
long long d = dist[u1] + dist[v1] - 2 * dist[lc];
if (lc == v1) {
sum = (g[u1] + g_[u1] - 2 * g_[v1] - 2 * mu(d, d) * (n - size[v1]) -
4 * d * f_[v1]) %
M;
} else {
sum = (2 * g[v1] - g_[u1] - g[u1] + 2 * mu(d, d) * size[v1] +
4 * d * first[v1]) %
M;
}
if (sum < 0) sum += M;
return sum;
}
int main() {
int a, b;
long long c;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d", &a);
scanf("%d", &b);
scanf("%lld", &c);
v[a].push_back(make_pair(b, c));
v[b].push_back(make_pair(a, c));
}
parent[1] = 1;
dist[1] = 0;
level[1] = 1;
dfs(1, 1);
dfs1(1, 1, 0);
preprocess();
int q;
scanf("%d", &q);
while (q--) {
scanf("%d", &a);
scanf("%d", &b);
cout << ans(a, b) << endl;
}
}
|
#include <bits/stdc++.h>
static struct FASTIO {
char READ_CHARACTER;
bool REMAINING_CHARACTER = false;
inline void ignore();
inline void flush();
template <typename T>
inline bool READ_INT(T &x);
template <typename T>
inline bool READ_STRING(T &x);
template <size_t N>
inline bool READ_CHAR_ARRAY(char (&x)[N]);
template <size_t N>
inline bool READ_VAR(char (&x)[N]);
template <typename T>
inline bool READ_CHAR(T &x);
inline bool READ_CHAR_ARRAY(char *&x);
inline bool READ_GETLINE(std::string &x);
template <typename T>
inline bool READ_FLOAT(T &x);
template <typename T>
inline bool READ_DOUBLE(T &x);
template <std::size_t N>
inline bool READ_BITSET(std::bitset<N> &bit);
template <std::size_t N>
inline bool READ_VAR(std::bitset<N> &bit);
inline bool READ_VAR(bool &x);
inline bool READ_VAR(short int &x);
inline bool READ_VAR(int &x);
inline bool READ_VAR(long int &x);
inline bool READ_VAR(long long int &x);
inline bool READ_VAR(unsigned short int &x);
inline bool READ_VAR(unsigned int &x);
inline bool READ_VAR(unsigned long &x);
inline bool READ_VAR(unsigned long long &x);
inline bool READ_VAR(std::string &x);
inline bool READ_VAR(char &x);
inline bool READ_VAR(char *&x);
inline bool READ_VAR(float &x);
inline bool READ_VAR(double &x);
inline bool READ_VAR(long double &x);
template <typename T>
inline void WRITE_INT(T x);
inline void WRITE_STRING(std::string &x);
inline void WRITE_CHAR(char x);
inline void WRITE_CHAR_ARRAY(const char *x);
inline void WRITE_FLOAT(float x);
template <typename T>
inline void WRITE_DOUBLE(T x);
inline void WRITE_VAR(bool x);
inline void WRITE_VAR(short int x);
inline void WRITE_VAR(int x);
inline void WRITE_VAR(long int x);
inline void WRITE_VAR(long long int x);
inline void WRITE_VAR(unsigned short int x);
inline void WRITE_VAR(unsigned int x);
inline void WRITE_VAR(unsigned long x);
inline void WRITE_VAR(unsigned long long x);
inline void WRITE_VAR(char x);
inline void WRITE_VAR(const char *x);
inline void WRITE_VAR(std::string &x);
inline void WRITE_VAR(float x);
inline void WRITE_VAR(double x);
inline void WRITE_VAR(long double x);
template <std::size_t N>
inline void WRITE_VAR(std::bitset<N> &bit);
template <std::size_t N>
inline void WRITE_BITSET(std::bitset<N> &bit);
} __FIO__;
using namespace std;
#pragma GCC optimize("O2,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int maxn = 1e5 + 10, maxm = 1e5 + 10, lg = 21, mod = 1e9 + 7, inf = 1e18;
struct node {
long long s1, s2, laz;
node(int s1 = 0, int s2 = 0, int laz = 0) : s1(s1), s2(s2), laz(laz) {}
} seg[maxn << 2];
int n, ans[maxn], st[maxn], ft[maxn], tt;
vector<pair<int, int> > g[maxn], pp[maxn];
void apply(int siz, int v, int x) {
seg[v].s2 += ((long long)siz * ((long long)x * x % mod) % mod) +
((long long)2 * seg[v].s1 * x % mod);
while (seg[v].s2 >= mod) seg[v].s2 -= mod;
seg[v].s1 += (long long)siz * x % mod;
while (seg[v].s1 >= mod) seg[v].s1 -= mod;
seg[v].laz += x;
while (seg[v].laz >= mod) seg[v].laz -= mod;
}
node mrg(node n1, node n2) {
return node(n1.s1 + n2.s1 + (n1.s1 + n2.s1 >= mod ? -mod : 0),
n1.s2 + n2.s2 + (n1.s2 + n2.s2 >= mod ? -mod : 0), 0);
}
void add(int l, int r, int x, int s = 0, int t = n, int v = 1) {
if (l >= t || r <= s) return;
if (l <= s && r >= t) return apply(t - s, v, x);
apply(((s + t) >> 1) - s, (v << 1), seg[v].laz);
apply(t - ((s + t) >> 1), ((v << 1) ^ 1), seg[v].laz);
seg[v].laz = 0;
add(l, r, x, s, ((s + t) >> 1), (v << 1));
add(l, r, x, ((s + t) >> 1), t, ((v << 1) ^ 1));
seg[v] = mrg(seg[(v << 1)], seg[((v << 1) ^ 1)]);
}
node get(int l, int r, int s = 0, int t = n, int v = 1) {
if (l >= t || r <= s) return node(0, 0, 0);
if (l <= s && r >= t) return seg[v];
apply(((s + t) >> 1) - s, (v << 1), seg[v].laz);
apply(t - ((s + t) >> 1), ((v << 1) ^ 1), seg[v].laz);
seg[v].laz = 0;
return mrg(get(l, r, s, ((s + t) >> 1), (v << 1)),
get(l, r, ((s + t) >> 1), t, ((v << 1) ^ 1)));
}
void pfs(int v = 1, int p = 0, int h = 0) {
st[v] = tt++;
for (auto u : g[v])
if (u.first != p)
pfs(u.first, v, (h + u.second) + (h + u.second >= mod ? -mod : 0));
ft[v] = tt;
add(st[v], st[v] + 1, h);
}
void dfs(int v = 1, int p = 0) {
for (auto x : pp[v]) {
ans[x.second] += get(st[x.first], ft[x.first]).s2;
if (ans[x.second] >= mod) ans[x.second] -= mod;
ans[x.second] -= mrg(get(0, st[x.first]), get(ft[x.first], n)).s2,
ans[x.second] += mod;
if (ans[x.second] >= mod) ans[x.second] -= mod;
}
for (auto uw : g[v])
if (uw.first != p) {
int u = uw.first, w = uw.second;
add(st[u], ft[u], mod - w);
add(0, st[u], w);
add(ft[u], n, w);
dfs(u, v);
add(st[u], ft[u], w);
add(0, st[u], mod - w);
add(ft[u], n, mod - w);
}
}
int main() {
0, 0, 0;
__FIO__.READ_VAR(n);
for (int i = 1; i < n; i++) {
int v, u, w;
__FIO__.READ_VAR(v), __FIO__.READ_VAR(u), __FIO__.READ_VAR(w);
g[v].push_back({u, w}), g[u].push_back({v, w});
}
int q;
__FIO__.READ_VAR(q);
for (int i = 0; i < q; i++) {
int v, u;
__FIO__.READ_VAR(u), __FIO__.READ_VAR(v);
pp[u].push_back({v, i});
}
pfs(), dfs();
for (int i = 0; i < q; i++) __FIO__.WRITE_VAR(ans[i]), putchar('\n');
return 0;
}
inline void FASTIO::ignore() {
if (REMAINING_CHARACTER == true)
REMAINING_CHARACTER = false;
else
READ_CHARACTER = getchar();
}
inline void FASTIO::flush() { fflush(stdout); }
template <typename T>
inline bool FASTIO::READ_INT(T &x) {
x = 0;
T sig = 1;
if (!REMAINING_CHARACTER)
READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
else
REMAINING_CHARACTER = false;
while (!isdigit(READ_CHARACTER) && READ_CHARACTER != EOF)
sig = (READ_CHARACTER == '-' ? -sig : sig), READ_CHARACTER = getchar();
if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
while (isdigit(READ_CHARACTER))
x = x * 10 + READ_CHARACTER - '0', READ_CHARACTER = getchar();
x *= sig;
REMAINING_CHARACTER = true;
return true;
}
template <typename T>
inline bool FASTIO::READ_STRING(T &x) {
x = "";
if (!REMAINING_CHARACTER)
READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
else
REMAINING_CHARACTER = false;
while ((READ_CHARACTER == '\n' || READ_CHARACTER == '\t' ||
READ_CHARACTER == ' '))
READ_CHARACTER = getchar();
if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
while ((READ_CHARACTER != '\n' && READ_CHARACTER != '\t' &&
READ_CHARACTER != ' ' && READ_CHARACTER != EOF))
x += READ_CHARACTER, READ_CHARACTER = getchar();
REMAINING_CHARACTER = true;
return true;
}
inline bool FASTIO::READ_GETLINE(std::string &x) {
x = "";
if (!REMAINING_CHARACTER)
READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
else
REMAINING_CHARACTER = false;
if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
while ((READ_CHARACTER != '\n' && READ_CHARACTER != EOF))
x += READ_CHARACTER, READ_CHARACTER = getchar();
REMAINING_CHARACTER = false;
return true;
}
template <typename T>
inline bool FASTIO::READ_CHAR(T &x) {
if (!REMAINING_CHARACTER)
READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
else
REMAINING_CHARACTER = false;
if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
while ((READ_CHARACTER == '\n' || READ_CHARACTER == '\t' ||
READ_CHARACTER == ' '))
READ_CHARACTER = getchar();
x = READ_CHARACTER;
REMAINING_CHARACTER = false;
return true;
}
template <size_t N>
inline bool FASTIO::READ_CHAR_ARRAY(char (&x)[N]) {
if (!REMAINING_CHARACTER)
READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
else
REMAINING_CHARACTER = false;
while ((READ_CHARACTER == '\n' || READ_CHARACTER == '\t' ||
READ_CHARACTER == ' '))
READ_CHARACTER = getchar();
if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
char *ptr = &x[0];
while ((READ_CHARACTER != '\n' && READ_CHARACTER != '\t' &&
READ_CHARACTER != ' ' && READ_CHARACTER != EOF))
*ptr++ = READ_CHARACTER, READ_CHARACTER = getchar();
*ptr = '\0', REMAINING_CHARACTER = true;
return true;
}
inline bool FASTIO::READ_CHAR_ARRAY(char *&x) {
std::string y;
if (READ_STRING(y) == false) return false;
x = new char[(int)y.size() + 1];
strcpy(x, y.c_str());
return true;
}
template <typename T>
inline bool FASTIO::READ_FLOAT(T &x) {
return (scanf("%f", &x) != EOF);
}
template <typename T>
inline bool FASTIO::READ_DOUBLE(T &x) {
double y;
if (scanf("%lf", &y) == EOF) return false;
x = y;
return true;
}
template <std::size_t N>
inline bool FASTIO::READ_BITSET(std::bitset<N> &x) {
if (!REMAINING_CHARACTER)
READ_CHARACTER = getchar(), REMAINING_CHARACTER = true;
else
REMAINING_CHARACTER = false;
while ((READ_CHARACTER == '\n' || READ_CHARACTER == '\t' ||
READ_CHARACTER == ' '))
READ_CHARACTER = getchar();
if (READ_CHARACTER == EOF) return REMAINING_CHARACTER = false, false;
int i = 0;
REMAINING_CHARACTER = true;
while (READ_CHARACTER == '0' || READ_CHARACTER == '1')
x[i++] = READ_CHARACTER - '0', READ_CHARACTER = getchar();
return true;
}
inline bool FASTIO::READ_VAR(short int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(long int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(long long int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(unsigned short int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(unsigned int &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(unsigned long &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(unsigned long long &x) { return READ_INT(x); }
inline bool FASTIO::READ_VAR(std::string &x) { return READ_STRING(x); }
inline bool FASTIO::READ_VAR(char &x) { return READ_CHAR(x); }
template <size_t N>
inline bool FASTIO::READ_VAR(char (&x)[N]) {
return READ_CHAR_ARRAY(x);
}
inline bool FASTIO::READ_VAR(char *&x) { return READ_CHAR_ARRAY(x); }
inline bool FASTIO::READ_VAR(float &x) { return READ_FLOAT(x); }
inline bool FASTIO::READ_VAR(double &x) { return READ_DOUBLE(x); }
inline bool FASTIO::READ_VAR(long double &x) { return READ_DOUBLE(x); }
template <std::size_t N>
inline bool FASTIO::READ_VAR(std::bitset<N> &x) {
return READ_BITSET(x);
}
template <typename T>
inline void FASTIO::WRITE_INT(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
char writeBuffer[20], *writePtr = writeBuffer;
do {
*writePtr++ = '0' + x % 10;
x /= 10;
} while (x);
do {
putchar(*--writePtr);
} while (writePtr > writeBuffer);
}
inline void FASTIO::WRITE_CHAR(char x) { putchar(x); }
inline void FASTIO::WRITE_CHAR_ARRAY(const char *x) {
while (*x != '\0') putchar(*x++);
}
inline void FASTIO::WRITE_STRING(std::string &x) {
for (char c : x) putchar(c);
}
inline void FASTIO::WRITE_FLOAT(float x) { printf("%f", x); }
template <typename T>
inline void FASTIO::WRITE_DOUBLE(T x) {
printf("%lf", (double)x);
}
template <std::size_t N>
inline void FASTIO::WRITE_BITSET(std::bitset<N> &x) {
for (int i = (int)x.size() - 1; i >= 0; i--) putchar(x[i] + 48);
}
inline void FASTIO::WRITE_VAR(bool x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(short int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(long int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(long long int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(unsigned short int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(unsigned int x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(unsigned long x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(unsigned long long x) { WRITE_INT(x); }
inline void FASTIO::WRITE_VAR(std::string &x) { WRITE_STRING(x); }
inline void FASTIO::WRITE_VAR(char x) { WRITE_CHAR(x); }
inline void FASTIO::WRITE_VAR(const char *x) { WRITE_CHAR_ARRAY(x); }
inline void FASTIO::WRITE_VAR(float x) { WRITE_FLOAT(x); }
inline void FASTIO::WRITE_VAR(double x) { WRITE_DOUBLE(x); }
inline void FASTIO::WRITE_VAR(long double x) { WRITE_DOUBLE(x); }
template <std::size_t N>
inline void FASTIO::WRITE_VAR(std::bitset<N> &x) {
WRITE_BITSET(x);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int modit(int x) {
x %= mod;
if (x < 0) x += mod;
return x;
}
int add(int a, int b) { return (a + b) % mod; }
int sub(int a, int b) { return add(a, mod - b); }
int mul(int a, int b) { return (long long)a * b % mod; }
int sq(int x) { return mul(x, x); }
struct PowerSums {
int sum[3];
PowerSums() { memset(sum, 0, sizeof sum); }
PowerSums append(int x) {
PowerSums ret;
ret.sum[0] = sum[0];
x = modit(x);
ret.sum[2] = add(sum[2], add(mul(2, mul(x, sum[1])), mul(sq(x), sum[0])));
ret.sum[1] = add(sum[1], mul(x, sum[0]));
return ret;
}
PowerSums add_zero() {
PowerSums ret = *this;
ret.sum[0] = add(1, sum[0]);
return ret;
}
int get() { return sum[2]; }
};
PowerSums apply(const PowerSums &a, const PowerSums &b, int f(int, int)) {
PowerSums ret;
for (int i = (0); i < (3); ++i) ret.sum[i] = f(a.sum[i], b.sum[i]);
return ret;
}
PowerSums operator+(const PowerSums &a, const PowerSums &b) {
return apply(a, b, add);
}
PowerSums operator-(const PowerSums &a, const PowerSums &b) {
return apply(a, b, sub);
}
const int MAXN = 100005;
const int MAXL = 18;
PowerSums down[MAXN];
PowerSums tot[MAXN];
PowerSums up[MAXN];
int N, Q;
vector<pair<int, int> > T[MAXN];
int rdist[MAXN];
void calc_down(int i, int dad, int rd) {
rdist[i] = rd;
for (auto e : T[i]) {
int j = e.first;
int d = e.second;
if (j != dad) {
calc_down(j, i, add(rd, d));
down[i] = down[i] + down[j].append(d);
}
}
down[i] = down[i].add_zero();
}
void calc_tot(int i, int dad) {
for (auto e : T[i]) {
int j = e.first;
int d = e.second;
if (j != dad) {
tot[j] = down[j] + (tot[i] - down[j].append(d)).append(d);
calc_tot(j, i);
}
}
up[i] = tot[i] - down[i];
}
void calc_all() {
calc_down(0, -1, 0);
tot[0] = down[0];
calc_tot(0, -1);
}
int dad[MAXN];
int dep[MAXN];
int anc[MAXN][MAXL];
void dfs(int i, int d) {
dep[i] = d;
for (auto it : T[i]) {
int j = it.first;
if (j != dad[i]) {
dad[j] = i;
dfs(j, d + 1);
}
}
}
void lca_precalc() {
dfs(0, 0);
for (int i = (0); i < (N); ++i) anc[i][0] = dad[i];
for (int p = (1); p < (MAXL); ++p)
for (int i = (0); i < (N); ++i) anc[i][p] = anc[anc[i][p - 1]][p - 1];
}
int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
for (int p = MAXL - 1; p >= 0; --p)
if (dep[anc[a][p]] >= dep[b]) a = anc[a][p];
if (a == b) return a;
for (int p = MAXL - 1; p >= 0; --p)
if (anc[a][p] != anc[b][p]) a = anc[a][p], b = anc[b][p];
return dad[a];
}
int dist(int a, int b) {
return sub(add(rdist[a], rdist[b]), mul(2, rdist[lca(a, b)]));
}
bool is_ancestor(int a, int b) { return lca(a, b) == a; }
int main(void) {
scanf("%d", &N);
for (int i = (0); i < (N - 1); ++i) {
int a, b, d;
scanf("%d%d%d", &a, &b, &d);
--a;
--b;
T[a].push_back(pair<int, int>(b, d));
T[b].push_back(pair<int, int>(a, d));
}
lca_precalc();
calc_all();
scanf("%d", &Q);
for (int i = (0); i < (Q); ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
if (is_ancestor(v, u))
printf("%d\n", sub(tot[u].get(), mul(2, up[v].append(dist(u, v)).get())));
else
printf("%d\n",
sub(mul(2, down[v].append(dist(u, v)).get()), tot[u].get()));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long N = 100005;
long long cnt, head[N], u, v, n, q, w, ff[N][22], Dfn, in[N], out[N], dis[N],
dep[N], val[N];
struct node {
long long to, next, w;
} num[N << 1];
struct func {
long long a, b, c;
} f[N], g[N];
void up(long long &x, long long y) {
x = x - mod + y;
x = (x < 0) ? x + mod : x;
}
void add(long long x, long long y, long long w) {
num[++cnt].to = y;
num[cnt].next = head[x];
num[cnt].w = w;
head[x] = cnt;
}
void dfs(long long x, long long fa) {
in[x] = ++Dfn;
for (long long i = head[x]; i; i = num[i].next)
if (num[i].to != fa) {
ff[num[i].to][0] = x;
dis[num[i].to] = ((long long)dis[x] + num[i].w) % mod;
dep[num[i].to] = dep[x] + 1;
dfs(num[i].to, x);
long long a = f[num[i].to].a, b = f[num[i].to].b, c = f[num[i].to].c;
up(f[x].a, a);
up(f[x].b,
((long long)b + (long long)2 * a % mod * num[i].w % mod) % mod);
up(f[x].c,
((long long)c + (long long)a * num[i].w % mod * num[i].w % mod +
(long long)b * num[i].w % mod) %
mod);
}
up(f[x].a, 1);
out[x] = Dfn;
}
void dfs1(long long x, long long fa) {
if (fa) {
long long a = f[x].a, b = f[x].b, c = f[x].c, w = val[x];
g[x].a = ((long long)f[fa].a - a + mod) % mod;
g[x].b =
(((long long)f[fa].b - b - (long long)2 * a % mod * w % mod) % mod +
mod) %
mod;
g[x].c = (((long long)f[fa].c - c - (long long)a * w % mod * w % mod -
(long long)b * w % mod) %
mod +
mod) %
mod;
a = g[fa].a, b = g[fa].b, c = g[fa].c;
w = val[fa];
up(g[x].a, a);
up(g[x].b, ((long long)b + (long long)2 * a % mod * w % mod) % mod);
up(g[x].c, ((long long)c + (long long)a * w % mod * w % mod +
(long long)b * w % mod) %
mod);
}
for (long long i = head[x]; i; i = num[i].next)
if (num[i].to != fa) val[num[i].to] = num[i].w, dfs1(num[i].to, x);
}
void init() {
for (long long j = 1; j <= 20; j++)
for (long long i = 1; i <= n; i++) ff[i][j] = ff[ff[i][j - 1]][j - 1];
}
long long lca(long long x, long long y) {
if (dep[x] < dep[y]) swap(x, y);
long long del = dep[x] - dep[y];
for (long long i = 0; i <= 20; i++)
if (del & (1 << i)) x = ff[x][i];
if (x == y) return x;
for (long long i = 20; i >= 0; i--)
if (ff[x][i] != ff[y][i]) x = ff[x][i], y = ff[y][i];
return ff[x][0];
}
long long dist(long long x, long long y) {
return ((long long)dis[x] + dis[y] - (long long)2 * dis[lca(x, y)] % mod +
mod) %
mod;
}
long long qry_F(long long x, long long y) {
return ((long long)x * x % mod * f[y].a % mod + (long long)x * f[y].b % mod +
f[y].c) %
mod;
}
long long qry_G(long long x, long long y) {
return ((long long)x * x % mod * g[y].a % mod + (long long)x * g[y].b % mod +
g[y].c) %
mod;
}
long long D(long long u, long long v) {
if (in[v] <= in[u] && in[u] <= out[v]) {
return (((long long)qry_F(0, u) + qry_G(val[u], u) -
qry_G(((long long)dis[u] - dis[ff[v][0]] + mod) % mod, v)) %
mod +
mod) %
mod;
} else {
return qry_F(dist(u, v), v);
}
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i < n; i++)
scanf("%lld%lld%lld", &u, &v, &w), add(u, v, w), add(v, u, w);
dfs(1, 0);
dfs1(1, 0);
init();
scanf("%lld", &q);
while (q--) {
scanf("%d%d", &u, &v);
printf("%lld\n", ((long long)2 * D(u, v) % mod - D(u, 1) + mod) % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > edge[100005];
long long sum[100005];
long long sum2[100005];
long long up[100005];
long long up2[100005];
int s[100005];
int lca[100005][20];
int dep[100005];
long long dist[100005];
void dfs(int v, int u) {
s[v] = 1;
lca[v][0] = u;
for (int i = 0; i < edge[v].size(); i++) {
if (edge[v][i].first == u) continue;
int x = edge[v][i].first;
dfs(x, v);
sum[v] += sum[x] + 1LL * s[x] * edge[v][i].second;
sum2[v] += sum2[x] +
1LL * s[x] * edge[v][i].second % 1000000007 * edge[v][i].second +
2LL * edge[v][i].second * sum[x];
sum[v] %= 1000000007;
sum2[v] %= 1000000007;
s[v] += s[x];
}
}
void dfs2(int v, int u, int c) {
if (u != -1) {
dep[v] = dep[u] + 1;
dist[v] = dist[u] + c;
long long x = sum2[v] + 2LL * c * sum[v] + 1LL * c * c % 1000000007 * s[v];
x %= 1000000007;
long long y = sum[v] + 1LL * c * s[v];
y %= 1000000007;
long long q = (sum2[u] + up2[u] - x + 1000000007) % 1000000007;
long long r = (sum[u] + up[u] - y + 1000000007) % 1000000007;
up[v] = (r + 1LL * (n - s[v]) * c) % 1000000007;
up2[v] =
(q + 2LL * r * c + 1LL * c * c % 1000000007 * (n - s[v])) % 1000000007;
}
for (int i = 0; i < edge[v].size(); i++)
if (u != edge[v][i].first) dfs2(edge[v][i].first, v, edge[v][i].second);
}
int calc(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
for (int i = 0; i < 20; i++) {
if ((((dep[b] - dep[a]) >> i) & 1)) {
b = lca[b][i];
}
}
if (a == b) return a;
for (int i = 19; i >= 0; i--) {
if (lca[a][i] != lca[b][i]) {
a = lca[a][i];
b = lca[b][i];
}
}
return lca[a][0];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
edge[a].push_back(make_pair(b, c));
edge[b].push_back(make_pair(a, c));
}
dfs(1, -1);
dfs2(1, -1, -1);
int q;
scanf("%d", &q);
for (int i = 0; i < 19; i++)
for (int j = 1; j <= n; j++)
if (lca[j][i] == -1)
lca[j][i + 1] = -1;
else
lca[j][i + 1] = lca[lca[j][i]][i];
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d%d", &u, &v);
int x = calc(u, v);
long long d = dist[u] + dist[v] - dist[x] * 2;
d %= 1000000007;
if (x == v && u != v) {
long long a =
up2[v] + 2LL * d * up[v] + 1LL * d * d % 1000000007 * (n - s[v]);
a %= 1000000007;
printf("%lld\n",
(sum2[u] + up2[u] - 2 * a + 1000000007 + 1000000007) % 1000000007);
} else {
long long a =
sum2[v] + 2LL * d * sum[v] + 1LL * d * d % 1000000007 * (s[v]);
a %= 1000000007;
printf("%lld\n",
(2 * a - sum2[u] - up2[u] + 1000000007 + 1000000007) % 1000000007);
}
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const long double pi = acos(-1.0);
const int M = (int)1e9 + 7;
const int N = (int)1e5 + 10;
const int L = 17;
int sum0[N], sum1[N], sum2[N], psum0[N], psum1[N], psum2[N], par[L][N], in[N],
out[N], curt, u, v, w, h[N], delta0[N], delta1[N], delta2[N], n, q;
vector<pair<int, int> > adj[N];
int add(int a, int b) { return (a + b) % M; }
int mult(int a, int b) { return (a * (long long)b) % M; }
bool is_parent(int u, int v) { return (in[u] <= in[v]) && (out[v] <= out[u]); }
void dfs(int v, int p = -1) {
in[v] = curt++, par[0][v] = ((p == -1) ? v : p), sum0[v] = 1, sum1[v] = 0,
sum2[v] = 0;
for (int i = 0; i < ((int)(adj[v]).size()); ++i) {
int u = adj[v][i].first, w = adj[v][i].second;
if (u == p) continue;
h[u] = add(h[v], w);
dfs(u, v);
sum0[v] = add(sum0[v], delta0[u] = sum0[u]);
sum1[v] = add(sum1[v], delta1[u] = add(sum1[u], mult(sum0[u], w)));
sum2[v] =
add(sum2[v], delta2[u] = add(add(sum2[u], mult(sum1[u], mult(2, w))),
mult(sum0[u], mult(w, w))));
}
out[v] = curt++;
}
void ndfs(int v, int p = -1) {
for (int i = 0; i < ((int)(adj[v]).size()); ++i) {
int u = adj[v][i].first, w = adj[v][i].second;
if (u == p) continue;
psum0[u] = add(psum0[v], add(sum0[v], M - delta0[u]));
psum1[u] = add(psum1[v], add(sum1[v], M - delta1[u]));
psum2[u] = add(psum2[v], add(sum2[v], M - delta2[u]));
psum2[u] = add(psum2[u],
add(mult(psum1[u], mult(2, w)), mult(psum0[u], mult(w, w))));
psum1[u] = add(psum1[u], mult(psum0[u], w));
ndfs(u, v);
}
}
int lca(int u, int v) {
if (is_parent(u, v)) return u;
for (int j = L - 1; j >= 0; --j)
if (!is_parent(par[j][u], v)) u = par[j][u];
return par[0][u];
}
int main() {
scanf("%d", &n);
for (int i = 0; i + 1 < n; ++i) {
scanf("%d%d%d", &u, &v, &w), --u, --v;
adj[u].push_back(make_pair(v, w)), adj[v].push_back(make_pair(u, w));
}
dfs(0);
for (int j = 1; j < L; ++j)
for (int i = 0; i < n; ++i) par[j][i] = par[j - 1][par[j - 1][i]];
ndfs(0);
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d%d", &u, &v), --u, --v;
w = add(add(h[u], h[v]), M - mult(2, h[lca(u, v)]));
if (!is_parent(v, u)) {
printf("%d\n", add(mult(2, add(add(sum2[v], mult(sum1[v], mult(2, w))),
mult(sum0[v], mult(w, w)))),
M - add(psum2[u], sum2[u])));
} else {
printf("%d\n",
add(M - mult(2, add(add(psum2[v], mult(psum1[v], mult(2, w))),
mult(psum0[v], mult(w, w)))),
add(psum2[u], sum2[u])));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1e5 + 10;
const int L = 20;
const long long MOD = 1e9 + 7;
const long double eps = 1e-12;
long long n, s1[N], s2[N], u1[N], u2[N], sz[N], par[N][L], dep[N], sub1[N],
sub2[N], dtr[N];
vector<pair<int, int> > e[N];
void dfs1(int v = 0, int pr = 0, long long w = 0) {
sz[v] = 1;
for (int i = 0; i < e[v].size(); i++) {
long long nx = e[v][i].first, w = e[v][i].second;
if (nx == pr) continue;
dfs1(nx, v, w);
s1[v] = (1LL * s1[v] + 1LL * w * sz[nx] + 1LL * s1[nx]) % MOD;
sz[v] += sz[nx];
s2[v] = (1LL * s2[v] + 1LL * w * 2 * s1[nx] + 1LL * s2[nx] +
1LL * ((1LL * w * w) % MOD) * sz[nx]) %
MOD;
}
sub1[v] = s1[v];
sub2[v] = s2[v];
}
void dfs2(int v = 0, int p = 0, long long w = 0) {
if (v != 0) {
long long y = (1LL * s2[p] - (1LL * s2[v] + 1LL * s1[v] * w * 2 +
1LL * sz[v] * ((1LL * w * w) % MOD))) %
MOD;
if (y < 0) y += MOD;
long long x = (1LL * s1[p] - (1LL * s1[v] + 1LL * w * sz[v])) % MOD;
if (x < 0) x += MOD;
long long s = n - sz[v];
s2[v] = (1LL * s2[v] + 1LL * y + 1LL * 2 * w * x +
1LL * s * 1LL * ((1LL * w * w) % MOD)) %
MOD;
s1[v] = (1LL * s1[v] + 1LL * x + 1LL * s * w) % MOD;
}
for (int i = 0; i < e[v].size(); i++)
if (e[v][i].first != p) dfs2(e[v][i].first, v, e[v][i].second);
}
void dfs3(int v = 0, int p = 0, long long w = 0) {
if (v) dep[v] = dep[p] + 1, dtr[v] = dtr[p] + w, dtr[v] %= MOD;
par[v][0] = p;
for (int i = 1; i < L; i++) par[v][i] = par[par[v][i - 1]][i - 1];
for (int i = 0; i < e[v].size(); i++)
if (e[v][i].first != p) dfs3(e[v][i].first, v, e[v][i].second);
}
int lca(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
int dif = dep[b] - dep[a];
for (int i = 0; i < L; i++)
if ((1 << i) & dif) b = par[b][i];
if (b == a) return b;
for (int i = L - 1; i >= 0; i--)
if (par[a][i] != par[b][i]) a = par[a][i], b = par[b][i];
return par[a][0];
}
int get(long long x) {
while (x < 0) x += MOD;
return (x % MOD);
}
int main() {
n = in();
for (int i = 1; i < n; i++) {
int a = in(), b = in(), w = in();
a--, b--;
e[a].push_back({b, w});
e[b].push_back({a, w});
}
dfs1();
dfs2();
dfs3();
int q = in();
for (int i = 0; i < q; i++) {
int a = in(), b = in();
a--, b--;
int x = lca(a, b);
long long dis = dtr[a] + dtr[b] - 2 * dtr[x];
long long first = (1LL * sub2[b] + 1LL * sub1[b] * dis * 2 +
1LL * sz[b] * ((1LL * dis * dis) % MOD)) %
MOD;
first *= 2;
first %= MOD;
long long ans = (first - s2[a] + MOD) % MOD;
if (x != b) printf("%d\n", get(ans));
if (x == b) {
long long out2 = (s2[b] - sub2[b]) % MOD;
long long out1 = (s1[b] - sub1[b]) % MOD;
if (out2 < 0) out2 += MOD;
if (out1 < 0) out1 += MOD;
long long s = n - sz[b];
long long fot = (1LL * out2 + 1LL * out1 * dis * 2 +
1LL * s * 1LL * ((1LL * dis * dis) % MOD)) %
MOD;
fot *= 2;
fot %= MOD;
printf("%d\n", get((s2[a] - fot + MOD) % MOD));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class sparse_table {
private:
int ancestor[100010][20 + 10];
int N;
public:
void init(int n, int *par) {
int i, j;
N = n;
memset(ancestor, -1, sizeof(int) * 100010 * (20 + 10));
for (i = 0; i < N; ++i) ancestor[i][0] = par[i];
for (j = 1; (1 << j) < N; ++j) {
for (i = 0; i < N; ++i) {
if (ancestor[i][j - 1] < 0) continue;
ancestor[i][j] = ancestor[ancestor[i][j - 1]][j - 1];
}
}
}
int query(int u, int v, int *lev) {
int i;
if (lev[u] < lev[v]) swap(u, v);
for (i = 20 - 1; i >= 0; --i) {
if (lev[u] - (1 << i) < lev[v]) continue;
u = ancestor[u][i];
}
if (u == v) return u;
for (i = 20 - 1; i >= 0; --i) {
if (ancestor[u][i] == ancestor[v][i]) continue;
u = ancestor[u][i];
v = ancestor[v][i];
}
return ancestor[u][0];
}
};
int ssize[100010];
int outsz[100010];
int rdist[100010];
int indist[100010];
int indist2[100010];
int outdist[100010];
int outdist2[100010];
int par[100010];
int lev[100010];
vector<pair<int, int> > adj[100010];
int N;
inline int mul(int a, int b) { return (1LL * a * b) % (int)((1e9) + 7); }
inline int add(int a, int b) {
int c = (a + b);
return c >= (int)((1e9) + 7) ? c - (int)((1e9) + 7) : c;
}
void dfs1(int v, int p, int dpar) {
rdist[v] = p >= 0 ? add(rdist[p], dpar) : 0;
par[v] = p;
lev[v] = p >= 0 ? lev[p] + 1 : 0;
int i, u, du;
ssize[v] = 1;
for (i = 0; i < adj[v].size(); ++i) {
u = adj[v][i].first;
if (u == p) continue;
du = adj[v][i].second;
dfs1(u, v, du);
ssize[v] += ssize[u];
indist[v] = add(indist[v], indist[u]);
indist[v] = add(indist[v], mul(du, ssize[u]));
indist2[v] = add(indist2[v], mul(mul(du, du), ssize[u]));
indist2[v] = add(indist2[v], indist2[u]);
indist2[v] = add(indist2[v], mul(2, mul(du, indist[u])));
}
outsz[v] = N - ssize[v];
}
inline int sub(int a, int b) {
int c = a - b;
if (c >= (int)((1e9) + 7)) c -= (int)((1e9) + 7);
return c < 0 ? c + (int)((1e9) + 7) : c;
}
void dfs2(int v, int p, int dpar) {
int i;
if (p < 0) {
for (i = 0; i < adj[v].size(); ++i)
dfs2(adj[v][i].first, v, adj[v][i].second);
return;
}
outdist[v] = add(add(outdist[p], indist[p]), mul(dpar, N));
outdist[v] = sub(outdist[v], add(indist[v], mul(dpar, 2 * ssize[v])));
int all, all2;
all = add(outdist[p], indist[p]);
all2 = add(outdist2[p], indist2[p]);
outdist2[v] = add(all2, add(mul(dpar, mul(dpar, N)), mul(all, mul(dpar, 2))));
outdist2[v] = sub(outdist2[v],
add(indist2[v], add(mul(dpar, mul(4, indist[v])),
mul(dpar, mul(dpar, 4 * ssize[v])))));
for (i = 0; i < adj[v].size(); ++i) {
if (adj[v][i].first == p) continue;
dfs2(adj[v][i].first, v, adj[v][i].second);
}
}
sparse_table T;
int get_sum(int u, int v) {
int all2;
int q1, q2;
all2 = add(outdist2[u], indist2[u]);
int l = T.query(u, v, lev);
int duv;
duv = sub(add(rdist[u], rdist[v]), mul(2, rdist[l]));
if (l == v) {
q2 = add(outdist2[v],
add(mul(duv, mul(duv, outsz[v])), mul(mul(2, duv), outdist[v])));
q1 = sub(all2, q2);
} else {
q1 = add(indist2[v],
add(mul(duv, mul(duv, ssize[v])), mul(mul(2, duv), indist[v])));
q2 = sub(all2, q1);
}
return sub(q1, q2);
}
int main() {
int i, u, v, q;
ios_base::sync_with_stdio(0);
cin >> N;
for (i = 0; i < N - 1; ++i) {
cin >> v >> u >> q;
--u, --v;
adj[u].push_back(make_pair(v, q));
adj[v].push_back(make_pair(u, q));
}
dfs1(0, -1, 0);
dfs2(0, -1, 0);
T.init(N, par);
cin >> q;
while (q--) {
cin >> u >> v;
--u, --v;
cout << get_sum(u, v) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100001;
vector<pair<int, int> > g[nmax], t[nmax];
int n, q, ans[nmax], c, l[nmax], r[nmax], d[nmax], sa[6 * nmax], sb[6 * nmax],
col[nmax * 6];
bool dd[nmax];
int modul = 1000000007;
void build(int s, int ll, int rr) {
if (ll == rr) {
sa[s] = d[ll];
sb[s] = ((long long)(d[ll]) * d[ll]) % modul;
return;
}
build(2 * s, ll, (ll + rr) / 2);
build(2 * s + 1, (ll + rr) / 2 + 1, rr);
sa[s] = (sa[2 * s] + sa[2 * s + 1]) % modul;
sb[s] = (sb[2 * s] + sb[2 * s + 1]) % modul;
}
void dfs(int i) {
l[i] = ++c;
for (int j = 0; j < g[i].size(); j++)
if (l[g[i][j].first] == 0) {
d[c + 1] = (d[l[i]] + g[i][j].second) % modul;
dfs(g[i][j].first);
}
r[i] = c;
}
void progress(int s, int ll, int rr) {
if (col[s] == 0) return;
int p = col[s];
col[2 * s] = (col[2 * s] + p) % modul;
int uu = ((long long)p * (long long)((ll + rr) / 2 - ll + 1)) % modul;
sb[2 * s] =
(sb[2 * s] +
((long long)p * (uu + (2 * sa[2 * s]) % modul) % modul) % modul) %
modul;
sa[2 * s] = (sa[2 * s] + uu) % modul;
col[2 * s + 1] = (col[2 * s + 1] + p) % modul;
uu = ((long long)p * (long long)(rr - (ll + rr) / 2)) % modul;
sb[2 * s + 1] =
(sb[2 * s + 1] +
((long long)p * (uu + (2 * sa[2 * s + 1]) % modul) % modul) % modul) %
modul;
sa[2 * s + 1] = (sa[2 * s + 1] + uu) % modul;
col[s] = 0;
}
void update(int s, int ll, int rr, int u, int v, int p) {
if (rr < u || v < ll) return;
progress(s, ll, rr);
if (u <= ll && rr <= v) {
int uu = ((long long)p * (long long)(rr - ll + 1)) % modul;
sb[s] = (sb[s] +
((long long)p * (long long)(uu + (2 * sa[s]) % modul) % modul) %
modul) %
modul;
sa[s] = (sa[s] + uu) % modul;
if (ll != rr) col[s] = p;
return;
}
update(s * 2, ll, (ll + rr) / 2, u, v, p);
update(s * 2 + 1, (ll + rr) / 2 + 1, rr, u, v, p);
sa[s] = (sa[2 * s] + sa[2 * s + 1]) % modul;
sb[s] = (sb[2 * s] + sb[2 * s + 1]) % modul;
}
int get(int s, int ll, int rr, int u, int v) {
if (rr < u || v < ll) return 0;
progress(s, ll, rr);
if (u <= ll && rr <= v) return sb[s];
return (get(2 * s, ll, (ll + rr) / 2, u, v) +
get(2 * s + 1, (ll + rr) / 2 + 1, rr, u, v)) %
modul;
}
void solve(int i) {
dd[i] = true;
for (int j = 0; j < t[i].size(); j++) {
pair<int, int> u = t[i][j];
ans[u.second] = ((2 * get(1, 1, n, l[u.first], r[u.first])) % modul -
get(1, 1, n, 1, n) + modul) %
modul;
}
for (int j = 0; j < g[i].size(); j++) {
pair<int, int> u = g[i][j];
if (!dd[u.first]) {
update(1, 1, n, 1, n, u.second);
update(1, 1, n, l[u.first], r[u.first],
(modul - (2 * u.second) % modul) % modul);
solve(u.first);
update(1, 1, n, 1, n, (modul - u.second) % modul);
update(1, 1, n, l[u.first], r[u.first], (2 * u.second) % modul);
}
}
}
int main() {
scanf("%d", &n);
int x, y, z;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
g[x].push_back(pair<int, int>(y, z));
g[y].push_back(pair<int, int>(x, z));
}
scanf("%d", &q);
dfs(1);
build(1, 1, n);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
t[x].push_back(pair<int, int>(y, i));
}
solve(1);
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
const int Maxn = 100010;
vector<pair<int, int> > G[Maxn];
int n;
int hh[Maxn], h[Maxn], pre[Maxn], fin[Maxn], sz[Maxn];
int f[Maxn][20];
int dfs_t;
inline void up(int &x, int y) {
x += y;
if (x >= M) x -= M;
}
inline int sqr(int x) { return x * (long long)x % M; }
int sum[Maxn << 2], ssum[Maxn << 2];
int toall[Maxn], upp[Maxn], down[Maxn], uupp[Maxn], ddown[Maxn];
void add(int tar, int w, int l, int r, int x) {
if (l == r) {
sum[x] = w;
ssum[x] = w * (long long)w % M;
return;
}
int mid = (l + r) >> 1;
if (tar <= mid)
add(tar, w, l, mid, x << 1);
else
add(tar, w, mid + 1, r, x << 1 | 1);
sum[x] = sum[x << 1];
up(sum[x], sum[x << 1 | 1]);
ssum[x] = ssum[x << 1];
up(ssum[x], ssum[x << 1 | 1]);
}
int query(int *tree, int L, int R, int l, int r, int x) {
if (L <= l && R >= r) return tree[x];
int mid = (l + r) >> 1;
int ret = 0;
if (L <= mid) up(ret, query(tree, L, R, l, mid, x << 1));
if (R > mid) up(ret, query(tree, L, R, mid + 1, r, x << 1 | 1));
return ret;
}
void dfs(int u, int fa) {
pre[u] = ++dfs_t;
add(dfs_t, hh[u], 1, n, 1);
f[u][0] = fa;
sz[u] = 1;
for (int i = 1; f[u][i - 1]; i++) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first, w = G[u][i].second;
if (v == fa) continue;
hh[v] = hh[u];
up(hh[v], w);
h[v] = h[u] + 1;
dfs(v, u);
sz[u] += sz[v];
}
fin[u] = dfs_t;
}
void dfs2(int u, int fa) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first, w = G[u][i].second;
if (v == fa) continue;
dfs2(v, u);
int t = down[v];
up(t, sz[v] * (long long)w % M);
up(down[u], t);
t = ddown[v];
up(t, sz[v] * (long long)w % M * w % M);
up(t, 2 * (long long)w * down[v] % M);
up(ddown[u], t);
}
}
void dfs3(int u, int fa) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first, w = G[u][i].second;
if (v == fa) continue;
int t = ((down[u] - down[v] + M) % M - sz[v] * (long long)w % M + M) % M;
upp[v] = upp[u];
up(upp[v], t);
up(upp[v], (n - sz[v]) * (long long)w % M);
toall[v] = toall[u];
t = n * (long long)w % M * w % M;
t = (M - t) % M;
up(toall[v], t);
t = (upp[v] - down[v] + M) % M;
t = t * (long long)w * 2 % M;
up(toall[v], t);
dfs3(v, u);
}
}
void prepare() {
dfs(1, 0);
toall[1] = ssum[1];
dfs2(1, 0);
dfs3(1, 0);
}
int getlca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
int t = h[u] - h[v];
for (int i = 18; i >= 0; i--)
if (t >= (1 << i)) {
t -= (1 << i);
u = f[u][i];
}
for (int i = 18; i >= 0; i--)
if (f[u][i] != f[v][i]) {
u = f[u][i];
v = f[v][i];
}
return u == v ? u : f[u][0];
}
void solve() {
int m;
scanf("%d", &m);
while (m--) {
int u, v;
scanf("%d%d", &v, &u);
int lca = getlca(u, v);
int c1 = ((hh[v] - 2 * (long long)hh[lca]) % M + M) % M;
int c2 = M - hh[v];
if (c2 < 0) c2 += M;
int ans = query(ssum, pre[u], fin[u], 1, n, 1);
int t1 = query(sum, pre[u], fin[u], 1, n, 1);
int t2 = query(sum, pre[v], fin[v], 1, n, 1);
int t3 = t1 - t2;
if (t3 < 0) t3 += M;
if (lca != u) {
up(ans, t1 * (long long)2 * c1 % M);
up(ans, c1 * (long long)c1 % M * sz[u] % M);
} else {
ans = toall[v];
up(ans, ddown[u]);
up(ans, (M - toall[u]) % M);
up(ans, (M - 2 * (long long)(hh[v] - hh[u]) * upp[u] % M) % M);
up(ans, (M - (n - sz[u]) * (long long)sqr(hh[v] - hh[u]) % M) % M);
}
up(ans, ans);
up(ans, (M - toall[v]) % M);
printf("%d\n", ans);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(pair<int, int>(v, w));
G[v].push_back(pair<int, int>(u, w));
}
prepare();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<ll, ll>;
ll const N = 1e5 + 20, LG = 20, mod = 1e9 + 7;
ll n, q;
ll sz[N];
ll in1[N], out1[N];
ll in2[N], out2[N];
vector<ll> g[N];
struct edge {
ll u, v, w;
} e[N];
ll par[LG][N], h[N], d[N];
void pre_dfs(ll v) {
for (ll i = 1; i < LG; i++)
if (~par[i - 1][v]) par[i][v] = par[i - 1][par[i - 1][v]];
for (ll ed : g[v]) {
ll u = e[ed].u ^ e[ed].v ^ v, w = e[ed].w;
if (u != par[0][v]) {
h[u] = h[v] + 1;
d[u] = (d[v] + w) % mod;
par[0][u] = v;
pre_dfs(u);
}
}
}
void dfs_down(ll v, ll par = -1) {
sz[v] = 1;
for (ll ed : g[v]) {
ll u = e[ed].u ^ e[ed].v ^ v, w = e[ed].w;
if (u == par) continue;
dfs_down(u, v);
sz[v] += sz[u];
in1[v] = (in1[v] + (in1[u] + 1ll * sz[u] * w % mod)) % mod;
in2[v] = (in2[v] + (in2[u] + 1ll * w * w % mod * sz[u] % mod +
2ll * w * in1[u] % mod)) %
mod;
}
}
void dfs_up(ll v, ll par = -1) {
for (ll ed : g[v]) {
ll u = e[ed].u ^ e[ed].v ^ v, w = e[ed].w;
if (u == par) continue;
out1[u] = ((in1[v] + out1[v] - (in1[u] + 1ll * sz[u] * w % mod)) +
1ll * (n - sz[u]) * w % mod) %
mod;
out2[u] =
(out2[v] + in2[v] -
(in2[u] + 1ll * w * w % mod * sz[u] % mod + 2ll * w * in1[u] % mod)) %
mod;
out2[u] =
(out2[u] + 1ll * w * w % mod * (n - sz[u]) % mod +
2ll * w * (in1[v] + out1[v] - (in1[u] + 1ll * sz[u] * w % mod))) %
mod;
dfs_up(u, v);
}
}
inline ll lca(ll u, ll v) {
if (h[u] > h[v]) swap(u, v);
for (ll i = 0; i < LG; i++)
if ((h[v] - h[u]) >> i & 1) v = par[i][v];
if (u == v) return u;
for (ll i = LG - 1; ~i; i--)
if (par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
return par[0][u];
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (ll i = 0; i < n - 1; i++) {
ll &u = e[i].u, &v = e[i].v;
cin >> u >> v >> e[i].w;
u--, v--;
g[u].push_back(i);
g[v].push_back(i);
}
memset(par, -1, sizeof par);
pre_dfs(0);
dfs_down(0);
dfs_up(0);
cin >> q;
while (q--) {
ll u, v, ans = 0;
cin >> u >> v;
u--, v--;
ll l = lca(u, v);
ll len = (d[u] + d[v] - 2 * d[l]) % mod;
if (l == v) {
ans = (in2[u] + out2[u] -
(out2[v] + 1ll * len * len % mod * (n - sz[v]) % mod +
2ll * len * out1[v]) %
mod) %
mod;
ans = (+ans - (out2[v] + 1ll * len * len % mod * (n - sz[v]) % mod +
2ll * len * out1[v] % mod)) %
mod;
} else {
ans = (in2[u] + out2[u] -
(in2[v] + 1ll * len * len % mod * sz[v] % mod +
2ll * len * in1[v] % mod)) %
mod;
ans = (-ans + (in2[v] + 1ll * len * len % mod * sz[v] % mod +
2ll * len * in1[v] % mod)) %
mod;
}
cout << (ans + mod) % mod << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, y, z, num;
const int MAXN = 100005;
const int mod = 1e9 + 7;
int b[MAXN];
int nxt[2 * MAXN], cost[2 * MAXN], a[2 * MAXN];
int fa[MAXN][25];
int be[MAXN], en[MAXN];
int sum, m, dep[MAXN];
int len;
int dist[MAXN], sumx[MAXN];
int ans, ans1, ans2;
int sum1[MAXN], sum2[MAXN], siz1[MAXN], siz2[MAXN], sum21[MAXN], sum22[MAXN];
void add(int x, int y, int z) {
++num;
a[num] = y;
nxt[num] = b[x];
cost[num] = z;
b[x] = num;
}
int lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
for (int i = 20; i >= 0; --i) {
if ((1 << i) & (dep[y] - dep[x])) y = fa[y][i];
}
if (x == y) return x;
for (int i = 20; i >= 0; --i) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
void dfs(int x, int ga) {
++sum;
be[x] = sum;
fa[x][0] = ga;
dep[x] = dep[ga] + 1;
for (int i = 1; i <= 20; ++i) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = b[x]; i != 0; i = nxt[i]) {
int y = a[i];
if (y == ga) continue;
dist[y] = dist[x] + cost[i];
dist[y] %= mod;
dfs(y, x);
}
en[x] = sum;
}
void worksub(int x) {
int dq;
siz1[x] = 1;
sum1[x] = 0;
sum21[x] = 0;
for (int i = b[x]; i != 0; i = nxt[i]) {
int y = a[i];
if (y == fa[x][0]) continue;
worksub(y);
dq = sum21[y];
dq += 2LL * cost[i] * sum1[y] % mod;
dq %= mod;
dq += 1LL * cost[i] * cost[i] % mod * siz1[y] % mod;
dq %= mod;
sum21[x] += dq;
sum21[x] %= mod;
sum1[x] += sum1[y];
sum1[x] %= mod;
sum1[x] += 1LL * cost[i] * siz1[y] % mod;
sum1[x] %= mod;
siz1[x] += siz1[y];
siz1[x] %= mod;
}
}
void workout(int x) {
int dq;
for (int i = b[x]; i != 0; i = nxt[i]) {
int y = a[i];
if (y == fa[x][0]) continue;
siz2[y] = siz2[x] + siz1[x] - siz1[y];
sum2[y] =
sum2[x] +
(sum1[x] - sum1[y] + mod - 1LL * siz1[y] * cost[i] % mod + mod) % mod;
sum2[y] %= mod;
sum2[y] += 1LL * cost[i] * siz2[x] % mod;
sum2[y] %= mod;
sum2[y] += 1LL * cost[i] * (siz1[x] - siz1[y]) % mod;
sum2[y] %= mod;
sum22[y] = sum22[x];
sum22[y] += 1LL * cost[i] * cost[i] % mod * siz2[x] % mod;
sum22[y] %= mod;
sum22[y] += 2LL * cost[i] * sum2[x] % mod;
sum22[y] %= mod;
sum22[y] += sum21[x];
sum22[y] %= mod;
sum22[y] = (sum22[y] - sum21[y] + mod) % mod;
sum22[y] =
(sum22[y] - 1LL * cost[i] * cost[i] % mod * siz1[y] % mod + mod) % mod;
sum22[y] = (sum22[y] - 2LL * cost[i] * sum1[y] % mod + mod) % mod;
sum22[y] =
(sum22[y] + 1LL * cost[i] * cost[i] % mod * (siz1[x] - siz1[y]) % mod) %
mod;
sum22[y] = (sum22[y] + 2LL * cost[i] *
(sum1[x] - sum1[y] + mod -
1LL * siz1[y] * cost[i] % mod + mod) %
mod) %
mod;
workout(y);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
add(y, x, z);
}
dfs(1, 0);
worksub(1);
workout(1);
for (int i = 1; i <= n; ++i) sumx[i] = (sum21[i] + sum22[i]) % mod;
scanf("%d", &m);
while (m--) {
scanf("%d%d", &x, &y);
if (be[x] >= be[y] && be[x] <= en[y]) {
ans = sum22[y];
len = (dist[x] - dist[y]) % mod + mod;
len %= mod;
ans += 1LL * len * len % mod * siz2[y] % mod;
ans %= mod;
ans += 2LL * len * sum2[y] % mod;
ans %= mod;
ans1 = sumx[x] - ans + mod;
ans1 %= mod;
ans2 = ans;
ans = ans1 - ans2 + mod;
ans %= mod;
} else {
ans = sum21[y];
z = lca(x, y);
len = dist[x] - dist[z];
len %= mod;
len = (len + mod) % mod;
len += dist[y] - dist[z];
len %= mod;
len = (len + mod) % mod;
ans += 1LL * len * len % mod * siz1[y] % mod;
ans %= mod;
ans += 2LL * len * sum1[y] % mod;
ans %= mod;
ans1 = ans;
ans2 = sumx[x] - ans + mod;
ans2 %= mod;
ans = ans1 - ans2 + mod;
ans %= mod;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long max(long long x, long long y) { return x > y ? x : y; }
inline long long min(long long x, long long y) { return x > y ? y : x; }
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
const long long N = 1e5 + 10;
const long long mod = 1e9 + 7;
long long n, head[N], cnt, fa[N][37], dep[N], dis[N], sz[N];
long long f[N], g[N], ff[N], gg[N];
struct node {
long long to, next, dis;
} edge[N << 1];
inline void add(long long u, long long v, long long w) {
edge[++cnt] = {v, head[u], w};
head[u] = cnt;
}
inline long long div(long long x) { return (x % mod + mod) % mod; }
inline void build(long long u, long long pre) {
fa[u][0] = pre, dep[u] = dep[pre] + 1, sz[u] = 1;
for (long long i = 0; fa[u][i]; i++) fa[u][i + 1] = fa[fa[u][i]][i];
for (long long i = head[u]; i; i = edge[i].next) {
long long v = edge[i].to, w = edge[i].dis;
if (v == pre) continue;
dis[v] = (dis[u] + w) % mod;
build(v, u);
sz[u] += sz[v];
f[u] = div(f[u] + f[v] + sz[v] * w) % mod;
g[u] =
div(div(g[u] + g[v] + f[v] * w % mod * 2) + sz[v] * w % mod * w % mod);
}
}
inline void dfs(long long u, long long fa) {
for (long long i = head[u]; i; i = edge[i].next) {
long long v = edge[i].to, w = edge[i].dis % mod;
if (v == fa) continue;
ff[v] = div(ff[u] + (n - 2 * sz[v]) * w);
gg[v] = div(gg[u] + (g[u] - g[v]) % mod - sz[v] * w % mod * w % mod -
2 * w * f[v] % mod);
gg[v] = div(gg[v] + 2 * w * div(ff[u] - f[v] - sz[v] * w) % mod +
w * w % mod * (n - sz[v]) % mod);
dfs(v, u);
}
}
inline long long LCA(long long u, long long v) {
if (dep[u] > dep[v]) swap(u, v);
for (long long i = 30; i >= 0; i--)
if (dep[v] - (1 << i) >= dep[u]) v = fa[v][i];
if (u == v) return u;
for (long long i = 30; i >= 0; i--)
if (fa[v][i] != fa[u][i]) v = fa[v][i], u = fa[u][i];
return fa[u][0];
}
signed main() {
n = read();
long long u, v, w;
for (long long i = 1; i < n; i++) {
u = read(), v = read(), w = read();
add(u, v, w);
add(v, u, w);
}
build(1, 0);
for (long long i = 1; i <= n; i++) ff[i] = f[i];
dfs(1, 0);
long long q = read(), ans = 0, lca, d;
for (long long i = 1; i <= q; i++) {
u = read(), v = read();
lca = LCA(u, v);
d = div(dis[u] + dis[v] - 2 * dis[lca]);
ans = 0;
if (lca == v) {
ans = div(ans + g[u] + gg[u] - gg[v] - (n - sz[v]) * d % mod * d % mod -
2 * d * (ff[v] - f[v]) % mod);
ans = div(ans - div(gg[v] + d * d % mod * (n - sz[v]) +
2 * d * (ff[v] - f[v])));
} else {
ans = div(ans + d * d % mod * sz[v] + 2 * f[v] * d % mod + g[v]);
ans = div(ans - div(gg[u] + g[u] - g[v] - d * d % mod * sz[v] % mod -
2 * f[v] * d % mod));
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long n, m, x, y, z, fa[300000], top[300000], dep[300000], sz[300000], tot,
head[300000];
struct poly {
long long f[3];
poly() { memset(f, 0, sizeof f); }
poly operator+(const poly &g) const {
poly h;
for (long long i = 0; i < 3; i++) h.f[i] = (f[i] + g.f[i]) % mod;
return h;
}
void operator+=(const poly &g) { *this = *this + g; }
poly operator-(const poly &g) const {
poly h;
for (long long i = 0; i < 3; i++) h.f[i] = (f[i] - g.f[i] + mod) % mod;
return h;
}
void operator-=(const poly &g) { *this = *this - g; }
long long operator()(long long k) const {
long long ret = 0;
k %= mod;
for (long long i = 2; i >= 0; i--) ret = (ret * k + f[i]) % mod;
return ret;
}
poly operator<<(long long k) const {
poly g;
k %= mod;
for (long long i = 2; i >= 0; i--) {
for (long long j = 2; j; j--) g.f[j] = (g.f[j] * k + g.f[j - 1]) % mod;
g.f[0] = (g.f[0] * k + f[i]) % mod;
}
return g;
}
} f[300000], g[300000];
struct edge {
long long v, l, nxt;
} e[300000];
void add(long long x, long long y, long long z) {
e[++tot].v = y;
e[tot].l = z;
e[tot].nxt = head[x];
head[x] = tot;
}
void dfs1(long long u) {
f[u].f[2] = 1;
for (long long i = head[u], v; i; i = e[i].nxt)
if ((v = e[i].v) != fa[u]) {
fa[v] = u;
dep[v] = dep[u] + e[i].l;
dfs1(v);
sz[u] += sz[v];
f[u] += f[v] << e[i].l;
}
if (!sz[u]) ++sz[u];
}
void dfs2(long long u) {
for (long long i = head[u], v; i; i = e[i].nxt)
if ((v = e[i].v) != fa[u])
g[v] = g[u] + (f[u] << (-dep[u])) - (f[v] << (-dep[u] + e[i].l));
if (!top[u]) top[u] = u;
long long t = 0;
for (long long i = head[u], v; i; i = e[i].nxt)
if ((v = e[i].v) != fa[u] && sz[v] > sz[t]) t = v;
if (!t) return;
top[t] = top[u];
dfs2(t);
for (long long i = head[u], v; i; i = e[i].nxt)
if ((v = e[i].v) != fa[u] && v != t) dfs2(v);
}
long long lca(long long u, long long v) {
for (; top[u] != top[v]; u = fa[top[u]])
if (dep[top[u]] < dep[top[v]]) swap(u, v);
return dep[u] < dep[v] ? u : v;
}
long long ddd(long long x, long long y) {
long long z = lca(x, y);
if (z == y)
return ((f[x](0) + g[x](dep[x]) - g[y](dep[x])) % mod + mod) % mod;
return f[y](dep[x] + dep[y] - dep[z] * 2);
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i < n; i++) {
scanf("%lld%lld%lld", &x, &y, &z);
add(x, y, z);
add(y, x, z);
}
dfs1(1);
dfs2(1);
scanf("%lld", &m);
for (long long i = 1; i <= m; i++) {
scanf("%lld%lld", &x, &y);
printf("%lld\n", ((ddd(x, y) * 2 - ddd(x, 1)) % mod + mod) % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const N = 1e5 + 20, mod = 1e9 + 7;
long long n, q, ans[N], h[N], st[N], ft[N], tme;
long long sum1[N << 2], sum2[N << 2], lazy[N << 2];
vector<pair<long long, long long> > g[N], vec[N];
inline void add(long long& a, const long long& b) {
a = (a + b % mod + mod) % mod;
}
void dfs1(long long v, long long par = -1) {
st[v] = tme++;
for (auto ed : g[v]) {
long long u, w;
tie(u, w) = ed;
if (u != par) h[u] = (h[v] + w) % mod, dfs1(u, v);
}
ft[v] = tme;
}
inline void add(long long v, long long s, long long e, long long val) {
add(lazy[v], val);
add(sum2[v], val * val % mod * (e - s) + 2 * val * sum1[v]);
add(sum1[v], (e - s) * val);
}
inline void shift(long long v, long long s, long long e, long long mid,
long long lc, long long rc) {
add(lc, s, mid, lazy[v]);
add(rc, mid, e, lazy[v]);
lazy[v] = 0;
}
void upd(long long l, long long r, long long val, long long v = 1,
long long s = 0, long long e = n) {
if (s >= r || e <= l) return;
if (s >= l && e <= r) {
add(v, s, e, val);
return;
}
long long mid = (s + e) >> 1, lc = v << 1, rc = lc | 1;
shift(v, s, e, mid, lc, rc);
upd(l, r, val, lc, s, mid), upd(l, r, val, rc, mid, e);
sum1[v] = (sum1[lc] + sum1[rc]) % mod, sum2[v] = (sum2[lc] + sum2[rc]) % mod;
}
long long get(long long l, long long r, long long v = 1, long long s = 0,
long long e = n) {
if (s >= r || e <= l) return 0;
if (s >= l && e <= r) return sum2[v];
long long mid = (s + e) >> 1, lc = v << 1, rc = lc | 1;
shift(v, s, e, mid, lc, rc);
return (get(l, r, lc, s, mid) + get(l, r, rc, mid, e)) % mod;
}
void dfs2(long long v, long long par = -1, long long wtopar = -1) {
if (v) upd(0, n, wtopar), upd(st[v], ft[v], -2 * wtopar);
for (auto x : vec[v])
ans[x.second] = -get(0, n) + 2 * get(st[x.first], ft[x.first]);
for (auto ed : g[v]) {
long long u, w;
tie(u, w) = ed;
if (u != par) dfs2(u, v, w);
}
if (v) upd(0, n, -wtopar), upd(st[v], ft[v], 2 * wtopar);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0, u, v, w; i < n - 1; i++) {
cin >> u >> v >> w;
u--, v--;
g[u].push_back({v, w}), g[v].push_back({u, w});
}
cin >> q;
for (long long i = 0, u, v; i < q; i++) {
cin >> u >> v;
u--, v--;
vec[u].push_back({v, i});
}
dfs1(0);
for (long long i = 0; i < n; i++) upd(st[i], st[i] + 1, h[i]);
dfs2(0);
for (long long i = 0; i < q; i++) cout << (ans[i] + mod) % mod << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, h[100001], root[100001], par[100001][25], size[100001],
dp_down_0[100001], dp_down_1[100001], dp_up_0[100001], dp_up_1[100001];
vector<pair<long long int, long long int> > v[100001];
long long int add(long long int x, long long int y) {
return (x + y) % 1000000007;
}
long long int mul(long long int x, long long int y) {
return (1LL * x * y) % 1000000007;
}
long long int sub(long long int x, long long int y) {
return (x - y + 1000000007) % 1000000007;
}
long long int sq(long long int x) { return (1LL * x * x) % 1000000007; }
void dfs_down(long long int cur, long long int p) {
if (p != -1) h[cur] = h[p] + 1;
par[cur][0] = p;
for (long long int i = 1; i < 20; i++) {
if (par[cur][i - 1] != -1) par[cur][i] = par[par[cur][i - 1]][i - 1];
}
size[cur] = 1;
for (long long int i = 0; i < v[cur].size(); i++) {
long long int x = v[cur][i].first;
if (x == p) continue;
root[x] = add(root[cur], v[cur][i].second);
dfs_down(x, cur);
size[cur] += size[x];
dp_down_0[cur] = add(dp_down_0[cur], dp_down_0[x]);
dp_down_0[cur] = add(dp_down_0[cur], mul(size[x], v[cur][i].second));
dp_down_1[cur] = add(dp_down_1[cur], mul(size[x], sq(v[cur][i].second)));
dp_down_1[cur] = add(dp_down_1[cur], dp_down_1[x]);
dp_down_1[cur] =
add(dp_down_1[cur], mul(2, mul(v[cur][i].second, dp_down_0[x])));
}
}
void dfs_up(long long int cur, long long int p, long long int wt) {
if (p != -1) {
dp_up_0[cur] = add(dp_up_0[cur], dp_up_0[p]);
dp_up_0[cur] = add(dp_up_0[cur], mul(n - size[p], wt));
long long int x = dp_down_0[p];
x = sub(x, dp_down_0[cur]);
x = sub(x, mul(size[cur], wt));
dp_up_0[cur] = add(dp_up_0[cur], x);
dp_up_0[cur] = add(dp_up_0[cur], mul(wt, size[p] - size[cur]));
dp_up_1[cur] = add(dp_up_1[cur], dp_up_1[p]);
dp_up_1[cur] = add(dp_up_1[cur], mul(n - size[p], sq(wt)));
dp_up_1[cur] = add(dp_up_1[cur], mul(2, mul(wt, dp_up_0[p])));
x = dp_down_1[p];
x = sub(x, dp_down_1[cur]);
x = sub(x, mul(2, mul(wt, dp_down_0[cur])));
x = sub(x, mul(size[cur], sq(wt)));
long long int y = dp_down_0[p];
y = sub(y, dp_down_0[cur]);
y = sub(y, mul(wt, size[cur]));
dp_up_1[cur] = add(dp_up_1[cur], x);
dp_up_1[cur] = add(dp_up_1[cur], mul(2, mul(wt, y)));
dp_up_1[cur] = add(dp_up_1[cur], mul(sq(wt), size[p] - size[cur]));
}
for (long long int i = 0; i < v[cur].size(); i++) {
long long int x = v[cur][i].first;
if (x == p) continue;
dfs_up(x, cur, v[cur][i].second);
}
}
int lca(int v, int u) {
if (h[v] < h[u]) swap(v, u);
for (int i = 20 - 1; i >= 0; i--) {
if (par[v][i] != -1 && h[par[v][i]] >= h[u]) {
v = par[v][i];
}
}
if (v == u) return u;
for (int i = 20 - 1; i >= 0; i--) {
if (par[v][i] - par[u][i]) v = par[v][i], u = par[u][i];
}
return par[v][0];
}
long long int distance(long long int x, long long int y) {
long long int ans = root[x];
ans = add(ans, root[y]);
ans = sub(ans, mul(2, root[lca(x, y)]));
return ans;
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
long long int i, j, q, x, y, ans, temp, z, lc, dist;
memset(par, -1, sizeof par);
cin >> n;
for (i = 1; i <= n - 1; i++) {
cin >> x >> y >> z;
v[x].push_back(make_pair(y, z));
v[y].push_back(make_pair(x, z));
}
dfs_down(1, -1);
dfs_up(1, -1, 0);
cin >> q;
while (q--) {
cin >> x >> y;
dist = distance(x, y);
lc = lca(x, y);
if ((lc != x && lc != y) || lc == x) {
ans = dp_down_1[y];
ans = add(ans, mul(sq(dist), size[y]));
ans = add(ans, mul(2, mul(dist, dp_down_0[y])));
ans = mul(2, ans);
ans = sub(ans, dp_down_1[x]);
ans = sub(ans, dp_up_1[x]);
cout << ans << "\n";
} else if (lc == y) {
ans = dp_down_1[x];
temp = dp_up_1[x];
temp = sub(temp, dp_up_1[y]);
temp = sub(temp, mul(2, mul(dist, dp_up_0[y])));
temp = sub(temp, mul(n - size[y], sq(dist)));
ans = add(ans, temp);
ans = mul(2, ans);
ans = sub(ans, dp_down_1[x]);
ans = sub(ans, dp_up_1[x]);
cout << ans << "\n";
} else
assert(false);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
inline void add(int& a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
const int N = 100002;
int a, b, c, d, n, m, k;
vector<pair<int, int> > sm[N];
int cnt[N], sum[N], ss[N];
bool bad[N];
void dfsr(int v, int pr, int* cnt, int* sum, int* ss) {
cnt[v] = 1;
sum[v] = 0;
ss[v] = 0;
for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[v][i].first;
if (w == pr || bad[w]) continue;
dfsr(w, v, cnt, sum, ss);
cnt[v] += cnt[w];
add(sum[v], sum[w]);
sum[v] = (sum[v] + (long long)cnt[w] * sm[v][i].second) % 1000000007;
add(ss[v], ss[w]);
ss[v] = (ss[v] + (long long)sm[v][i].second * sm[v][i].second % 1000000007 *
cnt[w]) %
1000000007;
ss[v] = (ss[v] + 2LL * sm[v][i].second * sum[w]) % 1000000007;
}
}
int ovss[N], ovsum[N], sub[N];
int dfs_cnt(int v, int pr) {
int ans = 1;
for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[v][i].first;
if (w == pr || bad[w]) continue;
ans += dfs_cnt(w, v);
}
return ans;
}
pair<int, int> dfs_cen(int v, int pr, int ov) {
pair<int, int> t = make_pair(1000000000, v);
sub[v] = 1;
int mx = 0;
for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[v][i].first;
if (w == pr || bad[w]) continue;
pair<int, int> tt = dfs_cen(w, v, ov);
t = min(t, tt);
sub[v] += sub[w];
mx = max(mx, sub[w]);
}
mx = max(mx, ov - sub[v]);
t = min(t, make_pair(mx, v));
return t;
}
int pcnt[N], psum[N], pss[N];
void dfs_part(int v, int pr, int sumsof, int cntrem, int sumrem, int sqrem) {
ovsum[v] = (ovsum[v] + sumrem + (long long)sumsof * cntrem) % 1000000007;
ovss[v] =
(ovss[v] + sqrem + (long long)sumsof * sumsof % 1000000007 * cntrem +
2LL * sumsof * sumrem) %
1000000007;
for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[v][i].first;
if (w == pr || bad[w]) continue;
dfs_part(w, v, (sumsof + sm[v][i].second) % 1000000007, cntrem, sumrem,
sqrem);
}
}
void rec(int s) {
int ov = dfs_cnt(s, -1);
pair<int, int> t = dfs_cen(s, -1, ov);
s = t.second;
dfsr(s, -1, pcnt, psum, pss);
add(ovss[s], pss[s]);
add(ovsum[s], psum[s]);
for (int _n(((int)((sm[s]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[s][i].first;
if (bad[w]) continue;
int cntrem = pcnt[s] - pcnt[w];
int sumrem =
(psum[s] - psum[w] - (long long)sm[s][i].second * pcnt[w]) % 1000000007;
if (sumrem < 0) sumrem += 1000000007;
int sqrem =
(pss[s] - pss[w] -
(long long)sm[s][i].second * sm[s][i].second % 1000000007 * pcnt[w] -
2LL * sm[s][i].second * psum[w]) %
1000000007;
if (sqrem < 0) sqrem += 1000000007;
dfs_part(w, s, sm[s][i].second, cntrem, sumrem, sqrem);
}
bad[s] = 1;
for (int _n(((int)((sm[s]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[s][i].first;
if (bad[w]) continue;
rec(w);
}
}
int up[100002][18];
int tin[100002], tout[100002], ct;
int hg[100002];
void dfs_lca(int v, int p = 0) {
tin[v] = ++ct;
up[v][0] = p;
for (int i = 1; i <= 17; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
for (size_t i = 0; i < sm[v].size(); ++i) {
int to = sm[v][i].first;
if (to != p) {
hg[to] = (hg[v] + sm[v][i].second) % 1000000007;
dfs_lca(to, v);
}
}
tout[v] = ++ct;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = 17; i >= 0; --i)
if (!upper(up[a][i], b)) a = up[a][i];
return up[a][0];
}
int main() {
scanf("%d", &n);
for (int _n((n - 1) - 1), i(0); i <= _n; i++) {
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
sm[a].push_back(make_pair(b, c));
sm[b].push_back(make_pair(a, c));
}
dfsr(0, -1, cnt, sum, ss);
rec(0);
dfs_lca(0);
scanf("%d", &m);
for (int _n((m)-1), i(0); i <= _n; i++) {
scanf("%d%d", &a, &b);
--a;
--b;
int toall = ovss[a];
int l = lca(a, b);
int ans = 0, sub = 0;
int len = (hg[a] - hg[l] + hg[b] - hg[l]) % 1000000007;
if (len < 0) len += 1000000007;
if (!upper(b, a)) {
sub = (ss[b] + (long long)len * len % 1000000007 * cnt[b] +
2LL * len * sum[b]) %
1000000007;
} else {
int ssnd = ovss[b] - ss[b];
if (ssnd < 0) ssnd += 1000000007;
int snd = ovsum[b] - sum[b];
if (snd < 0) snd += 1000000007;
int cnd = n - cnt[b];
sub = (ovss[a] - ssnd - (long long)len * len % 1000000007 * cnd -
2LL * len * snd) %
1000000007;
if (sub < 0) sub += 1000000007;
}
ans = (2LL * sub - toall) % 1000000007;
if (ans < 0) ans += 1000000007;
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long const M = 1e5 + 10, mod = 1e9 + 7, inf = 1e9 + 10;
long long par[M][30], dp[M], zt[M], sum[M], val[M][30], sum2[M], n, dp2[M],
len = 0, h[M];
vector<long long> adj[M], edg[M], inc[M];
long long mrg(long long x, long long y, long long sm, long long cnt) {
long long ans = (x + ((y * y) % mod) * cnt + ((sm * y) % mod) * 2) % mod;
return ans;
}
void dfs_down(long long v, long long l, long long c) {
zt[v] = 1;
val[v][0] = c;
h[v] = h[l] + 1;
par[v][0] = l;
for (long long i = 1; i <= 20; i++) {
par[v][i] = par[par[v][i - 1]][i - 1];
val[v][i] = val[par[v][i - 1]][i - 1] + val[v][i - 1];
val[v][i] %= mod;
}
for (long long i = 0; i < adj[v].size(); i++) {
long long u = adj[v][i];
if (u != l) dfs_down(u, v, edg[v][i]);
if (u == l) {
inc[v].push_back(0);
continue;
}
zt[v] += zt[u];
sum[v] += sum[u];
sum[v] %= mod;
sum[v] += edg[v][i] * zt[u];
sum[v] %= mod;
long long res = mrg(dp[u], edg[v][i], sum[u], zt[u]);
inc[v].push_back(res);
dp[v] += res;
dp[v] %= mod;
}
dp2[v] = dp[v];
}
void dfs_up(long long v, long long l, long long c, long long cc) {
if (v == 1) sum2[v] = sum[v];
if (v != 1) {
sum2[v] += (sum2[l] - ((cc * zt[v] + sum[v]) % mod) + mod) % mod;
sum2[v] %= mod;
long long res = dp[l] - c;
res += mod;
res %= mod;
dp[v] += mrg(res, cc, sum2[v], n - zt[v]);
dp[v] %= mod;
sum2[v] += sum[v];
sum2[v] %= mod;
sum2[v] += cc * (n - zt[v]);
sum2[v] %= mod;
}
for (long long i = 0; i < adj[v].size(); i++) {
long long u = adj[v][i];
if (u != l) dfs_up(u, v, inc[v][i], edg[v][i]);
}
}
long long lca(long long v, long long u) {
if (h[v] < h[u]) swap(v, u);
for (long long i = 20; i >= 0; i--) {
if (h[v] - (1 << i) >= h[u]) len += val[v][i], v = par[v][i];
}
len %= mod;
if (v == u) return v;
for (long long i = 20; i >= 0; i--) {
if (par[v][i] != par[u][i])
len += val[v][i], len += val[u][i], v = par[v][i], u = par[u][i];
}
len += val[v][0];
len += val[u][0];
len %= mod;
v = par[v][0];
return v;
}
int32_t main() {
cin >> n;
for (long long i = 1; i <= n - 1; i++) {
long long a, b, c;
cin >> a >> b >> c;
adj[a].push_back(b);
adj[b].push_back(a);
edg[a].push_back(c);
edg[b].push_back(c);
}
dfs_down(1, 0, 0);
dfs_up(1, 0, 0, 0);
long long q;
cin >> q;
while (q--) {
long long v, u;
cin >> u >> v;
len = 0;
long long lc = lca(u, v);
len %= mod;
long long all = 0;
if (lc != v) {
all = -dp[u];
all += mod;
all %= mod;
long long res = mrg(dp2[v], len, sum[v], zt[v]);
all += res * 2;
all %= mod;
} else {
all = dp[u];
long long res = sum2[v] - sum[v];
long long bad = dp[v] - dp2[v];
bad += mod;
bad %= mod;
res += mod;
res %= mod;
long long hlp = mrg(bad, len, res, n - zt[v]);
all -= 2 * hlp;
all += 3 * mod;
all %= mod;
}
cout << all << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const long long mod = 1e9 + 7;
int n, q;
;
vector<int> adj[maxn];
vector<int> edge[maxn];
vector<pair<int, int> > Q[maxn];
int st[maxn], ed[maxn], Node[maxn], cur;
long long h[maxn];
long long ans[maxn];
void dfs(int v, int par) {
st[v] = ++cur;
Node[cur] = v;
for (int i = 0; i < adj[v].size(); ++i) {
int u = adj[v][i];
int c = edge[v][i];
if (u == par) continue;
h[u] = (h[v] + c) % mod;
dfs(u, v);
;
}
ed[v] = cur;
}
struct node {
long long dis, disSquare, lazy;
node() {
dis = 0;
disSquare = 0;
lazy = 0;
}
void merge(node L, node R) {
dis = (L.dis + R.dis) % mod;
disSquare = (L.disSquare + R.disSquare) % mod;
}
} seg[4 * maxn];
void build(int idx, int i, int j) {
if (i == j) {
int v = Node[i];
seg[idx].dis = h[v];
seg[idx].disSquare = (h[v] * h[v]) % mod;
return;
}
int mid = (i + j) >> 1;
int left = idx << 1;
int right = left | 1;
build(left, i, mid);
build(right, mid + 1, j);
seg[idx].merge(seg[left], seg[right]);
}
void refresh(int idx, int i, int j) {
int left = idx << 1;
int right = left | 1;
long long add = seg[idx].lazy;
if (i != j) {
seg[left].lazy = (seg[left].lazy + add) % mod;
seg[right].lazy = (seg[right].lazy + add) % mod;
}
long long sz = j - i + 1;
seg[idx].disSquare =
(seg[idx].disSquare + ((2LL * add % mod) * seg[idx].dis % mod) +
((sz * add % mod) * add % mod)) %
mod;
seg[idx].dis = (seg[idx].dis + add * sz) % mod;
seg[idx].lazy = 0;
}
void update(int idx, int i, int j, int l, int r, long long val) {
refresh(idx, i, j);
if (i > j || j < l || r < i) return;
if (l <= i && j <= r) {
seg[idx].lazy = (seg[idx].lazy + val) % mod;
refresh(idx, i, j);
return;
}
int mid = (i + j) >> 1;
int left = idx << 1;
int right = left | 1;
update(left, i, mid, l, r, val);
update(right, mid + 1, j, l, r, val);
seg[idx].merge(seg[left], seg[right]);
}
node query(int idx, int i, int j, int l, int r) {
refresh(idx, i, j);
if (i > j || j < l || r < i) return node();
if (l <= i && j <= r) return seg[idx];
int mid = (i + j) >> 1;
int left = idx << 1;
int right = left | 1;
node L = query(left, i, mid, l, r);
node R = query(right, mid + 1, j, l, r);
node ret;
ret.merge(L, R);
return ret;
}
void dfsSolve(int v, int par) {
long long Sum = query(1, 1, n, 1, n).disSquare;
for (int i = 0; i < Q[v].size(); ++i) {
int u = Q[v][i].first;
int id = Q[v][i].second;
int L = st[u];
int R = ed[u];
long long subSum = query(1, 1, n, L, R).disSquare;
ans[id] = ((2LL * subSum % mod - Sum) % mod + mod) % mod;
}
for (int i = 0; i < adj[v].size(); ++i) {
int u = adj[v][i];
int c = edge[v][i];
if (u == par) continue;
int L = st[u];
int R = ed[u];
update(1, 1, n, 1, n, +c);
update(1, 1, n, L, R, -c * 2);
dfsSolve(u, v);
update(1, 1, n, 1, n, -c);
update(1, 1, n, L, R, +c * 2);
}
}
void solve() {
dfs(1, -1);
build(1, 1, n);
dfsSolve(1, -1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
adj[a].push_back(b);
adj[b].push_back(a);
edge[a].push_back(c);
edge[b].push_back(c);
}
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
int u, v;
scanf("%d %d", &u, &v);
Q[u].push_back({v, i});
}
solve();
for (int i = 1; i <= q; ++i) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100005];
vector<long long> vals[100005];
long long sdp[100005], sum[100005], dp[100005], upper[100005], upsum[100005];
long long ssum[100005];
int sz[100005];
long long dist[100005];
int depth[100005];
long long dist_to_p[100005];
int pa[100005][21] = {0};
void dfs(int x, int p) {
int omar = adj[x].size();
sz[x] = 1;
sum[0] = 0;
sdp[0] = 0;
for (int i = 0; i < omar; ++i) {
if (adj[x][i] == p) continue;
int u = adj[x][i];
depth[u] = depth[x] + 1;
pa[u][0] = x;
dist[u] = dist[x] + vals[x][i];
dist_to_p[u] = vals[x][i];
dfs(u, x);
sum[x] += sz[u] * vals[x][i] + sum[u];
sum[x] %= 1000000007;
sz[x] += sz[u];
sdp[x] += (sz[u] * ((vals[x][i] * vals[x][i]) % 1000000007)) % 1000000007 +
2 * sum[u] * vals[x][i] % 1000000007 + sdp[u];
sdp[x] %= 1000000007;
}
}
void solve(int x, int p) {
dp[x] = sdp[x];
ssum[x] = sum[x];
if (x != 1) {
int szupper = sz[1] - sz[x];
dp[x] +=
(szupper * ((dist_to_p[x] * dist_to_p[x]) % 1000000007)) % 1000000007 +
2 * upsum[x] * dist_to_p[x] % 1000000007 + upper[x];
dp[x] %= 1000000007;
sum[x] += upsum[x] + szupper * dist_to_p[x];
sum[x] %= 1000000007;
}
int omar = adj[x].size();
for (int i = 0; i < omar; ++i) {
if (adj[x][i] == p) continue;
int u = adj[x][i];
upsum[u] = sum[x] - sz[u] * vals[x][i] - sum[u];
upsum[u] %= 1000000007;
if (upsum[u] < 0) upsum[u] += 1000000007;
upper[u] = dp[x];
upper[u] -=
(sz[u] * ((vals[x][i] * vals[x][i]) % 1000000007)) % 1000000007 +
2 * sum[u] * vals[x][i] % 1000000007 + sdp[u];
upper[u] %= 1000000007;
if (upper[u] < 0) upper[u] += 1000000007;
}
for (int i = 0; i < omar; ++i) {
if (adj[x][i] == p) continue;
int u = adj[x][i];
solve(u, x);
}
}
int mxlog = 0;
int n;
void blca() {
while ((1 << mxlog) <= n) mxlog++;
for (int j = 1; j < mxlog; ++j)
for (int i = 1; i <= n; ++i) pa[i][j] = pa[pa[i][j - 1]][j - 1];
}
int lca(int x, int y) {
if (depth[x] < depth[y]) return lca(y, x);
int diff = depth[x] - depth[y];
for (int i = 0; i < mxlog; ++i)
if ((diff & (1 << i))) x = pa[x][i];
if (x == y) return x;
for (int i = mxlog - 1; i >= 0; --i)
if (pa[x][i] != pa[y][i]) x = pa[x][i], y = pa[y][i];
return pa[x][0];
}
int go_up(int x, int diff) {
for (int i = 0; i < mxlog; ++i)
if ((diff & (1 << i))) x = pa[x][i];
return x;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int u, v, val;
scanf("%d%d%d", &u, &v, &val);
adj[u].push_back(v);
adj[v].push_back(u);
vals[u].push_back(val);
vals[v].push_back(val);
}
dfs(1, -1);
solve(1, -1);
blca();
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
long long in;
int lc = lca(u, v);
long long dis =
(dist[u] + dist[v]) % 1000000007 - 2 * dist[lc] % 1000000007;
dis %= 1000000007;
if (dis < 0) dis += 1000000007;
long long omar = 0;
in = (sz[v] * ((dis * dis) % 1000000007)) % 1000000007 +
2 * ssum[v] * dis % 1000000007 + sdp[v];
in %= 1000000007;
if (v != u && lc == v) {
int c = go_up(u, depth[u] - depth[v] - 1);
long long dis2 = dist_to_p[c];
dis += dis2;
omar = (sz[c] * ((dis * dis) % 1000000007)) % 1000000007 +
2 * (ssum[c]) * dis % 1000000007 + sdp[c];
omar %= 1000000007;
in -= omar;
if (in < 0) in += 1000000007;
int szupper = sz[1] - sz[c];
dis -= dis2;
in += dp[u];
in %= 1000000007;
in -= (((szupper * ((dis * dis) % 1000000007)) % 1000000007 +
2 * upsum[c] * dis % 1000000007) %
1000000007 +
upper[c]) %
1000000007;
in %= 1000000007;
omar %= 1000000007;
dis -= dis2;
}
if (in < 0) in += 1000000007;
in %= 1000000007;
in *= 2;
in %= 1000000007;
in -= dp[u];
if (in < 0) in += 1000000007;
cout << in << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline int dec(int a, int b) {
if ((a -= b) < 0) a += mod;
return a;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
int n;
vector<pair<int, int> > v[100010];
class node {
public:
int siz, sum, sqr;
} dp[100010], tot[100010];
int dis[100010], st[100010][18], dep[100010];
void dfs(int np, int fath) {
dp[np] = (node){1, 0, 0};
dep[np] = dep[fath] + 1;
st[np][0] = fath;
for (int i = 1; i < 18; i++) st[np][i] = st[st[np][i - 1]][i - 1];
for (auto &x : v[np]) {
if (x.first == fath) continue;
dis[x.first] = add(dis[np], x.second);
dfs(x.first, np);
dp[np].siz += dp[x.first].siz;
dp[np].sum =
add(add(dp[np].sum, dp[x.first].sum), mult(dp[x.first].siz, x.second));
dp[np].sqr = add(add(dp[np].sqr, dp[x.first].sqr),
add(mult(2, mult(dp[x.first].sum, x.second)),
mult(dp[x.first].siz, mult(x.second, x.second))));
}
}
void dfs2(int np, int fath) {
for (auto &x : v[np]) {
if (x.first == fath) continue;
node tmp;
tmp.siz = tot[np].siz - dp[x.first].siz;
tmp.sum =
dec(tot[np].sum, add(dp[x.first].sum, mult(dp[x.first].siz, x.second)));
tmp.sqr = dec(tot[np].sqr,
add(dp[x.first].sqr,
add(mult(2, mult(dp[x.first].sum, x.second)),
mult(dp[x.first].siz, mult(x.second, x.second)))));
tot[x.first].siz = n;
tot[x.first].sum =
add(add(dp[x.first].sum, tmp.sum), mult(x.second, tmp.siz));
tot[x.first].sqr = add(add(dp[x.first].sqr, tmp.sqr),
add(mult(2, mult(tmp.sum, x.second)),
mult(tmp.siz, mult(x.second, x.second))));
dfs2(x.first, np);
}
}
inline int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 17; i >= 0; i--)
if (dep[st[x][i]] >= dep[y]) x = st[x][i];
if (x == y) return x;
for (int i = 17; i >= 0; i--)
if (st[x][i] != st[y][i]) x = st[x][i], y = st[y][i];
return st[x][0];
}
int main() {
scanf("%d", &n);
for (int i = 1, ti, tj, tk; i < n; i++) {
scanf("%d%d%d", &ti, &tj, &tk);
v[ti].push_back(make_pair(tj, tk));
v[tj].push_back(make_pair(ti, tk));
}
dfs(1, 0);
tot[1] = dp[1];
dfs2(1, 0);
int Q;
scanf("%d", &Q);
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
int l = lca(x, y);
int d = dec(add(dis[x], dis[y]), add(dis[l], dis[l]));
if (l != y) {
int tmp = add(dp[y].sqr, add(mult(2, mult(dp[y].sum, d)),
mult(dp[y].siz, mult(d, d))));
printf("%d\n", dec(add(tmp, tmp), tot[x].sqr));
} else {
node t;
t.siz = tot[y].siz - dp[y].siz;
t.sum = dec(tot[y].sum, dp[y].sum);
t.sqr = dec(tot[y].sqr, dp[y].sqr);
int tmp =
add(t.sqr, add(mult(2, mult(d, t.sum)), mult(t.siz, mult(d, d))));
printf("%d\n", dec(tot[x].sqr, add(tmp, tmp)));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[3], q;
cin >> n;
for (int i = 0; i < 3; i++) a[i] = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n - i; j++) {
cin >> q;
a[i] += q;
}
}
cout << a[0] - a[1] << endl;
cout << a[1] - a[2];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
unordered_multiset<int> a, b;
unordered_multiset<int>::iterator it;
for (int i = 0, x; i < n; i++) {
cin >> x;
a.emplace(x);
b.emplace(x);
}
n--;
for (int i = 0, x; i < n; i++) {
cin >> x;
it = a.find(x);
a.erase(it);
}
cout << *a.begin() << endl;
it = b.find(*a.begin());
b.erase(it);
n--;
for (int i = 0, x; i < n; i++) {
cin >> x;
it = b.find(x);
b.erase(it);
}
cout << *b.begin() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
int x = 0, y = 0, z = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
x += a;
}
for (int i = 1; i <= n - 1; i++) {
cin >> b;
y += b;
}
for (int i = 1; i <= n - 2; i++) {
cin >> c;
z += c;
}
cout << x - y << endl;
cout << y - z;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
scanf("%d", &n);
int asum = 0, bsum = 0, csum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
asum += x;
}
for (int i = 1; i < n; i++) {
scanf("%d", &x);
bsum += x;
}
for (int i = 2; i < n; i++) {
scanf("%d", &x);
csum += x;
}
printf("%d\n%d", asum - bsum, bsum - csum);
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t T;
constexpr auto EPS = 1e-7;
const int mod = (int)1e9 + 7;
int dxn[] = {-1, -2, -2, -1, 1, 2, 2, 1};
int dyn[] = {-2, -1, 1, 2, 2, 1, -1, -2};
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
long long gcd(long long a, long long b) { return (a) ? gcd(b % a, a) : b; }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
void nGu() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
nGu();
int n;
cin >> n;
map<int, int> mp, mp1, mp2;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
mp[x]++;
}
for (int i = 0; i < n - 1; i++) {
int x;
cin >> x;
mp1[x]++;
}
for (int i = 0; i < n - 2; i++) {
int x;
cin >> x;
mp2[x]++;
}
for (auto it : mp)
if (mp1[it.first] != it.second) {
cout << it.first << "\n";
break;
}
for (auto it : mp1)
if (mp2[it.first] != it.second) {
cout << it.first << "\n";
break;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, i, j, k, e, n, x, y, p, d, su, t;
map<long long int, long long int> ss, ff, tt;
vector<long long int> v;
vector<long long int>::iterator it;
cin >> t;
for (i = 1; i <= t; i++) {
cin >> a;
v.push_back(a);
ss[a]++;
}
for (i = 0; i < t - 1; i++) {
cin >> b;
tt[b]++;
}
for (i = 0; i < t - 2; i++) {
cin >> b;
ff[b]++;
}
for (i = 0; i < t; i++) {
if (ss[v[i]] != tt[v[i]]) {
cout << v[i] << endl;
it = find(v.begin(), v.end(), v[i]);
v.erase(it);
ss[i]--;
break;
}
}
for (i = 0; i < t - 1; i++) {
if (tt[v[i]] != ff[v[i]]) {
cout << v[i] << endl;
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, a = 0, b = 0, t, arr[2];
cin >> x;
for (int i = 0; i < 3; i++) {
for (int y = 0; y < x; y++) {
if (i == 0) {
cin >> t;
a = a + t;
} else if (i == 1) {
cin >> t;
b = b + t;
} else if (i == 2) {
cin >> t;
b = b + t;
}
}
if (i == 1) {
arr[i - 1] = a - b;
a = b;
b = 0;
} else if (i == 2) {
arr[i - 1] = a - b;
}
x = x - 1;
}
for (int y = 0; y < 2; y++) {
cout << arr[y] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, A[200005];
int main() {
scanf("%d", &N);
long long int X1, X2, X3;
X1 = X2 = X3 = 0;
for (int i = 1; i <= N; i++) {
cin >> X2;
X1 = X1 ^ X2;
}
X2 = 0;
for (int i = 1; i < N; i++) {
cin >> X3;
X2 = X2 ^ X3;
}
X3 = 0;
printf("%lld\n", X1 ^ X2);
for (int i = 2; i < N; i++) {
cin >> X1;
X3 = X3 ^ X1;
}
printf("%lld\n", X2 ^ X3);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
const int MAX_N = 100000;
int n, i, a[MAX_N + 1], b[MAX_N + 1], c[MAX_N + 1];
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n - 1; i++) {
scanf("%d", &b[i]);
}
for (i = 1; i <= n - 2; i++) {
scanf("%d", &c[i]);
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n);
b[n] = 0;
for (i = 1; a[i] == b[i]; i++) {
;
}
printf("%d\n", a[i]);
c[n - 1] = a[i];
b[n] = a[i];
sort(b + 1, b + n + 1);
sort(c + 1, c + n);
c[n] = 0;
for (i = 1; b[i] == c[i]; i++) {
;
}
printf("%d\n", b[i]);
c[n] = b[i];
sort(c + 1, c + n + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> fc;
vector<int> sc;
vector<int> tc;
int fe;
int se;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
fc.push_back(x);
}
for (int i = 0; i < n - 1; i++) {
int x;
cin >> x;
sc.push_back(x);
}
for (int i = 0; i < n - 2; i++) {
int x;
cin >> x;
tc.push_back(x);
}
sort(fc.begin(), fc.end());
sort(sc.begin(), sc.end());
sort(tc.begin(), tc.end());
for (int i = 0; i < n; i++) {
if (fc[i] != sc[i]) {
fe = fc[i];
break;
}
if (i == n - 1) fe = fc[i];
}
for (int i = 0; i < n - 1; i++) {
if (sc[i] != tc[i]) {
se = sc[i];
break;
}
if (i == n - 2) se = sc[i];
}
cout << fe << endl << se << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
cin >> n;
int s1 = 0, s2 = 0, s3 = 0;
int* arr = new int[n];
int* arr2 = new int[n - 1];
int* arr3 = new int[n - 2];
for (i = 0; i < n; i++) {
cin >> arr[i];
s1 += arr[i];
}
for (i = 0; i < n - 1; i++) {
cin >> arr2[i];
s2 += arr2[i];
}
for (i = 0; i < n - 2; i++) {
cin >> arr3[i];
s3 += arr3[i];
}
cout << s1 - s2 << endl;
cout << s2 - s3 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int aa, b, c, x = 0, y = 0, z = 0;
scanf("%d", &aa);
for (int i = 0; i < aa; i++) {
scanf("%d", &b);
x = x + b;
}
for (int i = 0; i < aa - 1; i++) {
scanf("%d", &b);
y = y + b;
}
for (int i = 0; i < aa - 2; i++) {
scanf("%d", &b);
z = z + b;
}
printf("%d\n%d\n", (x - y), (y - z));
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, i, sum = 0, sum1 = 0, sum2 = 0;
scanf("%d", &n);
int a[n], b[n - 1], c[n - 2];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum = sum + a[i];
}
for (i = 0; i < n - 1; i++) {
scanf("%d", &b[i]);
sum1 = sum1 + b[i];
}
for (i = 0; i < n - 2; i++) {
scanf("%d", &c[i]);
sum2 = sum2 + c[i];
}
printf("%d\n%d", sum - sum1, sum1 - sum2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int i, n, a, x1, x2, x3;
cin >> n;
x1 = x2 = x3 = 0;
for (i = 0; i < n; ++i) {
cin >> a;
x1 ^= a;
}
for (i = 0; i < n - 1; ++i) {
cin >> a;
x2 ^= a;
}
for (i = 0; i < n - 2; ++i) {
cin >> a;
x3 ^= a;
}
cout << (x1 ^ x2) << endl << (x2 ^ x3) << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.