text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long dx[] = {-1, 0, 1, 0};
long long dy[] = {0, -1, 0, 1};
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long ans = 0;
for (long long i = 0; i <= a; i += 2) {
for (long long j = 0; j <= c; j++) {
long long k = n - i / 2 - 2 * j;
if (k < 0 || k > b) continue;
ans++;
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int main() {
int i, j, k;
int n, m;
int a, b, c;
cin >> n >> a >> b >> c;
if (a / 2 + b + c * 2 < n) {
cout << 0 << endl;
return 0;
}
long long cou = 0;
for (i = 0; i <= a; i += 2)
for (j = 0; j <= b; j++) {
k = n - (i / 2 + j);
if (k < 0) continue;
if (k % 2 == 0 && k <= c * 2) cou++;
}
cout << cou << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int input(void) {
scanf("%d%d%d%d", &n, &a, &b, &c);
return 0;
}
int solve(void) {
int x, ans = 0;
for (register int y = 0; y <= b; y++) {
for (register int z = 0; z <= c; z++) {
x = (n - y - (z << 1)) << 1;
if (0 <= x && x <= a) ans++;
}
}
printf("%d\n", ans);
return 0;
}
int main(void) {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
static int r, sign;
static char c;
r = 0, sign = 1;
do c = getchar();
while (c != '-' && (c < '0' || c > '9'));
if (c == '-') sign = -1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + (int)(c - '0'), c = getchar();
return sign * r;
}
template <typename T>
inline void print(T *a, int n) {
for (int i = 1; i < n; ++i) cout << a[i] << " ";
cout << a[n] << endl;
}
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];
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], dissum[100100 + 1], dissqr[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;
dissum[node] = dissum[x] + dis[node];
dissqr[node] = dissqr[x] + dis[node] * dis[node];
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];
}
inline int LCA2(int x, int y) {
for (int i = logn; i >= 0; --i)
if (dep[x] < dep[p[i][y]]) y = p[i][y];
return y;
}
vector<pair<int, int> > Q[100100 + 1];
int q, ans[100100 + 1], seq[100100 + 1], cnt = 0;
DP pre[100100 + 1], suf[100100 + 1];
struct BIT {
hashInt a[100100 + 1];
inline void modify(int x, hashInt w) {
for (; x <= n; x += x & -x) a[x] = a[x] + w;
}
inline hashInt query(int x) {
hashInt r = 0;
for (; x > 0; x -= x & -x) r = r + a[x];
return r;
}
} sufsum, sufsqr;
void dfs(int x, int f) {
for (int i = 0; i < Q[x].size(); ++i) {
int node = Q[x][i].first, id = Q[x][i].second;
int p = LCA(x, node);
hashInt b = dis[node] - dis[p];
b = b * b;
}
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
seq[++cnt] = x;
pre[cnt].sum = pre[cnt - 1].sum + e[i].w * (cnt - 1);
pre[cnt].sqr = delta(pre[cnt - 1], cnt - 1, e[i].w);
dfs(node, x);
--cnt;
}
}
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 modulo = 1000000007;
int N, E[200010], lvl[200010], first[100010], M[200010][18], max2[200010],
S1[100010], S2[100010], nr[100010], droot[100010], indd[100010], T[100010],
finalsol1[100010], finalsol2[100010];
vector<int> V[100010], C[100010], pd1[100010], pd2[100010];
int add(int x, int y) {
x += y;
return x >= modulo ? x - modulo : x;
}
int mult(int x, int y) {
int ret = ((long long)x * y) % modulo;
return ret < 0 ? ret + modulo : ret;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + modulo : x;
}
void euler(int x, int& poz, int l = 0, int t = -1) {
T[x] = t;
for (auto i : V[x])
if (t != i) {
E[poz] = x;
lvl[poz++] = l;
euler(i, poz, l + 1, x);
}
E[poz] = x;
lvl[poz++] = l;
}
void precompute_lca() {
int poz = 0;
euler(0, poz);
memset(first, -1, sizeof(first));
for (int i = 0; i < 2 * N - 1; i++)
if (first[E[i]] == -1) first[E[i]] = i;
for (int i = 0; i < 2 * N - 1; i++) M[i][0] = i;
for (int k = 1; (1 << k) <= 2 * N - 1; k++)
for (int i = 0; i + (1 << k) <= 2 * N - 1; i++) {
int l = M[i][k - 1], r = M[i + (1 << (k - 1))][k - 1];
M[i][k] = lvl[l] < lvl[r] ? l : r;
}
for (int k = 1; (1 << k) <= 2 * N - 1; k++) max2[1 << k] = 1;
for (int i = 1; i <= 2 * N - 1; i++) max2[i] += max2[i - 1];
}
int lca(int x, int y) {
int a = first[x], b = first[y];
if (a > b) swap(a, b);
int len = b - a + 1, k = max2[len];
int l = M[a][k], r = M[b - (1 << k) + 1][k];
if (lvl[l] < lvl[r])
return E[l];
else
return E[r];
}
void calc_S(int x, int d = 0) {
nr[x] = 1;
droot[x] = d;
for (int i = 0; i < V[x].size(); i++) {
int y = V[x][i];
if (y == T[x]) continue;
calc_S(y, add(d, C[x][i]));
S1[x] = add(S1[x], add(S1[y], mult(C[x][i], nr[y])));
S2[x] = add(S2[x], add(S2[y], add(mult(nr[y], mult(C[x][i], C[x][i])),
mult(2, mult(C[x][i], S1[y])))));
nr[x] += nr[y];
}
}
void calc_pd(int x, int ind = 0) {
int up = 0;
indd[x] = ind;
if (T[x] != -1) {
up = add(pd1[T[x]][ind], mult(C[T[x]][ind], N - nr[x]));
}
up = add(up, S1[x]);
for (int i = 0; i < V[x].size(); i++)
if (V[x][i] != T[x]) {
pd1[x].push_back(sub(sub(up, S1[V[x][i]]), mult(C[x][i], nr[V[x][i]])));
} else {
pd1[x].push_back(-1);
}
up = 0;
if (T[x] != -1) {
up = add(
add(pd2[T[x]][ind], mult(mult(N - nr[x], C[T[x]][ind]), C[T[x]][ind])),
mult(mult(2, C[T[x]][ind]), pd1[T[x]][ind]));
}
up = add(up, S2[x]);
for (int i = 0; i < V[x].size(); i++)
if (V[x][i] != T[x]) {
int y = V[x][i];
pd2[x].push_back(
sub(sub(sub(up, S2[y]), mult(mult(C[x][i], C[x][i]), nr[y])),
mult(mult(2, C[x][i]), S1[y])));
} else {
pd2[x].push_back(-1);
}
for (int i = 0; i < V[x].size(); i++)
if (V[x][i] != T[x]) calc_pd(V[x][i], i);
}
int calc_d(int x, int y) {
int z = lca(x, y);
return sub(add(droot[x], droot[y]), mult(2, droot[z]));
}
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--;
V[a].push_back(b);
V[b].push_back(a);
C[a].push_back(c);
C[b].push_back(c);
}
precompute_lca();
calc_S(0);
calc_pd(0);
int Q;
scanf("%d", &Q);
for (int i = 0; i < N; i++)
if (T[i] != -1) {
int t = T[i], ind = indd[i];
finalsol1[i] = add(pd1[T[i]][indd[i]], mult(C[T[i]][indd[i]], N - nr[i]));
finalsol2[i] =
add(add(pd2[t][ind], mult(mult(C[t][ind], C[t][ind]), N - nr[i])),
mult(mult(2, C[t][ind]), pd1[t][ind]));
} else {
finalsol1[i] = finalsol2[i] = 0;
}
for (int i = 0; i < Q; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--, v--;
int ret = 0;
int duv = calc_d(u, v);
if (lca(u, v) == v) {
ret = add(ret, mult(N - nr[v], mult(duv, duv)));
ret = add(ret, finalsol2[v]);
ret = add(ret, mult(mult(2, duv), finalsol1[v]));
ret = mult(ret, -2);
ret = add(ret, add(S2[u], finalsol2[u]));
} else {
ret = add(ret, mult(nr[v], mult(duv, duv)));
ret = add(ret, S2[v]);
ret = add(ret, mult(mult(2, duv), S1[v]));
ret = mult(ret, 2);
ret = sub(ret, add(S2[u], finalsol2[u]));
}
printf("%d\n", ret);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100, LOG = 20, MOD = 1000 * 1000 * 1000 + 7;
int sum(int a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
else if (a < 0)
a += MOD;
return a;
}
void _sum(int &a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
else if (a < 0)
a += MOD;
}
int mul(int a, int b) { return 1LL * a * b % MOD; }
int n, u, v, w, q, h[N], sz[N], sum_down[N], sq_down[N], sq_up[N][LOG];
pair<int, int> upper[N][LOG], sum_up[N][LOG];
vector<pair<int, int> > nei[N];
int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int i = LOG - 1; i >= 0; i--)
if (h[u] - (1 << i) >= h[v]) u = upper[u][i].first;
if (u == v) return u;
for (int i = LOG - 1; i >= 0; i--)
if (upper[u][i].first != upper[v][i].first) {
u = upper[u][i].first;
v = upper[v][i].first;
}
return upper[u][0].first;
}
bool under(int u, int v) { return lca(u, v) == v; }
int dis(int u, int v) {
int res = 0;
for (int i = LOG - 1; i >= 0; i--)
if (h[u] - (1 << i) >= h[v]) {
_sum(res, upper[u][i].second);
u = upper[u][i].first;
}
return res;
}
int get_sq(int u, int v) {
int res = 0, len = 0;
for (int i = LOG - 1; i >= 0; i--)
if (h[u] - (1 << i) >= h[v]) {
_sum(res, sq_up[u][i]);
_sum(res, mul(len, sum(mul(len, sum_up[u][i].second),
mul(2, sum_up[u][i].first))));
_sum(len, upper[u][i].second);
u = upper[u][i].first;
}
return res;
}
void dfs_down(int v, int par = 0) {
for (int i = 1; i < LOG; i++) {
pair<int, int> p1 = upper[v][i - 1], p2 = upper[p1.first][i - 1];
upper[v][i] = pair<int, int>(p2.first, sum(p1.second, p2.second));
}
int SUM = 0, SQ = 0, SZ = 0;
for (pair<int, int> p : nei[v])
if (p.first != par) {
int u = p.first, d = p.second;
upper[u][0] = pair<int, int>(v, d);
h[u] = h[v] + 1;
dfs_down(u, v);
SZ += sz[u];
_sum(SUM, sum(sum_down[u], mul(sz[u], d)));
_sum(SQ,
sum(sq_down[u], mul(d, sum(mul(d, sz[u]), mul(2, sum_down[u])))));
}
sz[v] = sum(SZ, 1);
sum_down[v] = SUM;
sq_down[v] = SQ;
}
void dfs_up(int v, int par = 0) {
for (int i = 1; i < LOG; i++) {
int u = upper[v][i - 1].first, d = upper[v][i - 1].second,
SZ = sum_up[u][i - 1].second;
sum_up[v][i].first =
sum(sum_up[v][i - 1].first, sum(sum_up[u][i - 1].first, mul(SZ, d)));
sum_up[v][i].second = sum(sum_up[v][i - 1].second, SZ);
sq_up[v][i] =
sum(sq_up[v][i - 1],
sum(sq_up[u][i - 1],
mul(d, sum(mul(SZ, d), mul(2, sum_up[u][i - 1].first)))));
}
for (pair<int, int> p : nei[v])
if (p.first != par) {
int u = p.first, d = p.second;
sum_up[u][0].first =
sum(sum_down[v],
sum(-mul(d, sz[u]), sum(-sum_down[u], mul(sz[v] - sz[u], d))));
sum_up[u][0].second = sz[v] - sz[u];
sq_up[u][0] = sum(
sq_down[v],
-sum(sq_down[u], mul(d, sum(mul(d, sz[u]), mul(2, sum_down[u])))));
_sum(sq_up[u][0], mul(d, sum(mul(d, sum_up[u][0].second),
mul(2, sum(sum_up[u][0].first,
-mul(d, sum_up[u][0].second))))));
dfs_up(u, v);
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v >> w;
nei[--u].push_back(pair<int, int>(--v, w));
nei[v].push_back(pair<int, int>(u, w));
}
dfs_down(0);
dfs_up(0);
cin >> q;
while (q--) {
cin >> u >> v;
u--, v--;
int ans = sum(sq_down[u], get_sq(u, 0)), LCA = lca(u, v),
d = sum(dis(v, LCA), dis(u, LCA));
if (under(u, v))
_sum(ans, -mul(2, sum(get_sq(u, v), sq_down[u])));
else
_sum(ans, -mul(2, sum(sq_down[v],
mul(d, sum(mul(d, sz[v]), mul(2, sum_down[v]))))));
ans = (-ans + MOD) % MOD;
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long int INFLL = 1e18;
const double EPS = 1e-8;
const long long int MOD = 1000000007;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
struct Mod {
unsigned n;
Mod() {}
Mod(long long int x) {
if (x < 0)
n = x % MOD + MOD;
else
n = x % MOD;
}
};
Mod operator+(Mod a, Mod b) { return Mod((a.n + b.n) % MOD); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-(Mod a, Mod b) { return Mod((a.n + MOD - b.n) % MOD); }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*(Mod a, Mod b) { return Mod(((long long int)a.n * b.n) % MOD); }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod modpow(Mod x, long long int k) {
Mod res = 1;
while (k) {
if (k & 1) res *= x;
k /= 2;
x *= x;
}
return res;
}
Mod inv(Mod a) { return modpow(a, MOD - 2); }
Mod operator/(Mod a, Mod b) {
return Mod(((long long int)a.n * inv(b).n) % MOD);
}
Mod operator/=(Mod &a, Mod b) { return a = a / b; }
struct Bit {
vector<long long int> bit;
int size;
void init(int n) {
n++;
size = 1;
while (size < n) size *= 2;
bit = vector<long long int>(size, 0);
}
void add(int k, long long int x) {
k++;
while (k <= size) {
bit[k] += x;
k += k & -k;
}
}
long long int sum(int k) {
k++;
long long int res = 0;
while (k > 0) {
res += bit[k];
k -= k & -k;
}
return res;
}
long long int get(int k) { return sum(k) - sum(k - 1); }
long long int update(int k, long long int x) { add(k, x - get(k)); }
};
struct Tree {
vector<vector<pair<long long int, long long int> > > G;
int n, logn, r;
vector<int> nst, sst;
vector<int> dep;
vector<long long int> w;
vector<int> par;
vector<bool> used;
vector<vector<int> > ps;
vector<int> in, out;
int etcnt;
bool dfs_f, lca_f, et_f;
Bit etbit;
void init(int num, int root = 0) {
n = num;
r = root;
G = vector<vector<pair<long long int, long long int> > >(n);
par = vector<int>(n, -1);
w = vector<long long int>(n, 1);
dfs_f = lca_f = et_f = false;
}
Tree(int num, int root = 0) { init(num, root); }
Tree() {}
void set_weight(const vector<long long int> &weight) { w = weight; }
void set_graph_dfs(
const vector<vector<pair<long long int, long long int> > > &g, int x) {
used[x] = true;
for (auto &w : g[x]) {
if (!used[w.first]) {
G[x].push_back(w);
set_graph_dfs(g, w.first);
}
}
}
void set_graph(const vector<vector<pair<long long int, long long int> > > &g,
int root = 0) {
init(g.size(), root);
used = vector<bool>(n, 0);
G = vector<vector<pair<long long int, long long int> > >(n);
set_graph_dfs(g, root);
}
void set_graph(int root = 0) {
vector<vector<pair<long long int, long long int> > > tempg = G;
set_graph(tempg, root);
}
void add_edge(int x, int p, long long int co = 1) {
G[p].push_back(pair<long long int, long long int>(x, co));
}
void add_biedge(int a, int b, long long int co = 1) {
G[a].push_back(pair<long long int, long long int>(b, co));
G[b].push_back(pair<long long int, long long int>(a, co));
}
void dfs(int x, int p, int d) {
used[x] = true;
dep[x] = d;
nst[x] = 1;
sst[x] = w[x];
par[x] = p;
for (auto &w : G[x]) {
if (p != x && !used[w.first]) {
dfs(w.first, x, d + 1);
nst[x] += nst[w.first];
sst[x] += sst[w.first];
}
}
}
void dfs() {
used = vector<bool>(n, false);
nst = sst = vector<int>(n);
dep = vector<int>(n);
dfs(r, -1, 0);
dfs_f = true;
}
void init_lca() {
if (!dfs_f) dfs();
logn = (int)log2(n) + 1;
ps = vector<vector<int> >(logn, vector<int>(n, -1));
ps[0] = par;
for (int i = (1); i < (int)(logn); i++) {
for (int j = (0); j < (int)(n); j++) {
if (ps[i - 1][j] == -1)
ps[i][j] = -1;
else
ps[i][j] = ps[i - 1][ps[i - 1][j]];
}
}
lca_f = true;
}
int lca(int a, int b) {
if (!lca_f) init_lca();
if (dep[a] > dep[b]) swap(a, b);
for (int i = logn; i >= 0; i--)
if ((dep[b] - dep[a]) & (1 << i)) b = ps[i][b];
if (a == b) return a;
for (int i = logn - 1; i >= 0; i--) {
if (ps[i][a] != ps[i][b]) {
a = ps[i][a];
b = ps[i][b];
}
}
return ps[0][a];
}
void etdfs(int x) {
in[x] = etcnt++;
for (auto &w : G[x]) {
etdfs(w.first);
etbit.add(in[w.first], w.second);
etbit.add(out[w.first], -w.second);
}
out[x] = etcnt++;
}
void etdfs() {
if (!dfs_f) dfs();
if (!lca_f) init_lca();
etcnt = 0;
in = vector<int>(n);
out = vector<int>(n);
etbit.init(2 * n);
etdfs(r);
et_f = true;
}
void etupdate(int x, long long int d) {
if (!et_f) etdfs();
etbit.update(in[x], d);
etbit.update(out[x], -d);
}
long long int dist(int a, int b) {
if (!et_f) etdfs();
return etbit.sum(in[a]) + etbit.sum(in[b]) - etbit.sum(in[lca(a, b)]) * 2;
}
vector<Mod> ds, dss;
void dsdfs(int x) {
for (auto &w : G[x]) {
dsdfs(w.first);
Mod c = w.second;
ds[x] += ds[w.first] + Mod(nst[w.first]) * c;
dss[x] +=
dss[w.first] + Mod(2) * c * ds[w.first] + c * c * Mod(nst[w.first]);
}
}
void dsdfs() {
ds = dss = vector<Mod>(n, 0);
dsdfs(r);
}
vector<Mod> ss, sss;
void qdfs(int x, Mod sum, Mod sums) {
ss[x] = sum;
sss[x] = sums;
for (auto &w : G[x]) {
int t = w.first;
Mod c = w.second;
qdfs(t, sum + Mod(n - 2 * nst[t]) * c,
sums + c * c * Mod(n) - Mod(4) * (ds[t] + c * Mod(nst[t])) * c +
Mod(2) * sum * c);
}
}
void qdfs() {
dsdfs();
ss = sss = vector<Mod>(n);
qdfs(r, ds[r], dss[r]);
}
Mod mdist(int u, int v) { return Mod(dist(u, v)); }
Mod querya(int u, int v) {
if (lca(u, v) == v) {
return sss[u] -
(sss[v] - dss[v] + mdist(u, v) * mdist(u, v) * Mod(n - nst[v]) +
Mod(2) * mdist(u, v) * (ss[v] - ds[v]));
} else {
return dss[v] + mdist(u, v) * mdist(u, v) * Mod(nst[v]) +
Mod(2) * mdist(u, v) * ds[v];
}
}
Mod query(int u, int v) { return Mod(2) * querya(u, v) - sss[u]; }
};
Tree T;
int n, q;
int main() {
cin >> n;
T.init(n);
for (int i = (0); i < (int)(n - 1); i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
T.add_biedge(a, b, c);
}
T.set_graph(0);
T.dfs();
T.init_lca();
T.etdfs();
T.qdfs();
cin >> q;
for (int i = (0); i < (int)(q); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
cout << T.query(u, v).n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int LG = 20;
const int MOD = 1e9 + 7;
int dp[N][2], up[N][2], cnt[N];
vector<pair<int, int> > adj[N];
int d[N], par[N][LG], path[N][LG];
int n;
void add(int &a, long long val) {
a += val % MOD;
a %= MOD;
a += MOD;
a %= MOD;
}
void dfs_down(int v, int p) {
cnt[v]++;
for (auto e : adj[v]) {
int u = e.first;
int w = e.second;
if (u == p) continue;
d[u] = d[v] + 1;
par[u][0] = v;
path[u][0] = w;
for (int i = 1; i < LG; i++) {
par[u][i] = par[par[u][i - 1]][i - 1];
path[u][i] = (path[u][i - 1] + path[par[u][i - 1]][i - 1]) % MOD;
}
dfs_down(u, v);
cnt[v] += cnt[u];
add(dp[v][0], 1LL * dp[u][0] + 1LL * cnt[u] * w % MOD);
add(dp[v][1], 1LL * dp[u][1] + 2LL * dp[u][0] * w % MOD +
1LL * cnt[u] * w % MOD * w % MOD);
}
}
void dfs_up(int v, int p) {
for (auto e : adj[v]) {
int u = e.first;
int w = e.second;
if (u == p) continue;
int sum = dp[v][0];
add(sum, -1LL * dp[u][0] + -1LL * cnt[u] * w % MOD);
int sum2 = dp[v][1];
add(sum2, -1LL * dp[u][1] + -2LL * dp[u][0] * w % MOD +
-1LL * cnt[u] * w % MOD * w % MOD);
add(up[u][0], 1LL * (sum + up[v][0]) % MOD + 1LL * (n - cnt[u]) * w % MOD);
add(up[u][1], 1LL * (sum2 + up[v][1]) % MOD +
2LL * (sum + up[v][0]) % MOD * w % MOD +
1LL * (n - cnt[u]) * w % MOD * w % MOD);
dfs_up(u, v);
}
}
pair<int, int> get_parent(int v, int a) {
int ans = 0;
for (int i = 0; i < LG; i++)
if ((a >> i) & 1) {
ans += path[v][i], ans %= MOD;
v = par[v][i];
}
return {v, ans};
}
int lca(int v, int u) {
if (d[u] > d[v]) swap(u, v);
v = get_parent(v, d[v] - d[u]).first;
if (v == u) return v;
for (int i = LG - 1; i >= 0; i--)
if (par[v][i] != par[u][i]) v = par[v][i], u = par[u][i];
return par[u][0];
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
adj[v].push_back({u, w});
adj[u].push_back({v, w});
}
dfs_down(0, -1);
dfs_up(0, -1);
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
u--, v--;
int w = lca(u, v);
int dis = (get_parent(v, d[v] - d[w]).second +
get_parent(u, d[u] - d[w]).second) %
MOD;
int ans = 0;
if (w == v)
add(ans, 1LL * dp[u][1] + 1LL * up[u][1] +
-2LL *
(1LL * up[v][1] + 2LL * up[v][0] * dis % MOD +
1LL * (n - cnt[v]) * dis % MOD * dis % MOD) %
MOD);
else
add(ans, -1LL * dp[u][1] + -1LL * up[u][1] +
2LL *
(1LL * dp[v][1] + 2LL * dp[v][0] * dis % MOD +
1LL * cnt[v] * dis % MOD * dis % MOD) %
MOD);
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const int mo = (int)1e9 + 7;
const int N = (int)1e5 + 5, logN = 17;
int n, q;
struct node;
struct edge {
node *ed;
edge *next;
int w;
} E[N << 1], *newE = E;
struct data {
long long sum2, sum, cnt;
data operator*(long long t) {
t %= mo;
return (data){(sum2 + 2 * t * sum % mo + t * t % mo * cnt % mo) % mo,
(sum + t * cnt % mo) % mo, cnt};
}
void operator+=(const data &t) {
(sum2 += t.sum2) %= mo;
(sum += t.sum) %= mo;
(cnt += t.cnt) %= mo;
}
void operator-=(const data &t) {
(sum2 -= t.sum2) %= mo;
(sum -= t.sum) %= mo;
(cnt -= t.cnt) %= mo;
}
};
struct node {
edge *son;
node *pa[logN];
int dep;
long long depth;
data s, a;
void dfs() {
for (int j = 1; j < logN; j++) pa[j] = pa[j - 1]->pa[j - 1];
s.cnt = 1;
for (edge *e = son; e; e = e->next)
if (e->ed != pa[0]) {
e->ed->pa[0] = this;
e->ed->dep = dep + 1;
e->ed->depth = depth + e->w;
e->ed->dfs();
s += e->ed->s * e->w;
}
}
void dfs2(data now) {
now += s;
a = now;
for (edge *e = son; e; e = e->next)
if (e->ed != pa[0]) {
now -= e->ed->s * e->w;
e->ed->dfs2(now * e->w);
now += e->ed->s * e->w;
}
}
} V[N];
node *lca(node *u, node *v) {
for (int j = logN - 1; j >= 0; j--)
if (u->pa[j]->dep >= v->dep) u = u->pa[j];
for (int j = logN - 1; j >= 0; j--)
if (v->pa[j]->dep >= u->dep) v = v->pa[j];
for (int j = logN - 1; j >= 0; j--)
if (u->pa[j] != v->pa[j]) u = u->pa[j], v = v->pa[j];
if (u == v) return u;
return u->pa[0];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
*newE = (edge){V + y, V[x].son, w}, V[x].son = newE++;
*newE = (edge){V + x, V[y].son, w}, V[y].son = newE++;
}
for (int j = 0; j < logN; j++) V[1].pa[j] = V + 1;
V[1].dfs();
V[1].dfs2((data){0, 0, 0});
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
node *w = lca(V + x, V + y);
long long d = V[x].depth + V[y].depth - w->depth * 2;
data a = V[y].s * d;
if (w == V + y) {
data c = V[y].a;
c -= V[y].s;
a = V[x].a;
a -= c * d;
}
data b = V[x].a;
b -= a;
a -= b;
printf("%I64d\n", (a.sum2 + mo) % mo);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char x = getchar();
int ans = 0, flag = 1;
while (!isdigit(x))
if (x == '-')
flag = -1, x = getchar();
else
x = getchar();
while (isdigit(x)) ans = ans * 10 + x - '0', x = getchar();
return ans * flag;
}
long long head[100005], nxt[200005], pnt[200005], len[200005], E, DEP[100005],
dep[100005];
long long bz[100005][20], siz[100005], dp1[100005], dp2[100005], dp[100005],
dis[100005];
long long dist[100005], n, dp3[100005];
const long long mod = 1e9 + 7;
long long mo(long long x) {
if (x >= mod) x -= mod;
if (x < 0) x += mod;
return x;
}
void add_edge(long long u, long long v, long long w) {
pnt[E] = v;
nxt[E] = head[u];
len[E] = w;
head[u] = E++;
}
void dfs(long long u, long long pre) {
DEP[u] = DEP[pre] + 1;
bz[u][0] = pre;
for (long long i = 1; i <= 16; i++) bz[u][i] = bz[bz[u][i - 1]][i - 1];
siz[u] = 1;
for (long long i = head[u]; i != -1; i = nxt[i]) {
long long v = pnt[i];
if (v == pre) continue;
dep[v] = mo(dep[u] + len[i]);
dfs(v, u);
siz[u] += siz[v];
dis[u] = mo(dis[u] + dis[v]);
dis[u] = mo(dis[u] + siz[v] * len[i] % mod);
dp1[u] = mo(dp1[u] + dp1[v]);
dp1[u] = mo(dp1[u] + 2 * dis[v] * len[i] % mod);
dp1[u] = mo(dp1[u] + len[i] * len[i] % mod * siz[v] % mod);
dp2[u] = mo(dp2[u] + len[i] * siz[v] % mod);
dp2[u] = mo(dp2[u] + dp2[v]);
}
}
void dfs1(long long u, long long pre) {
for (long long i = head[u]; i != -1; i = nxt[i]) {
long long v = pnt[i];
if (v == pre) continue;
dp3[v] = mo(dp3[u] - siz[v] * len[i] % mod);
dp3[v] = mo(dp3[v] + (siz[1] - siz[v]) * len[i] % mod);
dp[v] = mo(dp[u] + len[i] * len[i] % mod * siz[1] % mod);
dp[v] =
mo(dp[v] - 2 * len[i] % mod * ((dis[v] + siz[v] * len[i]) % mod) % mod);
long long tmp = mo(dis[u] - dis[v]);
tmp = mo(tmp - siz[v] * len[i] % mod);
dp[v] = mo(dp[v] + 2 * len[i] % mod * mo(tmp + dist[u]) % mod);
dist[v] = mo(dist[u] + tmp);
dist[v] = mo(dist[v] + (siz[1] - siz[v]) * len[i] % mod);
dfs1(v, u);
}
}
long long lca(long long x, long long y) {
if (DEP[x] < DEP[y]) swap(x, y);
for (long long i = 16; i >= 0; i--)
if (DEP[bz[x][i]] >= DEP[y]) x = bz[x][i];
if (x == y) return x;
for (long long i = 16; i >= 0; i--)
if (bz[x][i] != bz[y][i]) x = bz[x][i], y = bz[y][i];
return bz[x][0];
}
signed main() {
memset(head, -1, sizeof(head));
scanf("%lld", &n);
for (long long i = 1; i < n; i++) {
long long u, v, w;
scanf("%lld%lld%lld", &u, &v, &w);
add_edge(u, v, w);
add_edge(v, u, w);
}
dfs(1, 0);
dp[1] = dp1[1], dp3[1] = dp2[1];
dfs1(1, 0);
long long q;
scanf("%lld", &q);
while (q--) {
long long u, v;
scanf("%d%d", &u, &v);
long long LCA = lca(u, v), ans = 0;
if (LCA == v) {
long long tmp = mo(dp[LCA] - dp1[LCA]);
tmp = mo(tmp +
mo(dep[u] - dep[LCA]) * 2 % mod * mo(dp3[LCA] - dp2[LCA]) % mod);
tmp = mo(tmp + (dep[u] - dep[LCA]) * (dep[u] - dep[LCA]) % mod *
(siz[1] - siz[v]) % mod);
ans = mo(dp[u] - tmp);
ans = mo(ans * 2 - dp[u]);
} else {
long long diss = dep[u] + dep[v] - 2 * dep[LCA];
diss %= mod;
if (diss < 0) diss += mod;
ans = mo(dp1[v] + 2 * diss % mod * dp2[v] % mod);
ans = mo(ans + diss * diss % mod * siz[v] % mod);
ans = mo(mo(ans * 2) - dp[u]);
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long par[111111][25], d[3][111111][25], child[111111], up[111111][3],
down[111111][3];
int depth[111111], in[111111], out[111111];
int logarit[111111];
int cnt = 0;
vector<vector<pair<int, int> > > adj;
long long mod = 1000000007;
void dfs_1(int u, int p) {
in[u] = cnt++;
depth[u] = depth[p] + 1;
for (int i = 0, _n = adj[u].size(); i < _n; i++) {
int v = adj[u][i].first;
int w = adj[u][i].second;
if (v == p) continue;
par[v][0] = u;
d[0][v][0] = w;
d[1][v][0] = 1ll * w * w % mod;
dfs_1(v, u);
child[u] += child[v];
down[u][0] = (down[u][0] + down[v][0] + 1ll * child[v] * w % mod) % mod;
down[u][1] = (down[u][1] + down[v][1] + d[1][v][0] * child[v] % mod +
1ll * down[v][0] * 2 * w % mod) %
mod;
}
out[u] = cnt++;
}
void init_logarit() {
logarit[1] = 0;
for (int i = 2, _b = n; i <= _b; i++) {
if ((1 << (logarit[i - 1] + 1)) == i)
logarit[i] = logarit[i - 1] + 1;
else
logarit[i] = logarit[i - 1];
}
}
void init_lca() {
for (int i = 1, _b = n; i <= _b; i++) child[i] = 1;
init_logarit();
memset(par, -1, sizeof par);
dfs_1(1, 0);
for (int j = 1, _b = logarit[n]; j <= _b; j++)
for (int i = 1, _b = n; i <= _b; i++)
if (par[i][j - 1] != -1) {
par[i][j] = par[par[i][j - 1]][j - 1];
d[0][i][j] = (d[0][i][j - 1] + d[0][par[i][j - 1]][j - 1]) % mod;
}
}
void dfs_2(int u, int p, int w) {
if (u != 1) {
up[u][0] = (up[p][0] + down[p][0] - down[u][0] +
1ll * (n - 2 * child[u] + 2 * mod) * w + mod) %
mod;
up[u][1] =
(up[p][1] + down[p][1] - down[u][1] +
1ll * (n - 4 * child[u] + 4 * mod) * (1ll * w * w % mod) % mod +
2ll * w * (up[p][0] + down[p][0] - 2 * down[u][0] + 2 * mod) % mod +
mod) %
mod;
}
for (int i = 0, _n = adj[u].size(); i < _n; i++) {
int v = adj[u][i].first;
if (v == p) continue;
dfs_2(v, u, adj[u][i].second);
}
}
void init() {
init_lca();
dfs_2(1, 0, 0);
}
long long find_lca(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
long long res = 0;
for (int i = logarit[depth[u]]; i >= 0; i--)
if (depth[u] - (1 << i) >= depth[v] && par[u][i] != -1) {
res = (res + d[0][u][i]) % mod;
u = par[u][i];
}
if (u == v) return res;
for (int i = logarit[depth[u]]; i >= 0; i--)
if (par[v][i] != -1 && par[u][i] != -1 && par[v][i] != par[u][i]) {
res = (res + d[0][u][i] + d[0][v][i]) % mod;
u = par[u][i], v = par[v][i];
}
res = (res + d[0][u][0] + d[0][v][0]) % mod;
return res;
}
void Query(int u, int v) {
long long tmp = find_lca(u, v);
if (in[v] <= in[u] && out[u] <= out[v]) {
long long res = (down[u][1] + up[u][1]) % mod;
long long x = 2ll *
(up[v][1] + 2ll * up[v][0] * tmp % mod +
(tmp * tmp % mod) * (1ll * n - child[v]) % mod) %
mod;
res = (res - x + mod) % mod;
printf("%d\n", (int)res);
return;
}
long long res = (down[v][1] + (tmp * tmp) % mod * child[v] % mod +
2ll * down[v][0] * tmp % mod) %
mod;
long long x = (down[u][1] + up[u][1]) % mod;
res = (2 * res - x + mod) % mod;
printf("%d\n", (int)res);
}
int main() {
int u, v, w, Q;
scanf("%d", &n);
adj.assign(n + 1, vector<pair<int, int> >());
for (int i = 0, _n = n - 1; i < _n; i++) {
scanf("%d%d%d", &u, &v, &w);
adj[u].push_back(pair<int, int>(v, w));
adj[v].push_back(pair<int, int>(u, w));
}
init();
scanf("%d", &Q);
while (Q--) {
scanf("%d%d", &u, &v);
Query(u, v);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline sqr(T x) {
return x * x;
}
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 1e-8;
const int N = 100500;
const int MOD = 1e9 + 7;
const int logN = 18;
int par[logN][N];
int timer = 0;
int tin[N], tout[N];
vector<pair<int, int> > g[N];
long long sumLin[N], sumSqr[N];
long long sumLinDown[N], sumSqrDown[N];
int cntDown[N];
long long h[N];
int n;
inline long long M(long long x) {
x %= MOD;
if (x < 0) x += MOD;
return x;
}
long long f(long long w, int n, long long sumLin) {
return M(M(w * w) * n + 2 * sumLin * w);
}
void dfs_init(int v) {
tin[v] = ++timer;
int p = -1;
for (int i = 0; i < (int)(g[v].size()); ++i) {
int to = g[v][i].first, w = g[v][i].second;
if (tin[to]) {
p = i;
} else {
h[to] = h[v] + w;
dfs_init(to);
}
}
cntDown[v] = 1;
if (p != -1) {
par[0][v] = g[v][p].first;
g[v].erase(g[v].begin() + p);
} else
par[0][v] = v;
for (pair<int, int> ed : g[v]) {
int to = ed.first;
long long w = ed.second;
cntDown[v] += cntDown[to];
sumLinDown[v] += sumLinDown[to] + w * cntDown[to];
sumSqrDown[v] += sumSqrDown[to] + f(w, cntDown[to], sumLinDown[to]);
}
sumLinDown[v] %= MOD;
sumSqrDown[v] %= MOD;
tout[v] = ++timer;
}
void dfs2(int v) {
for (pair<int, int> ed : g[v]) {
int to = ed.first;
long long w = ed.second;
int q = cntDown[to];
sumLin[to] = M(sumLin[v] - q * w + (n - q) * w);
long long sumToChild = M(sumLinDown[to] + w * q);
sumSqr[to] = M(sumSqr[v] + f(-w, q, sumToChild)) +
f(w, n - q, M(sumLin[v] - sumToChild));
dfs2(to);
}
}
bool isIn(int u, int v) { return tin[u] <= tin[v] && tout[u] >= tout[v]; }
int lca(int u, int v) {
if (isIn(u, v)) return u;
for (int j = (int)(logN)-1; j >= 0; --j) {
int nu = par[j][u];
if (!isIn(nu, v)) u = nu;
}
return par[0][u];
}
int main() {
cin >> n;
for (int i = 0; i < (int)(n - 1); ++i) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
}
dfs_init(0);
cerr << "init\n";
for (int i = 1; i <= (int)(logN - 1); ++i)
for (int j = 0; j < (int)(N); ++j) par[i][j] = par[i - 1][par[i - 1][j]];
sumSqr[0] = sumSqrDown[0];
sumLin[0] = sumLinDown[0];
dfs2(0);
cerr << "dfs2\n";
for (int i = 0; i < (int)(n); ++i) {
}
int q;
cin >> q;
for (int i = 0; i < (int)(q); ++i) {
int u, v;
cin >> u >> v;
--u, --v;
long long ans = 0;
int l = lca(u, v);
long long d = M(h[u] + h[v] - 2 * h[l]);
if (isIn(v, u)) {
ans = M(sumSqr[v] - sumSqrDown[v]);
ans = M(ans + f(d, n - cntDown[v], sumLin[v] - sumLinDown[v]));
ans = M(sumSqr[u] - 2 * ans);
} else {
ans = sumSqrDown[v] + f(d, cntDown[v], sumLinDown[v]);
ans = M(2 * ans - sumSqr[u]);
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using std::vector;
const int maxn = 1e5 + 1;
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x * 10) + (s & 15);
s = getchar();
}
x *= f;
}
const long long p = 1e9 + 7;
struct Edge {
long long u, v, w;
} e[maxn << 1];
long long head[maxn], ecnt;
inline void addedge(long long u, long long v, long long w) {
e[++ecnt].v = v;
e[ecnt].w = w;
e[ecnt].u = head[u];
head[u] = ecnt;
}
inline void add(long long u, long long v, long long w) {
addedge(u, v, w);
addedge(v, u, w);
}
long long f1[maxn], f[maxn], g[maxn], g1[maxn], siz[maxn], dfn[maxn], idx,
top[maxn], fq[maxn], son[maxn], dis[maxn], n, q, a, b, c, ans, dep[maxn];
inline void dfs1(long long x, long long fa) {
dfn[x] = (++idx);
siz[x] = 1;
f[x] = 0;
fq[x] = fa;
f1[x] = 0;
dis[x] %= p;
for (long long i = head[x], v; i && (v = e[i].v); i = e[i].u) {
if (v == fa) continue;
dis[v] = dis[x] + e[i].w;
dep[v] = dep[x] + 1;
dfs1(v, x);
siz[x] += siz[v];
if (siz[v] > siz[son[x]]) son[x] = v;
f1[x] += (f1[v] + e[i].w * siz[v] % p);
f1[x] %= p;
f[x] +=
(f[v] + f1[v] * 2 % p * e[i].w % p + siz[v] * e[i].w % p * e[i].w % p);
f[x] %= p;
}
}
inline void dfs2(long long x, long long topf) {
top[x] = topf;
if (!son[x]) return;
dfs2(son[x], topf);
for (long long i = head[x], v; i && (v = e[i].v); i = e[i].u) {
if (v == son[x] || v == fq[x]) continue;
dfs2(v, v);
}
}
inline void dfs2(long long x) {
for (long long i = head[x], v; i && (v = e[i].v); i = e[i].u) {
if (v == fq[x]) continue;
g1[v] = (g1[x] - e[i].w * siz[v] % p + e[i].w * (n - siz[v]) % p);
g1[v] %= p;
g[v] = ((f[v] + (g[x] - ((f[v] + 2 * e[i].w % p * f1[v] % p) % p +
siz[v] * e[i].w % p * e[i].w % p) %
p) %
p) %
p +
((g1[x] - f1[v] - siz[v] * e[i].w % p) % p * 2 * e[i].w % p +
(n - siz[v]) * e[i].w % p * e[i].w % p) %
p);
g[v] %= p;
dfs2(v);
}
}
inline long long LCA(long long x, long long y) {
while (top[x] != top[y])
(dep[top[x]] > dep[top[y]]) ? (x = fq[top[x]]) : (y = fq[top[y]]);
return dep[x] < dep[y] ? x : y;
}
inline long long Dis(long long x, long long y) {
return dis[x] + dis[y] - (dis[LCA(x, y)] << 1);
}
signed main() {
read(n);
for (long long i = 1; i <= n - 1; i++) {
read(a);
read(b);
read(c);
add(a, b, c);
}
dfs1(1, 0);
dfs2(1, 1);
g[1] = f[1];
g1[1] = f1[1];
dfs2(1);
read(q);
for (long long i = 1; i <= q; i++) {
read(a);
read(b);
if ((dfn[a] >= dfn[b]) && (dfn[a] <= (dfn[b] + siz[b] - 1))) {
long long add = (dis[a] - dis[b]), X = (g[b] - f[b]), Ans;
Ans = (X + 2 * add % p * (g1[b] - f1[b]) % p +
(n - siz[b]) * add % p * add) %
p;
Ans = (g[a] - (Ans * 2) % p);
Ans %= p;
printf("%lld\n", ((Ans + p) % p));
} else {
long long add = (Dis(a, b)) % p, X = f[b], Ans;
Ans = (X + 2 * add % p * f1[b] % p + siz[b] * add % p * add % p);
(Ans += p) %= p;
Ans = ((Ans << 1) - g[a]);
Ans %= p;
printf("%lld\n", ((Ans + p) % p));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long int INFLL = 1e18;
const double EPS = 1e-8;
const long long int MOD = 1000000007;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
struct Mod {
unsigned n;
Mod() {}
Mod(long long int x) {
if (x < 0)
n = x % MOD + MOD;
else
n = x % MOD;
}
};
Mod operator+(Mod a, Mod b) { return Mod(a.n + b.n); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-(Mod a, Mod b) { return Mod(a.n + MOD - b.n); }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*(Mod a, Mod b) { return Mod((long long int)a.n * b.n); }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod modpow(Mod x, long long int k) {
Mod res = 1;
while (k) {
if (k & 1) res *= x;
k /= 2;
x *= x;
}
return res;
}
Mod inv(Mod a) { return modpow(a, MOD - 2); }
Mod operator/(Mod a, Mod b) {
return Mod(((long long int)a.n * inv(b).n) % MOD);
}
Mod operator/=(Mod &a, Mod b) { return a = a / b; }
struct Bit {
vector<long long int> bit;
int size;
void init(int n) {
n++;
size = 1;
while (size < n) size *= 2;
bit = vector<long long int>(size, 0);
}
void add(int k, long long int x) {
k++;
while (k <= size) {
bit[k] += x;
k += k & -k;
}
}
long long int sum(int k) {
k++;
long long int res = 0;
while (k > 0) {
res += bit[k];
k -= k & -k;
}
return res;
}
long long int get(int k) { return sum(k) - sum(k - 1); }
long long int update(int k, long long int x) { add(k, x - get(k)); }
};
struct Tree {
vector<vector<pair<long long int, long long int> > > G;
int n, logn, r;
vector<int> nst, sst;
vector<int> dep;
vector<long long int> w;
vector<int> par;
vector<bool> used;
vector<vector<int> > ps;
vector<int> in, out;
int etcnt;
bool dfs_f, lca_f, et_f;
Bit etbit;
void init(int num, int root = 0) {
n = num;
r = root;
G = vector<vector<pair<long long int, long long int> > >(n);
par = vector<int>(n, -1);
w = vector<long long int>(n, 1);
dfs_f = lca_f = et_f = false;
}
Tree(int num, int root = 0) { init(num, root); }
Tree() {}
void set_weight(const vector<long long int> &weight) { w = weight; }
void set_graph_dfs(
const vector<vector<pair<long long int, long long int> > > &g, int x) {
used[x] = true;
for (auto &w : g[x]) {
if (!used[w.first]) {
G[x].push_back(w);
set_graph_dfs(g, w.first);
}
}
}
void set_graph(const vector<vector<pair<long long int, long long int> > > &g,
int root = 0) {
init(g.size(), root);
used = vector<bool>(n, 0);
G = vector<vector<pair<long long int, long long int> > >(n);
set_graph_dfs(g, root);
}
void set_graph(int root = 0) {
vector<vector<pair<long long int, long long int> > > tempg = G;
set_graph(tempg, root);
}
void add_edge(int x, int p, long long int co = 1) {
G[p].push_back(pair<long long int, long long int>(x, co));
}
void add_biedge(int a, int b, long long int co = 1) {
G[a].push_back(pair<long long int, long long int>(b, co));
G[b].push_back(pair<long long int, long long int>(a, co));
}
void dfs(int x, int p, int d) {
used[x] = true;
dep[x] = d;
nst[x] = 1;
sst[x] = w[x];
par[x] = p;
for (auto &w : G[x]) {
if (p != x && !used[w.first]) {
dfs(w.first, x, d + 1);
nst[x] += nst[w.first];
sst[x] += sst[w.first];
}
}
}
void dfs() {
used = vector<bool>(n, false);
nst = sst = vector<int>(n);
dep = vector<int>(n);
dfs(r, -1, 0);
dfs_f = true;
}
void init_lca() {
if (!dfs_f) dfs();
logn = (int)log2(n) + 1;
ps = vector<vector<int> >(logn, vector<int>(n, -1));
ps[0] = par;
for (int i = (1); i < (int)(logn); i++) {
for (int j = (0); j < (int)(n); j++) {
if (ps[i - 1][j] == -1)
ps[i][j] = -1;
else
ps[i][j] = ps[i - 1][ps[i - 1][j]];
}
}
lca_f = true;
}
int lca(int a, int b) {
if (!lca_f) init_lca();
if (dep[a] > dep[b]) swap(a, b);
for (int i = logn; i >= 0; i--)
if ((dep[b] - dep[a]) & (1 << i)) b = ps[i][b];
if (a == b) return a;
for (int i = logn - 1; i >= 0; i--) {
if (ps[i][a] != ps[i][b]) {
a = ps[i][a];
b = ps[i][b];
}
}
return ps[0][a];
}
void etdfs(int x) {
in[x] = etcnt++;
for (auto &w : G[x]) {
etdfs(w.first);
etbit.add(in[w.first], w.second);
etbit.add(out[w.first], -w.second);
}
out[x] = etcnt++;
}
void etdfs() {
if (!dfs_f) dfs();
if (!lca_f) init_lca();
etcnt = 0;
in = vector<int>(n);
out = vector<int>(n);
etbit.init(2 * n);
etdfs(r);
et_f = true;
}
void etupdate(int x, long long int d) {
if (!et_f) etdfs();
etbit.update(in[x], d);
etbit.update(out[x], -d);
}
long long int dist(int a, int b) {
if (!et_f) etdfs();
return etbit.sum(in[a]) + etbit.sum(in[b]) - etbit.sum(in[lca(a, b)]) * 2;
}
vector<Mod> ds, dss;
void dsdfs(int x) {
for (auto &w : G[x]) {
dsdfs(w.first);
Mod c = w.second;
ds[x] += ds[w.first] + Mod(nst[w.first]) * c;
dss[x] +=
dss[w.first] + Mod(2) * c * ds[w.first] + c * c * Mod(nst[w.first]);
}
}
void dsdfs() {
ds = dss = vector<Mod>(n, 0);
dsdfs(r);
}
vector<Mod> ss, sss;
void qdfs(int x, Mod sum, Mod sums) {
ss[x] = sum;
sss[x] = sums;
for (auto &w : G[x]) {
int t = w.first;
Mod c = w.second;
qdfs(t, sum + Mod(n - 2 * nst[t]) * c,
sums + c * c * Mod(n) - Mod(4) * (ds[t] + c * Mod(nst[t])) * c +
Mod(2) * sum * c);
}
}
void qdfs() {
dsdfs();
ss = sss = vector<Mod>(n);
qdfs(r, ds[r], dss[r]);
}
Mod mdist(int u, int v) { return Mod(dist(u, v)); }
Mod querya(int u, int v) {
if (lca(u, v) == v) {
return sss[u] -
(sss[v] - dss[v] + mdist(u, v) * mdist(u, v) * Mod(n - nst[v]) +
Mod(2) * mdist(u, v) * (ss[v] - ds[v]));
} else {
return dss[v] + mdist(u, v) * mdist(u, v) * Mod(nst[v]) +
Mod(2) * mdist(u, v) * ds[v];
}
}
Mod query(int u, int v) { return Mod(2) * querya(u, v) - sss[u]; }
};
Tree T;
int n, q;
int main() {
cin >> n;
T.init(n);
for (int i = (0); i < (int)(n - 1); i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
T.add_biedge(a, b, c);
}
T.set_graph(0);
T.dfs();
T.init_lca();
T.etdfs();
T.qdfs();
cin >> q;
for (int i = (0); i < (int)(q); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
cout << T.query(u, v).n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
const int LOG = 20;
const int MOD = 1e9 + 7;
int s_time[MAXN], f_time[MAXN];
int from[MAXN], to[MAXN], we[MAXN];
int n, q;
int v, u, w;
long long num;
long long sum_up[3][MAXN], sum_down[3][MAXN];
long long sum_total[MAXN];
int par[LOG + 5][MAXN];
int row[MAXN];
vector<int> adj[MAXN];
bool is_child(int u, int v) {
return (s_time[v] <= s_time[u] && f_time[u] <= f_time[v]);
}
int get_par(int k, int v) {
for (int i = 0; i < 20; i++)
if (k & (1 << i)) v = par[i][v];
return v;
}
int lca(int u, int v) {
if (row[u] > row[v]) swap(u, v);
v = get_par(row[v] - row[u], v);
if (u == v) return u;
for (int i = LOG; i >= 0; i--)
if (par[i][v] != par[i][u]) {
u = par[i][u];
v = par[i][v];
}
return par[0][v];
}
void dfs_down(int p, int v) {
s_time[v] = num++;
sum_down[0][v]++;
par[0][v] = p;
for (int i = 1; i < LOG; i++) par[i][v] = par[i - 1][par[i - 1][v]];
for (int i = 0; i < ((int)adj[v].size()); i++) {
int id = adj[v][i];
long long w = we[id];
int u = from[id] + to[id] - v;
if (u == p) continue;
row[u] = row[v] + 1;
dfs_down(v, u);
sum_down[0][v] += sum_down[0][u];
sum_down[1][v] += sum_down[1][u] + (w * sum_down[0][u]);
sum_down[2][v] += (w * w % MOD * sum_down[0][u]) + sum_down[2][u] +
(2 * w * sum_down[1][u]);
sum_down[0][v] %= MOD;
sum_down[1][v] %= MOD;
sum_down[2][v] %= MOD;
}
f_time[v] = num;
}
void dfs_up(int p, int v) {
for (int i = 0; i < ((int)adj[v].size()); i++) {
int id = adj[v][i];
long long w = we[id];
int u = from[id] + to[id] - v;
if (u == p) continue;
sum_total[u] = (sum_total[v] + w) % MOD;
sum_up[0][u] = n - sum_down[0][u];
sum_up[1][u] = sum_up[1][v] + sum_down[1][v] - sum_down[1][u] -
(w * sum_down[0][u]) % MOD + (sum_up[0][u] * w) % MOD;
sum_up[2][u] = (sum_up[0][u] * w % MOD * w) % MOD + sum_up[2][v] +
sum_down[2][v] - sum_down[2][u] -
2 * w % MOD * sum_down[1][u] -
w * w % MOD * sum_down[0][u] % MOD +
(2 * w % MOD *
((sum_up[1][v] + sum_down[1][v] - sum_down[1][u] -
sum_down[0][u] * w) %
MOD));
sum_up[0][u] %= MOD;
sum_up[1][u] %= MOD;
sum_up[2][u] %= MOD;
dfs_up(v, u);
}
}
long long calc_1(int u, int v) {
long long y = (sum_total[u] + sum_total[v] - 2 * sum_total[lca(u, v)]) % MOD;
long long s =
(sum_up[2][v] + 2 * y % MOD * sum_up[1][v] + y * y % MOD * sum_up[0][v]) %
MOD;
long long tot = (sum_down[2][u] + sum_up[2][u]) % MOD;
return ((tot - 2 * s) % MOD + MOD) % MOD;
}
long long calc_2(int u, int v) {
long long y = sum_total[u] + sum_total[v] - 2 * sum_total[lca(u, v)];
long long s = sum_down[2][v] + 2 * y % MOD * sum_down[1][v] % MOD +
y * y % MOD * sum_down[0][v] % MOD;
long long tot = sum_down[2][u] + sum_up[2][u];
return ((s - (tot - s)) % MOD + MOD) % MOD;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v >> w;
u--, v--;
adj[u].push_back(i);
adj[v].push_back(i);
from[i] = u;
to[i] = v;
we[i] = w;
}
dfs_down(0, 0);
dfs_up(0, 0);
cin >> q;
while (q--) {
cin >> u >> v;
u--;
v--;
if (is_child(u, v))
cout << calc_1(u, v);
else
cout << calc_2(u, v);
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const long long MXN = 2e5 + 10;
const long long LOG = 20;
const long long Mod = 1e9 + 7;
long long n, timer, q;
long long Jad[LOG][MXN], dis[MXN], Stm[MXN], Ftm[MXN];
long long dp[2][MXN], sig[2][MXN], sub[MXN], Tdis[MXN];
vector<pair<long long, long long>> adj[MXN];
void prep(long long u, long long par) {
timer++, Stm[u] = timer, Jad[0][u] = par;
for (int i = 1; i < LOG; i++) {
Jad[i][u] = Jad[i - 1][Jad[i - 1][u]];
}
for (auto Pr : adj[u]) {
long long v, w;
tie(v, w) = Pr;
if (v == par) continue;
dis[v] = (dis[u] + w) % Mod;
Tdis[v] = Tdis[u] + 1;
prep(v, u);
}
Ftm[u] = timer;
}
long long K_Jad(long long u, long long k) {
for (int i = 0; i < LOG; i++) {
if ((k >> i) & 1LL) u = Jad[i][u];
}
return u;
}
long long LCA(long long u, long long v) {
if (Tdis[u] > Tdis[v]) swap(u, v);
v = K_Jad(v, Tdis[v] - Tdis[u]);
if (u == v) return u;
for (int i = LOG - 1; ~i; i--) {
if (Jad[i][u] != Jad[i][v]) {
u = Jad[i][u], v = Jad[i][v];
}
}
return Jad[0][u];
}
inline long long Fix(long long x) {
x %= Mod;
if (x < 0) x += Mod;
return x;
}
inline long long DIS(long long u, long long v) {
return Fix(dis[u] + dis[v] - (2ll * dis[LCA(u, v)] % Mod));
}
inline long long Is_Jad(long long x, long long u) {
return (Stm[x] <= Stm[u] && Ftm[u] <= Ftm[x]);
}
inline long long Func(long long a, long long b) {
return (((a * a % Mod) * (b * b % Mod) % Mod) + (a * b % Mod) * 2 % Mod) %
Mod;
}
void DFS_down(long long u, long long par) {
sub[u] = 1;
for (auto Pr : adj[u]) {
long long v, w, nw;
tie(v, w) = Pr;
if (v == par) continue;
DFS_down(v, u);
sub[u] += sub[v];
sig[0][u] = (sig[0][u] + sig[0][v] + w * sub[v] % Mod) % Mod;
nw = (dp[0][v] + sub[v] * (w * w % Mod) % Mod) % Mod;
nw = (nw + 2 * w * sig[0][v] % Mod) % Mod;
dp[0][u] = (dp[0][u] + nw) % Mod;
}
}
void DFS_up(long long u, long long par, long long prw) {
long long ex, now, nw;
if (par) {
sig[1][u] = (sig[1][u] + sig[1][par] + prw * (n - sub[par]) % Mod) % Mod;
nw = Fix(sig[0][par] - (sig[0][u] + prw * sub[u] % Mod));
sig[1][u] = (sig[1][u] + nw) % Mod;
sig[1][u] = (sig[1][u] + (sub[par] - sub[u]) * prw % Mod) % Mod;
dp[1][u] =
(dp[1][u] + dp[1][par] + (prw * prw % Mod) * (n - sub[par]) % Mod);
dp[1][u] = (dp[1][u] + (2 * prw % Mod) * sig[1][par] % Mod) % Mod;
ex = (dp[0][u] + sub[u] * (prw * prw % Mod) % Mod) % Mod;
ex = (ex + 2 * prw * sig[0][u] % Mod) % Mod;
now = (prw * prw % Mod) * (sub[par] - sub[u]) % Mod;
now = (now + (nw * prw % Mod) * 2) % Mod;
dp[1][u] = (dp[1][u] + Fix(dp[0][par] - ex) + now) % Mod;
}
for (auto Pr : adj[u]) {
long long v, w, nw;
tie(v, w) = Pr;
if (v == par) continue;
DFS_up(v, u, w);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int 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});
}
prep(1, 0);
DFS_down(1, 0);
DFS_up(1, 0, 0);
cin >> q;
while (q--) {
long long u, v, val1, val2, nw, ex, d, kol;
cin >> u >> v;
d = DIS(u, v);
kol = (dp[0][u] + dp[1][u]) % Mod;
if (Is_Jad(v, u)) {
val2 = (((dp[1][v] + (d * d % Mod) * (n - sub[v]) % Mod) % Mod) +
(sig[1][v] * d % Mod) * 2 % Mod) %
Mod;
val1 = Fix(kol - val2 + Mod);
cout << Fix(val1 - val2) << '\n';
} else {
val1 = (dp[0][v] + (d * d % Mod) * sub[v] + (d * sig[0][v]) * 2) % Mod;
val2 = Fix(kol - val1);
cout << Fix(val1 - val2) << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
const int P = 1000000007;
int H[N], to[N], len[N], nxt[N], e = 1;
void addedge(int t, int v, int s) {
e++, to[e] = v, len[e] = s, nxt[e] = H[t], H[t] = e;
e++, to[e] = t, len[e] = s, nxt[e] = H[v], H[v] = e;
}
struct A {
long long size, val, ans;
};
A operator+(A x, A y) {
return {x.size + y.size, (x.val + y.val) % P, (x.ans + y.ans) % P};
}
A operator-(A x, A y) {
return {x.size - y.size, (x.val - y.val) % P, (x.ans - y.ans) % P};
}
A operator*(A x, long long mul) {
return {x.size, (x.val + mul * x.size) % P,
(x.ans + 2 * mul * x.val % P + mul * mul % P * x.size) % P};
}
A dp[N], up[N], down[N];
void Build(int u, int f) {
for (int i = H[u], v = to[i]; i; i = nxt[i], v = to[i])
if (v != f) {
down[v] = (down[u] + dp[u] - up[v]) * len[i];
Build(v, u);
}
}
void init_(int u, int f) {
dp[u] = {1, 0, 0};
for (int i = H[u], v = to[i]; i; i = nxt[i], v = to[i])
if (v != f) {
init_(v, u);
up[v] = dp[v] * len[i];
dp[u] = dp[u] + up[v];
}
}
long long dis[N];
int dep[N], fa[N][21];
void dfs(int u, int f) {
fa[u][0] = f;
dep[u] = dep[f] + 1;
for (int i = 1; i <= 20; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
for (int i = H[u], v = to[i]; i; i = nxt[i], v = to[i])
if (v != f) {
dis[v] = dis[u] + len[i];
dfs(v, u);
}
}
int calc(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 20; i >= 0; i--)
if (dep[fa[u][i]] >= dep[v]) u = fa[u][i];
if (u == v) return u;
for (int i = 20; i >= 0; i--)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
int main() {
int n;
cin >> n;
for (int i = 2; i <= n; i++) {
int t, v, s;
scanf("%d%d%d", &t, &v, &s);
addedge(t, v, s);
}
dfs(1, 0);
init_(1, 0);
Build(1, 0);
int m;
cin >> m;
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
int s = calc(u, v);
long long dist = (dis[u] + dis[v] - dis[s] * 2) % P;
if (s == v) {
A add = dp[u] + down[u];
A Dec = down[v] * dist;
printf("%d\n", (int)((add.ans - 2 * Dec.ans) % P + P) % P);
} else {
A add = dp[v] * dist;
A Dec = dp[u] + down[u];
printf("%d\n", (int)((2 * add.ans - Dec.ans) % P + P) % P);
}
}
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) { return (long long)a * b % mod; }
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;
int N, K, D, Q, st[200005], Dep[200005], Dis[200005], C[20][20], F[20][200005];
struct Lin {
int v, c, next;
} E[200005];
struct Nod {
int A[20];
Nod() { memset(A, 0, sizeof(A)); }
Nod operator*(int k) {
Nod c;
k = (k + 1000000007) % 1000000007;
for (int i = 0; i <= K; i++)
for (int j = i, x = 1; j + 1; j--)
(c.A[i] += 1ll * x * A[j] % 1000000007 * C[i][j] % 1000000007) %=
1000000007,
x = 1ll * x * k % 1000000007;
return c;
}
Nod operator+(const Nod& b) {
Nod c;
for (int i = 0; i <= K; i++) c.A[i] = (A[i] + b.A[i]) % 1000000007;
return c;
}
Nod operator-(const Nod& b) {
Nod c;
for (int i = 0; i <= K; i++)
c.A[i] = (A[i] - b.A[i] + 1000000007) % 1000000007;
return c;
}
} A[200005], T[200005];
int IN() {
int x = 0, ch;
for (; (ch = getchar()) < '0' || ch > '9';)
;
for (; ch >= '0' && ch <= '9'; (ch = getchar())) (x *= 10) += ch - '0';
return x;
}
void Link(int c = IN(), int v = IN(), int u = IN()) {
E[++D] = (Lin){v, c, st[u]};
st[u] = D;
E[++D] = (Lin){u, c, st[v]};
st[v] = D;
}
void Pre(int u, int f) {
T[u].A[0] = 1;
F[0][u] = f;
Dep[u] = Dep[f] + 1;
for (int i = st[u], v; i; i = E[i].next)
if ((v = E[i].v) ^ f) Pre(v, u), T[u] = T[u] + T[v] * E[i].c;
A[u] = T[u];
}
void DFS(int u, int f, Nod t) {
T[u] = T[u] + t;
for (int i = st[u], v; i; i = E[i].next)
if ((v = E[i].v) ^ f) {
Dis[v] = (Dis[u] + E[i].c) % 1000000007;
DFS(v, u, (T[u] - T[v] * E[i].c) * E[i].c);
}
}
int LCA(int u, int v) {
if (Dep[u] > Dep[v]) swap(u, v);
for (int i = 16, d = Dep[v] - Dep[u]; i + 1; i--)
if ((1 << i) & d) v = F[i][v];
if (u == v) return u;
for (int i = 16; i + 1; i--)
if (F[i][u] != F[i][v]) u = F[i][u], v = F[i][v];
return F[0][u];
}
int main() {
N = IN();
K = 2;
for (int i = 2; i <= N; i++) Link();
for (int i = 0; i <= K; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
Pre(1, 0);
DFS(1, 0, Nod());
for (int i = 1; i <= 16; i++)
for (int j = 1; j <= N; j++) F[i][j] = F[i - 1][F[i - 1][j]];
for (Q = IN(); Q--;) {
int u = IN(), v = IN(), x = 2, z = LCA(u, v);
if (z == v) {
Nod t = (T[v] - A[v]) * ((Dis[u] + Dis[v] - 2 * Dis[z]) % 1000000007);
printf("%d\n", (T[u] - t - t).A[x]);
} else {
Nod t = A[v] * ((Dis[u] + Dis[v] - 2 * Dis[z]) % 1000000007);
printf("%d\n", (t + t - T[u]).A[x]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_N = 100 * 1000 + 10;
const int LOG = 20 + 5;
vector<pair<int, int>> adj[MAX_N];
int dp1[MAX_N], dp2[MAX_N];
int dp3[MAX_N], dp4[MAX_N];
int par[MAX_N][LOG];
int cmp[MAX_N], n;
int dis[MAX_N];
int h[MAX_N];
long long mul(long long a, long long b) {
a %= MOD, b %= MOD;
return a * b % MOD;
}
long long change(long long n) { return (n % MOD + MOD) % MOD; }
void dfs1(int u = 0, int dad = 0) {
par[u][0] = dad, cmp[u] = 1;
for (int i = 1; i < LOG; i++) par[u][i] = par[par[u][i - 1]][i - 1];
for (auto x : adj[u])
if (x.first != dad) {
int v = x.first, w = x.second;
h[v] = h[u] + 1, dis[v] = change(dis[u] + w), dfs1(v, u);
cmp[u] += cmp[v];
dp1[u] = change(dp1[u] + dp1[v] + mul(cmp[v], w));
dp2[u] =
change(dp2[u] + dp2[v] + mul(cmp[v], mul(w, w)) + mul(2 * dp1[v], w));
}
}
void dfs2(int u = 0, int dad = 0, int w = 0) {
dp3[u] = change(dp3[dad] + mul(n - 2 * cmp[u], w));
dp4[u] = change(dp4[dad] + mul(n, mul(w, w)) +
mul(dp3[dad] - 2 * (dp1[u] + mul(cmp[u], w)), 2 * w));
for (auto x : adj[u])
if (x.first != dad) dfs2(x.first, u, x.second);
}
int get_par(int u, int k) {
for (int i = 0; i < LOG; i++)
if (k >> i & 1) u = par[u][i];
return u;
}
int lca(int u, int v) {
if (h[u] > h[v]) swap(u, v);
v = get_par(v, h[v] - h[u]);
if (u == v) return u;
for (int i = LOG - 1; ~i; i--)
if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
return par[u][0];
}
int F(int u, int v) {
int x = lca(u, v);
int d = change(dis[u] + dis[v] - 2 * dis[x]);
if (x != v)
return change(2 * (dp2[v] + mul(cmp[v], mul(d, d)) + mul(dp1[v], 2 * d)) -
dp4[u]);
return change(dp4[u] - 2 * (dp4[v] - dp2[v] + mul(n - cmp[v], mul(d, d)) +
mul(dp3[v] - dp1[v], 2 * d)));
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
dfs1(), dp3[0] = dp1[0], dp4[0] = dp2[0], dfs2();
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
u--, v--;
cout << F(u, v) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5, maxq = 5000, mod = 1e9 + 7;
int n, dfn[maxn + 10], ed[maxn + 10], dcnt;
int dep[maxn + 10], val[maxn + 10], q;
vector<pair<int, int> > ask[maxn + 10];
int ans[maxn + 10];
struct edge {
int to, w;
};
vector<edge> g[maxn + 10];
void dfs(int p, int fa) {
dfn[p] = ++dcnt;
val[dcnt] = dep[p];
for (auto i : g[p]) {
if (i.to != fa) {
dep[i.to] = (dep[p] + i.w) % mod;
dfs(i.to, p);
}
}
ed[p] = dcnt;
}
namespace seg {
int ls[maxn * 4 + 10], rs[maxn * 4 + 10];
int s1[maxn * 4 + 10], s2[maxn * 4 + 10], tag[maxn * 4 + 10];
void upd(int p) {
s1[p] = (s1[p << 1] + s1[p << 1 | 1]) % mod;
s2[p] = (s2[p << 1] + s2[p << 1 | 1]) % mod;
}
void build(int p, int l, int r) {
ls[p] = l;
rs[p] = r;
if (l == r) {
s1[p] = val[l];
s2[p] = 1ll * val[l] * val[l] % mod;
} else {
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
upd(p);
}
}
void apply(int p, int v) {
int len = rs[p] - ls[p] + 1;
(s2[p] += (1ll * v * v % mod * len + 2ll * v * s1[p]) % mod) %= mod;
(s1[p] += 1ll * len * v % mod) %= mod;
(tag[p] += v) %= mod;
}
void push(int p) {
if (tag[p]) {
apply(p << 1, tag[p]);
apply(p << 1 | 1, tag[p]);
tag[p] = 0;
}
}
void modify(int p, int l, int r, int v) {
if (ls[p] == l && rs[p] == r)
apply(p, v);
else {
int mid = (ls[p] + rs[p]) >> 1;
push(p);
if (r <= mid)
modify(p << 1, l, r, v);
else if (l > mid)
modify(p << 1 | 1, l, r, v);
else {
modify(p << 1, l, mid, v);
modify(p << 1 | 1, mid + 1, r, v);
}
upd(p);
}
}
int query(int p, int l, int r) {
if (ls[p] == l && rs[p] == r)
return s2[p];
else {
int mid = (ls[p] + rs[p]) >> 1;
push(p);
if (r <= mid)
return query(p << 1, l, r);
else if (l > mid)
return query(p << 1 | 1, l, r);
else
return (query(p << 1, l, mid) + query(p << 1 | 1, mid + 1, r)) % mod;
}
}
} // namespace seg
int adj(int x) { return (x % mod + mod) % mod; }
void dfsans(int p, int fa) {
for (auto i : ask[p]) {
int w = i.first;
int s1 = seg::query(1, dfn[w], ed[w]);
int s2 = seg::query(1, 1, n);
s2 = adj(s2 - s1);
s2 = adj(s1 - s2);
ans[i.second] = s2;
}
for (auto i : g[p]) {
if (i.to != fa) {
seg::modify(1, 1, n, i.w);
seg::modify(1, dfn[i.to], ed[i.to], adj(-i.w * 2));
dfsans(i.to, p);
seg::modify(1, 1, n, adj(-i.w));
seg::modify(1, dfn[i.to], ed[i.to], i.w * 2 % mod);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int l, r, w;
scanf("%d%d%d", &l, &r, &w);
g[l].push_back((edge){r, w});
g[r].push_back((edge){l, w});
}
dfs(1, 0);
seg::build(1, 1, n);
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
ask[x].push_back(make_pair(y, i));
}
dfsans(1, 0);
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, mod = 1e9 + 7, lg = 16 + 2;
int n, q, par[N][lg], sumup[N][lg], tvin[N][lg], sumin[N][lg], cntin[N][lg],
sumst[N], tvst[N], cntst[N], updtv[N], updsum[N], updcnt[N], h[N];
vector<pair<int, int> > gr[N];
long long mrg(int ftv, int fsum, int fcnt, int add) {
return 1ll *
(1ll * ftv + 1ll * fsum * add % mod * 2 % mod +
1ll * add * add % mod * fcnt % mod) %
mod;
}
void getSt(int v, int par = -1) {
for (auto p : gr[v]) {
int u = p.first, w = p.second;
if (u != par) {
getSt(u, v);
updtv[u] = mrg(tvst[u], sumst[u], cntst[u], w),
tvst[v] = (tvst[v] + updtv[u]) % mod;
updsum[u] = (1ll * cntst[u] * w % mod + sumst[u]) % mod,
sumst[v] = (sumst[v] + updsum[u]) % mod;
updcnt[u] = cntst[u], cntst[v] = cntst[v] + updcnt[u];
}
}
cntst[v]++;
}
void getPr(int v, int parent = -1, int wb = -1) {
if (parent != -1) {
h[v] = h[parent] + 1;
par[v][0] = parent, sumup[v][0] = wb;
for (int i = 1; i < lg - 1; i++)
par[v][i] = par[par[v][i - 1]][i - 1],
sumup[v][i] = (sumup[v][i - 1] + sumup[par[v][i - 1]][i - 1]) % mod;
cntin[v][0] = cntst[parent] - updcnt[v],
sumin[v][0] = (sumst[parent] - updsum[v] + mod) % mod;
tvin[v][0] = mrg((tvst[parent] - updtv[v] + mod) % mod, sumin[v][0],
cntin[v][0], wb);
sumin[v][0] = (sumin[v][0] + 1ll * cntin[v][0] * wb % mod) % mod;
for (int i = 1; i < lg - 1; i++) {
cntin[v][i] = (cntin[v][i - 1] + cntin[par[v][i - 1]][i - 1]) % mod;
sumin[v][i] = ((sumin[v][i - 1] + 1ll * sumup[v][i - 1] *
cntin[par[v][i - 1]][i - 1] % mod) %
mod +
sumin[par[v][i - 1]][i - 1] % mod) %
mod;
tvin[v][i] = (tvin[v][i - 1] +
mrg(tvin[par[v][i - 1]][i - 1], sumin[par[v][i - 1]][i - 1],
cntin[par[v][i - 1]][i - 1], sumup[v][i - 1])) %
mod;
}
}
for (auto p : gr[v]) {
int u = p.first, w = p.second;
if (u != parent) getPr(u, v, w);
}
}
bool isAnc(int v, int u) {
int diff = h[v] - h[u];
if (diff <= 0) return false;
for (int i = 0; i < lg - 1; i++)
if (((diff >> i) & 1)) v = par[v][i];
if (v == u) return true;
return false;
}
int AnsAnc(int v, int u) {
int pst = tvst[v], rtr = 0, sumrn = 0;
int diff = h[v] - h[u];
for (int i = lg - 1; i >= 0; i--) {
if (((diff >> i) & 1)) {
rtr = (rtr + mrg(tvin[v][i], sumin[v][i], cntin[v][i], sumrn)) % mod;
sumrn = (sumrn + sumup[v][i]) % mod;
v = par[v][i];
}
}
return (rtr + pst) % mod;
}
int getSum(int v, int u) {
if (h[u] > h[v]) swap(u, v);
int diff = h[v] - h[u], rtr = 0;
for (int i = 0; i < lg - 1; i++) {
if (((diff >> i) & 1)) rtr = (rtr + sumup[v][i]) % mod, v = par[v][i];
}
if (v == u) return rtr;
for (int i = lg - 1; i >= 0; i--) {
if (par[v][i] != par[u][i]) {
rtr = ((rtr + sumup[v][i]) % mod + sumup[u][i]) % mod;
v = par[v][i], u = par[u][i];
}
}
rtr = ((rtr + sumup[v][0]) % mod + sumup[u][0]) % mod;
return rtr;
}
int AnsN(int v, int u) {
int sum = getSum(v, u);
return mrg(tvst[u], sumst[u], cntst[u], sum);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y, w;
cin >> x >> y >> w;
x--, y--;
gr[x].push_back({y, w});
gr[y].push_back({x, w});
}
getSt(0);
getPr(0);
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
x--, y--;
long long rtr;
if (isAnc(x, y))
rtr = AnsAnc(x, y);
else
rtr = AnsN(x, y);
int mn = AnsAnc(x, 0);
rtr = ((rtr * 2 - mn) % mod + mod) % mod;
cout << rtr << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
void solve();
int main() {
cin.tie(0);
cout.sync_with_stdio(0);
cout.precision(10);
cout << fixed;
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
int TIMER = 1;
vector<pair<long long, long long> > g[101010];
int tin[101010];
int tout[101010];
long long depth[101010];
long long cntDown[101010];
long long sumDistDown[101010];
long long sumSqrDistDown[101010];
long long sumDist[101010];
long long sumSqrDist[101010];
long long sumDistUp[101010];
long long sumSqrDistUp[101010];
const int MOD = 1000000007;
int n;
int l = 17;
vector<int> up[101010];
void dfs(int v, int p) {
tin[v] = ++TIMER;
cntDown[v] = 1;
up[v][0] = p;
for (int i = 1; i <= l; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
for (pair<int, int> to : g[v]) {
if (to.first == p) continue;
depth[to.first] = depth[v] + to.second;
depth[to.first] %= MOD;
dfs(to.first, v);
cntDown[v] += cntDown[to.first];
sumDistDown[v] += sumDistDown[to.first] + cntDown[to.first] * to.second;
sumDistDown[v] %= MOD;
sumSqrDistDown[v] += sumSqrDistDown[to.first] +
to.second * 2 * sumDistDown[to.first] % MOD +
cntDown[to.first] * to.second % MOD * to.second;
sumSqrDistDown[v] %= MOD;
}
tout[v] = ++TIMER;
}
void dfs2(int v, int p) {
for (pair<int, int> to : g[v]) {
if (to.first == p) continue;
sumDist[to.first] = sumDist[v] - to.second * cntDown[to.first] +
to.second * (n - cntDown[to.first]);
sumDist[to.first] %= MOD;
sumDistUp[to.first] = (sumDist[to.first] - sumDistDown[to.first]) % MOD;
sumSqrDist[to.first] =
sumSqrDist[v] -
2 * to.second *
(sumDistDown[to.first] + to.second * cntDown[to.first] % MOD) +
cntDown[to.first] * to.second % MOD * to.second;
sumSqrDist[to.first] +=
2 * to.second *
(sumDistUp[to.first] - to.second * (n - cntDown[to.first]) % MOD) +
(n - cntDown[to.first]) * to.second % MOD * to.second;
sumSqrDist[to.first] %= MOD;
sumSqrDistUp[to.first] =
(sumSqrDist[to.first] - sumSqrDistDown[to.first]) % MOD;
dfs2(to.first, v);
}
tout[v] = ++TIMER;
}
bool upper(int v, int u) { return (tin[v] <= tin[u] && tout[v] >= tout[u]); }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = l; i >= 0; --i)
if (!upper(up[a][i], b)) a = up[a][i];
return up[a][0];
}
long long dist(long long u, long long v) {
long long x = lca(u, v);
return (depth[u] + depth[v] - 2 * depth[x]) % MOD;
}
void solve() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
}
for (int i = 0; i < n; ++i) up[i].resize(l + 1);
dfs(0, 0);
sumDist[0] = sumDistDown[0];
sumSqrDist[0] = sumSqrDistDown[0];
dfs2(0, -1);
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
long long ans = 0;
long long d = dist(u, v);
if (upper(v, u)) {
ans = sumSqrDist[u] - (sumSqrDistUp[v] + 2 * d * sumDistUp[v] +
d * d % MOD * (n - cntDown[v]));
} else {
ans =
sumSqrDistDown[v] + 2 * d * sumDistDown[v] + cntDown[v] * d % MOD * d;
}
ans %= MOD;
ans = 2 * ans - sumSqrDist[u];
ans %= MOD;
ans += MOD;
ans %= MOD;
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int MOD = 1e9 + 7;
struct segment {
int l, r, to_add;
pair<int, int> sum;
int size() { return r - l; }
int unity(int _l, int _r) { return max(0 * l, min(_r, r) - max(_l, l)); }
segment(int _l = 0, int _r = 0) {
l = _l;
r = _r;
sum = pair<int, int>(0, 0);
to_add = 0;
}
} seg[N << 2];
int n, h[N], lp[N], rp[N], ans[N];
vector<pair<int, int> > que[N], g[N];
vector<int> st;
int dfs(int, int = 0, int = 0, int = 0);
void build(int, int, int = 1);
void add(int, int, int = 1);
pair<int, int> get(int, int, int = 0, int = 1);
void update(int);
pair<int, int> get(int);
void answer(int, int = 0);
pair<int, int> calc(pair<int, int>, int, int);
pair<int, int> _pair_sum(pair<int, int>, pair<int, int>);
int _sum(int, int);
int _mul(int, int);
int _neg(int);
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int v, u, w;
cin >> v >> u >> w;
v--;
u--;
g[v].push_back({u, w});
g[u].push_back({v, w});
}
dfs(0);
build(0, n);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
que[v].push_back({u, i});
}
answer(0);
for (int i = 0; i < q; i++) cout << ans[i] << endl;
}
int dfs(int v, int pv, int d, int cur_pos) {
h[v] = d;
lp[v] = cur_pos;
rp[v] = cur_pos + 1;
st.push_back(v);
for (auto [u, w] : g[v])
if (u != pv) rp[v] = dfs(u, v, _sum(d, w), rp[v]);
return rp[v];
}
void answer(int v, int pv) {
int sigma_t = _neg(get(0).second);
for (auto [u, query] : que[v])
ans[query] = _sum(sigma_t, _mul(2, get(u).second));
for (auto [u, w] : g[v])
if (u != pv) {
add(0, w);
add(u, _mul(_neg(2), w));
answer(u, v);
add(u, _mul(2, w));
add(0, _mul(_neg(1), w));
}
}
void build(int l, int r, int v) {
seg[v] = segment(l, r);
if (r - l == 1) {
seg[v].sum = {h[st[l]], _mul(h[st[l]], h[st[l]])};
return;
}
int med = (l + r) / 2;
build(l, med, v << 1);
build(med, r, v << 1 | 1);
update(v);
}
void add(int ver, int val, int v) {
int l = lp[ver];
int r = rp[ver];
if (seg[v].unity(l, r) == 0) return;
if (seg[v].unity(l, r) == seg[v].size()) {
seg[v].to_add = _sum(seg[v].to_add, val);
seg[v].sum = calc(seg[v].sum, seg[v].size(), val);
return;
}
add(ver, val, v << 1);
add(ver, val, v << 1 | 1);
update(v);
seg[v].sum = calc(seg[v].sum, seg[v].size(), seg[v].to_add);
}
pair<int, int> get(int ver) { return get(lp[ver], rp[ver]); }
pair<int, int> get(int l, int r, int par_sum, int v) {
if (seg[v].unity(l, r) == 0) return pair<int, int>(0, 0);
if (seg[v].unity(l, r) == seg[v].size())
return calc(seg[v].sum, seg[v].size(), par_sum);
pair<int, int> lc = get(l, r, _sum(par_sum, seg[v].to_add), v << 1);
pair<int, int> rc = get(l, r, _sum(par_sum, seg[v].to_add), v << 1 | 1);
return _pair_sum(lc, rc);
}
void update(int v) {
seg[v].sum = _pair_sum(seg[v << 1].sum, seg[v << 1 | 1].sum);
}
pair<int, int> calc(pair<int, int> v, int cnt, int d) {
auto [A, B] = v;
int C = _mul(d, cnt);
int sum_1 = _sum(A, C);
int sum_2 = _sum(_sum(B, _mul(d, C)), _mul(_mul(2, d), A));
return pair<int, int>(sum_1, sum_2);
}
int _sum(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
int _mul(int a, int b) { return 1LL * a * b % MOD; }
int _neg(int x) {
return MOD - x;
x = -x;
while (x < 0) x += MOD;
return x;
}
pair<int, int> _pair_sum(pair<int, int> a, pair<int, int> b) {
return pair<int, int>(_sum(a.first, b.first), _sum(a.second, b.second));
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<pair<int, int> > G[100005];
int Level[100005], D[100005];
int Sum[100005], Total[100005], Sz[100005], Left[100005], Right[100005], cnt;
int SumSq[100005], TotalSq[100005];
int Father[20][100005], Log[100005];
const int MOD = 1000000007;
inline void Add(int& x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
inline void Sub(int& x, int y) {
x -= y;
if (x < 0) x += MOD;
}
void Read() {
scanf("%d", &N);
for (int i = 1; i < N; i++) {
int x, y, c;
scanf("%d%d%d", &x, &y, &c);
G[x].push_back(make_pair(y, c));
G[y].push_back(make_pair(x, c));
}
}
void DFS(int node, int father, int cost) {
Father[0][node] = father;
Level[node] = Level[father] + 1;
D[node] = D[father] + cost;
if (D[node] >= MOD) D[node] -= MOD;
Left[node] = ++cnt;
Sz[node] = 1;
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i].first, c = G[node][i].second;
if (neighb == father) continue;
DFS(neighb, node, c);
Sz[node] += Sz[neighb];
int val = Sum[neighb];
Add(val, (1LL * c * Sz[neighb]) % MOD);
Add(Sum[node], val);
val = SumSq[neighb];
int aux = (1LL * c * c) % MOD;
Add(val, (1LL * aux * Sz[neighb]) % MOD);
Add(val, (2LL * c * Sum[neighb]) % MOD);
Add(SumSq[node], val);
}
Right[node] = cnt;
}
void DFS2(int node, int father, int cost) {
if (node != 1) {
Total[node] = Total[father];
Add(Total[node], (1LL * (N - Sz[node]) * cost) % MOD);
Sub(Total[node], (1LL * Sz[node] * cost) % MOD);
TotalSq[node] = TotalSq[father];
int val = (1LL * cost * cost) % MOD;
val = (1LL * val * N) % MOD;
int aux = Total[node];
Sub(aux, Sum[node]);
Sub(aux, (1LL * (N - Sz[node]) * cost) % MOD);
Add(val, (2LL * (aux)*cost) % MOD);
int aux2 = Sum[node];
Add(aux2, (1LL * cost * Sz[node]) % MOD);
Sub(val, (2LL * cost * aux2) % MOD);
Add(TotalSq[node], val);
}
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i].first, c = G[node][i].second;
if (neighb == father) continue;
DFS2(neighb, node, c);
}
}
void precalcFather() {
for (int i = 1; (1 << i) <= N; i++) {
for (int j = 1; j <= N; j++) Father[i][j] = Father[i - 1][Father[i - 1][j]];
}
}
void precalcLog() {
for (int i = 2; i <= N; i++) Log[i] = Log[i / 2] + 1;
}
int F(int node, int dist) {
while (dist > 0) {
int k = Log[dist];
node = Father[k][node];
dist -= (1 << k);
}
return node;
}
int LCA(int x, int y) {
if (Level[x] > Level[y]) swap(x, y);
y = F(y, Level[y] - Level[x]);
if (x == y) return x;
for (int k = Log[N]; k >= 0; k--) {
if (Father[k][x] != Father[k][y]) {
x = Father[k][x];
y = Father[k][y];
}
}
return Father[0][x];
}
int Dist(int x, int y) {
int lca = LCA(x, y);
return (D[x] - D[lca] + D[y] - D[lca]) % MOD;
}
int Query(int u, int v) {
int d = Dist(u, v);
if (Left[u] >= Left[v] && Left[u] <= Right[v]) {
int aux = d;
d = (1LL * d * d) % MOD;
int sumOut = (1LL * (N - Sz[v]) * d) % MOD;
int val = Total[v];
Sub(val, Sum[v]);
Add(sumOut, (2LL * aux * val) % MOD);
Add(sumOut, TotalSq[v]);
Sub(sumOut, SumSq[v]);
int sum = TotalSq[u];
Sub(sum, (2LL * sumOut) % MOD);
return sum;
} else {
int aux = d;
d = (1LL * d * d) % MOD;
int sumIn = (1LL * Sz[v] * d) % MOD;
Add(sumIn, (2LL * aux * Sum[v]) % MOD);
Add(sumIn, SumSq[v]);
int sum = TotalSq[u];
Sub(sum, (2LL * sumIn) % MOD);
sum = MOD - sum;
if (sum >= MOD) sum -= MOD;
return sum;
}
}
int main() {
Read();
precalcLog();
DFS(1, 0, 0);
precalcFather();
for (int i = 1; i <= N; i++) {
Add(Total[1], D[i]);
Add(TotalSq[1], (1LL * D[i] * D[i]) % MOD);
}
DFS2(1, 0, 0);
int Q;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
int u, v;
scanf("%d%d", &u, &v);
int aux = Query(u, v);
if (aux < 0) aux += MOD;
if (aux >= MOD) aux -= MOD;
printf("%d\n", aux);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os << '(' << a.first << ", " << a.second << ')';
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &a) {
os << '[';
for (unsigned long long i = 0; i < a.size(); i++)
os << a[i] << (i < a.size() - 1 ? ", " : "");
os << ']';
return os;
}
long long n;
vector<vector<pair<long long, long long> > > a(N);
const long long mod = 1e9 + 7;
void norm(long long &x) {
x %= mod;
x += (x < 0 ? mod : 0);
}
struct LCAOn {
pair<long long, long long> tour[2 * N], rmq[2 * N][22];
long long depth[N], par[N], dis[N], sta[N], en[N], lg2[2 * N], Time = 0;
bool firstTime = true;
void dfs(long long u, long long p) {
tour[++Time] = {depth[u], u};
sta[u] = Time;
par[u] = p;
for (auto v : a[u])
if (v.first != p)
depth[v.first] = depth[u] + 1, dis[v.first] = dis[u] + v.second,
dfs(v.first, u);
tour[++Time] = {depth[u], u};
en[u] = Time;
}
void build_rmq() {
for (long long i = 1; i <= Time; ++i) rmq[i][0] = tour[i];
for (long long j = 1; (1 << j) <= Time; ++j)
for (long long i = 1; i + (1 << j) - 1 <= Time; ++i)
rmq[i][j] = min(rmq[i][j - 1], rmq[i + (1 << (j - 1))][j - 1]);
}
long long lca(long long u, long long v) {
if (sta[v] < sta[u]) swap(u, v);
if (en[u] >= en[v]) return u;
long long dist = lg2[sta[v] - en[u] + 1];
auto ans = min(rmq[en[u]][dist], rmq[sta[v] - (1 << dist) + 1][dist]);
return par[ans.second];
}
long long distance(long long u, long long v) {
long long p = lca(u, v);
long long ret = dis[u] + dis[v] - 2 * dis[p];
norm(ret);
return ret;
}
void init() {
if (firstTime)
for (long long i = 1; i < 2 * N; i++) lg2[i] = log2(i);
firstTime = false;
Time = 0;
dfs(1, 1);
build_rmq();
}
} LCA;
struct data {
long long cnt, dis1, dis2;
data(long long _cnt = 0, long long _dis1 = 0, long long _dis2 = 0)
: cnt(_cnt), dis1(_dis1), dis2(_dis2){};
};
void norm(data &x) {
norm(x.dis1);
norm(x.dis2);
}
data up[N], down[N];
bool inSubtree(long long p, long long u) {
if (LCA.lca(u, p) == p) return true;
return false;
}
long long calAllTree(long long u) { return (up[u].dis2 + down[u].dis2) % mod; }
long long calInSub(long long root, long long u) {
if (root == 1) return calAllTree(u);
long long w = LCA.distance(root, u);
long long ret =
up[root].dis2 + 2 * w * up[root].dis1 + up[root].cnt * w % mod * w % mod;
norm(ret);
ret = calAllTree(u) - ret;
norm(ret);
return ret;
}
long long calOutSub(long long root, long long u) {
long long w = LCA.distance(root, u);
long long ret =
down[root].dis2 + 2 * w * down[root].dis1 + down[root].cnt * w % mod * w;
norm(ret);
return ret;
}
void dfsUp(long long u, long long p) {
auto cur = down[u];
cur.cnt += up[u].cnt;
cur.dis1 += up[u].dis1;
cur.dis2 += up[u].dis2;
norm(cur);
for (auto it : a[u]) {
long long v = it.first;
long long w = it.second;
if (v == p) continue;
auto tmp = cur;
tmp.cnt -= down[v].cnt;
tmp.dis1 -= down[v].dis1 + w * down[v].cnt;
tmp.dis2 -= down[v].dis2 + 2 * w * down[v].dis1 + down[v].cnt * w % mod * w;
norm(tmp);
up[v].cnt += tmp.cnt;
up[v].dis1 += tmp.dis1 + w * tmp.cnt;
up[v].dis2 += tmp.dis2 + 2 * w * tmp.dis1 + tmp.cnt * w % mod * w;
norm(up[v]);
dfsUp(v, u);
}
}
void dfsDown(long long u, long long p) {
for (auto it : a[u]) {
long long v = it.first;
long long w = it.second;
if (v != p) {
dfsDown(v, u);
down[u].cnt += down[v].cnt;
down[u].dis1 += down[v].dis1 + w * down[v].cnt;
down[u].dis2 +=
down[v].dis2 + 2 * w * down[v].dis1 + down[v].cnt * w % mod * w;
norm(down[u]);
}
}
down[u].cnt++;
}
void prepDis() {
dfsDown(1, 1);
dfsUp(1, 1);
}
void preCheck() {
for (long long u = (long long)1; u <= (long long)n; u++) {
long long tup = 0;
long long tdown = 0;
for (long long v = (long long)1; v <= (long long)n; v++) {
if (inSubtree(u, v))
tdown += LCA.distance(u, v) * LCA.distance(u, v) % mod;
else
tup += LCA.distance(u, v) * LCA.distance(u, v) % mod;
}
norm(tup);
norm(tdown);
assert(tup == up[u].dis2);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = (long long)1; i <= (long long)n - 1; i++) {
long long u, v, w;
cin >> u >> v >> w;
a[u].push_back(make_pair(v, w));
a[v].push_back(make_pair(u, w));
}
LCA.init();
prepDis();
long long q;
cin >> q;
for (long long _ = (long long)1; _ <= (long long)q; _++) {
long long u, v;
cin >> u >> v;
long long ret = 0;
if (inSubtree(v, u))
ret = 2 * calInSub(v, u) - calAllTree(u);
else
ret = 2 * calOutSub(v, u) - calAllTree(u);
norm(ret);
cout << ret << '\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>
using namespace std;
int n, m, tot;
int head[100010], to[300010], net[300010];
long long val[300010], mod = 1000000007;
void add(int x, int y, int c) {
net[++tot] = head[x], head[x] = tot, to[tot] = y, val[tot] = c;
}
int deep[100010], size[100010], son[100010], fa[100010], top[100010];
struct your {
long long dis, sqr;
} dp[100010], sum[100010], all[100010];
long long dis[100010];
void dfs(int x) {
deep[x] = deep[fa[x]] + 1, size[x] = 1;
for (int i = head[x]; i; i = net[i])
if (to[i] != fa[x]) {
dis[to[i]] = (dis[x] + val[i]) % mod, fa[to[i]] = x, dfs(to[i]),
size[x] += size[to[i]];
if (size[to[i]] > size[son[x]]) son[x] = to[i];
dp[x].dis = (dp[x].dis + dp[to[i]].dis % mod +
(long long)size[to[i]] * val[i] % mod) %
mod;
long long tmp = (long long)size[to[i]] * val[i] % mod * val[i] % mod;
long long nmp = (dp[to[i]].sqr + 2 * val[i] * dp[to[i]].dis % mod) % mod;
dp[x].sqr = (dp[x].sqr + tmp + nmp) % mod;
}
}
void dfs2(int x) {
for (int i = head[x]; i; i = net[i]) {
if (to[i] == fa[x]) continue;
long long tmp =
(sum[x].dis + (long long)(n - 2 * size[to[i]]) * val[i]) % mod;
long long nmp = (dp[x].dis - dp[to[i]].dis + mod) % mod;
sum[to[i]].dis = (tmp + nmp) % mod;
tmp = (sum[x].sqr + 2 * sum[x].dis * val[i] % mod +
(long long)(n - size[x]) * val[i] % mod * val[i] % mod) %
mod;
long long dx, dy, dc;
dx = ((dp[x].sqr - dp[to[i]].sqr - 2 * val[i] * dp[to[i]].dis % mod -
(long long)size[to[i]] * val[i] % mod * val[i] % mod) %
mod +
mod) %
mod;
dy = (long long)(size[x] - size[to[i]]) * val[i] % mod * val[i] % mod;
dc = (2 * val[i] *
(dp[x].dis - dp[to[i]].dis -
(long long)val[i] * size[to[i]] % mod) %
mod +
mod) %
mod;
sum[to[i]].sqr = (tmp + dx + dy + dc) % mod;
dfs2(to[i]);
}
}
void dfs3(int x, int temp) {
top[x] = temp;
if (son[x]) dfs3(son[x], temp);
for (int i = head[x]; i; i = net[i])
if (to[i] != fa[x] && to[i] != son[x]) dfs3(to[i], to[i]);
}
int lca(int x, int y) {
while (top[x] != top[y]) {
if (deep[top[x]] < deep[top[y]]) swap(x, y);
x = fa[top[x]];
}
return deep[x] < deep[y] ? x : y;
}
void check(int x, int y);
int main() {
scanf("%d", &n);
for (int x, y, c, i = 1; i < n; i++)
scanf("%d%d%d", &x, &y, &c), add(x, y, c), add(y, x, c);
dfs(1), dfs2(1), dfs3(1, 1);
for (int i = 1; i <= n; i++) {
all[i].dis = (sum[i].dis + dp[i].dis) % mod;
all[i].sqr = (sum[i].sqr + dp[i].sqr) % mod;
}
scanf("%d", &m);
for (int x, y, i = 1; i <= m; i++) scanf("%d%d", &x, &y), check(x, y);
return 0;
}
void check(int x, int y) {
int l = lca(x, y);
if (l != x && l != y) {
long long c = ((dis[x] + dis[y] - 2 * dis[l]) % mod + mod) % mod;
long long tmp = (dp[y].sqr + (long long)c * c % mod * size[y] % mod +
2 * c * dp[y].dis % mod) %
mod;
printf("%lld\n", (2 * tmp % mod - all[x].sqr + mod) % mod);
} else if (l == x) {
long long c = ((dis[x] + dis[y] - 2 * dis[l]) % mod + mod) % mod;
long long tmp = (dp[y].sqr + (long long)c * c % mod * size[y] % mod +
2 * c * dp[y].dis % mod) %
mod;
printf("%lld\n", (2 * tmp % mod - all[x].sqr + mod) % mod);
} else if (l == y) {
long long c = ((dis[x] + dis[y] - 2 * dis[l]) % mod + mod) % mod;
long long tmp = (sum[y].sqr + (long long)c * c % mod * (n - size[y]) % mod +
2 * c * sum[y].dis % mod) %
mod;
printf("%lld\n", ((all[x].sqr - 2 * tmp) % mod + mod) % mod);
}
}
|
#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 vis[200005];
int cnt;
vector<pair<int, int> > stamp[200005];
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 L[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;
L[u] = tot++;
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);
stamp[u].push_back(make_pair(tot - 1, i));
}
}
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 fv = lca.p[v][0];
int pos = lower_bound(lca.stamp[fv].begin(), lca.stamp[fv].end(),
make_pair(lca.L[v], -1)) -
lca.stamp[fv].begin();
int idx = lca.stamp[fv][pos].second ^ 1;
int now = 1;
ret = lca.sum[u][2];
lca.Add(d, lca.w[idx]);
for (int i = 0; i <= 2; i++) {
lca.Add(ret, (1000000007 - 1ll * C[2][i] * lca.dp[idx][2 - i] %
1000000007 * now % 1000000007) %
1000000007);
now = 1ll * now * d % 1000000007;
}
} else {
int fv = lca.p[v][0];
int pos = lower_bound(lca.stamp[fv].begin(), lca.stamp[fv].end(),
make_pair(lca.L[v], -1)) -
lca.stamp[fv].begin();
int idx = lca.stamp[fv][pos].second;
int now = 1;
for (int i = 0; i <= 2; i++) {
lca.Add(ret, 1ll * C[2][i] * lca.dp[idx][2 - i] % 1000000007 * now %
1000000007);
now = 1ll * now * d % 1000000007;
}
}
ans += 2 * ret % 1000000007;
ans = (ans % 1000000007 + 1000000007) % 1000000007;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
clock_t time_p = clock();
void aryanc403() {}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return !(a.first < b.first || (a.first == b.first && a.second <= b.second));
}
};
void add(map<long long int, long long int>& m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt == m.end())
m.insert({x, cnt});
else
jt->second += cnt;
}
void del(map<long long int, long long int>& m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int>& a,
const pair<long long int, long long int>& b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 1000000007L;
const long long int N = 100000L;
template <class T>
struct RMQ {
vector<vector<T>> jmp;
RMQ(const vector<T>& V) : jmp(1, V) {
for (int pw = 1, k = 1; pw * 2 <= (long long int)(V).size(); pw *= 2, ++k) {
jmp.emplace_back((long long int)(V).size() - pw * 2 + 1);
for (int j = 0; j < ((long long int)(jmp[k]).size()); ++j)
jmp[k][j] = min(jmp[k - 1][j], jmp[k - 1][j + pw]);
}
}
T query(int a, int b) {
assert(a < b);
int dep = 31 - __builtin_clz(b - a);
return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
}
};
struct LCA {
int T = 0;
vector<long long int> time, path, ret;
vector<long long> dist;
RMQ<long long int> rmq;
LCA(vector<vector<pair<long long int, long long int>>>& C)
: time((long long int)(C).size()),
dist((long long int)(C).size()),
rmq((dfs(C), ret)) {}
void dfs(vector<vector<pair<long long int, long long int>>>& C, int v = 0,
int p = -1, long long di = 0) {
time[v] = T++, dist[v] = di;
for (auto& e : C[v])
if (e.first != p) {
path.push_back(v), ret.push_back(time[v]);
dfs(C, e.first, v, di + e.second);
}
}
int query(int a, int b) {
if (a == b) return a;
tie(a, b) = minmax(time[a], time[b]);
return path[rmq.query(a, b)];
}
long long distance(int a, int b) {
int lca = query(a, b);
return dist[a] + dist[b] - 2 * dist[lca];
}
};
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y;
long long int m;
string s;
vector<long long int> cst0, cst1, cst2;
vector<long long int> scst0, scst1, scst2;
vector<long long int> ucst1, ucst2;
vector<vector<pair<long long int, long long int>>> e;
vector<long long int> tin, tout, hei;
void dfs(long long int u, long long int p, long long int h) {
hei[u] = h;
tin[u] = ++T;
for (auto x : e[u]) {
const long long int v = x.first, w = x.second;
if (v == p) continue;
dfs(v, u, (h + w) % mod);
cst2[u] = (cst2[u] + cst2[v] + 2 * w * cst1[v] % mod +
cst0[v] * (w * w % mod) % mod) %
mod;
cst1[u] = (cst1[u] + cst1[v] % mod + cst0[v] * w % mod) % mod;
cst0[u] += cst0[v];
}
cst0[u]++;
tout[u] = ++T;
}
void dfs2(long long int u, long long int p,
pair<long long int, long long int> up) {
cst2[u] = (cst2[u] + up.second) % mod;
cst1[u] = (cst1[u] + up.first) % mod;
ucst2[u] = up.second % mod;
ucst1[u] = up.first % mod;
for (auto x : e[u]) {
const long long int v = x.first, w = x.second;
if (v == p) continue;
long long int h2 = cst2[u], h1 = cst1[u], h0 = n - cst0[v];
h2 -= cst0[v] * (w * w % mod) % mod + (2 * w * cst1[v]) % mod + cst2[v];
h1 -= cst0[v] * w + cst1[v];
h1 %= mod;
h2 %= mod;
h2 += 2 * w * h1 % mod;
h2 += (w * w % mod) * h0 % mod;
h1 += w * h0 % mod;
h1 %= mod;
h2 %= mod;
dfs2(v, u, {h1, h2});
}
}
long long int query(long long int u, long long int y) {
y %= mod;
long long int h0 = scst0[u];
long long int h1 = scst1[u];
long long int h2 = scst2[u];
h2 += 2 * y * h1 % mod;
h2 += (y * y % mod) * h0 % mod;
return h2;
}
long long int queryu(long long int u, long long int y) {
y %= mod;
long long int h0 = n - scst0[u];
long long int h1 = ucst1[u];
long long int h2 = ucst2[u];
h2 += 2 * y * h1 % mod;
h2 += (y * y % mod) * h0 % mod;
return h2;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
cin >> n;
e.resize(n + 1);
cst0.resize(n + 1);
cst1.resize(n + 1);
cst2.resize(n + 1);
ucst1.resize(n + 1);
ucst2.resize(n + 1);
tin.resize(n + 1);
tout.resize(n + 1);
hei.resize(n + 1);
for (i = 0; i < (n - 1); ++i) {
long long int w;
cin >> u >> v >> w;
e[u].push_back({v, w});
e[v].push_back({u, w});
}
dfs(1, -1, 0);
scst0 = cst0;
scst1 = cst1;
scst2 = cst2;
dfs2(1, -1, {0, 0});
e[0].push_back({1, 0});
e[1].push_back({0, 0});
LCA lca(e);
long long int q;
cin >> q;
while (q--) {
cin >> u >> v;
long long int ans = 0;
if (tin[v] <= tin[u] && tout[u] <= tout[v]) {
ans += cst2[u];
ans -= queryu(v, lca.distance(u, v));
} else {
ans += query(v, lca.distance(u, v));
}
ans *= 2;
ans -= cst2[u];
ans %= mod;
ans += mod;
ans %= mod;
cout << ans << "\n";
}
}
aryanc403();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int N = 100500;
int n;
vector<pair<int, int> > g[N];
const int MOD = 1e9 + 7;
inline int add(int a, int b) {
int res = a + b;
if (res >= MOD) res -= MOD;
return res;
}
inline int sub(int a, int b) {
int res = a - b;
if (res < 0) res += MOD;
return res;
}
inline int mul(int a, int b) {
long long res = a * 1LL * b;
if (res >= MOD) res %= MOD;
return int(res);
}
struct thing {
int cnt, sum, sumSq;
thing() {}
thing(int cnt, int sum, int sumSq) : cnt(cnt), sum(sum), sumSq(sumSq) {}
thing extend(int len) {
thing res(cnt, add(sum, mul(len, cnt)),
add(sumSq, add(mul(2, mul(sum, len)), mul(mul(len, len), cnt))));
return res;
}
};
thing operator+(const thing& a, const thing& b) {
thing res(add(a.cnt, b.cnt), add(a.sum, b.sum), add(a.sumSq, b.sumSq));
return res;
}
thing operator-(const thing& a, const thing& b) {
thing res(sub(a.cnt, b.cnt), sub(a.sum, b.sum), sub(a.sumSq, b.sumSq));
return res;
}
thing down[N];
void dfsDown(int v, int p = -1) {
down[v] = thing(1, 0, 0);
for (int i = int(0); i < int(int((g[v]).size())); ++i) {
int to = g[v][i].first;
if (to == p) continue;
dfsDown(to, v);
down[v] = down[v] + down[to].extend(g[v][i].second);
}
}
const int LOG = 20;
int pp[N][LOG];
thing sumAll[N];
thing ups[N];
int tin[N], tout[N], dep[N], curT;
int depLen[N];
void dfs(int v, int p = -1, thing up = thing(0, 0, 0)) {
ups[v] = up;
sumAll[v] = up + down[v];
tin[v] = curT++;
pp[v][0] = p == -1 ? v : p;
for (int i = int(1); i < int(LOG); ++i) pp[v][i] = pp[pp[v][i - 1]][i - 1];
for (int i = int(0); i < int(int((g[v]).size())); ++i) {
int to = g[v][i].first;
if (to == p) continue;
dep[to] = dep[v] + 1;
depLen[to] = add(depLen[v], g[v][i].second);
dfs(to, v,
(sumAll[v] - down[to].extend(g[v][i].second)).extend(g[v][i].second));
}
tout[v] = curT++;
}
bool isParent(int p, int v) { return tin[p] <= tin[v] && tout[v] <= tout[p]; }
int lca(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
for (int i = LOG - 1; i >= 0; --i) {
if (dep[pp[b][i]] > dep[a]) b = pp[b][i];
}
if (dep[a] != dep[b]) b = pp[b][0];
assert(dep[a] == dep[b]);
for (int i = LOG - 1; i >= 0; --i) {
if (pp[a][i] != pp[b][i]) {
a = pp[a][i];
b = pp[b][i];
}
}
if (a != b) {
a = pp[a][0];
b = pp[b][0];
}
assert(a == b);
return a;
}
int d(int a, int b) {
int p = lca(a, b);
return sub(add(depLen[a], depLen[b]), mul(2, depLen[p]));
}
int f(int a, int b) {
int res = sumAll[a].sumSq;
if (isParent(b, a)) {
res = sub(res, mul(2, ups[b].extend(d(a, b)).sumSq));
} else {
res = sub(res, mul(2, down[b].extend(d(a, b)).sumSq));
res = sub(0, res);
}
return res;
}
bool solve() {
if (scanf("%d", &n) != 1) return false;
curT = 0;
for (int i = int(0); i < int(n - 1); ++i) {
int a, b, c;
assert(scanf("%d%d%d", &a, &b, &c) == 3);
--a;
--b;
g[a].push_back(pair<int, int>(b, c));
g[b].push_back(pair<int, int>(a, c));
}
dep[0] = 0;
depLen[0] = 0;
dfsDown(0);
dfs(0);
int q;
assert(scanf("%d", &q) == 1);
for (int i = int(0); i < int(q); ++i) {
int a, b;
assert(scanf("%d%d", &a, &b) == 2);
--a;
--b;
printf("%d\n", f(a, b));
}
for (int i = int(0); i < int(n); ++i) {
g[i].clear();
}
return true;
}
int main() {
cout << fixed << setprecision(10);
cerr << fixed << setprecision(3);
while (solve()) {
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void R(T &xx) {
xx = 0;
char ch = getchar();
bool F = 0;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') F = 1, ch = getchar();
while (ch >= '0' && ch <= '9')
xx = xx + xx + (xx << 3) + ch - 48, ch = getchar();
if (F) xx = -xx;
}
template <class T>
inline void add(int &x, T y) {
for (x += y; x >= 1000000007; x -= 1000000007)
;
}
long long A[200011], B[200011], C[200011], sum[200011], sum2[200011],
dis[200011];
int f[200011][23], dep[200011], sz[200011], n;
vector<pair<int, int> > g[200011];
void dfs(int u, int fa) {
f[u][0] = fa;
sz[u] = 1;
sum[u] = dis[u];
sum2[u] = (long long)dis[u] * dis[u] % 1000000007;
dep[u] = dep[fa] + 1;
for (int i = 0; i < (int)((int)g[u].size()); i++)
if (g[u][i].first != fa) {
int v = g[u][i].first;
dis[v] = (dis[u] + g[u][i].second) % 1000000007;
dfs(v, u);
sz[u] += sz[v];
(sum[u] += sum[v]) %= 1000000007;
(sum2[u] += sum2[v]) %= 1000000007;
}
}
void dfs1(int u, int fa) {
A[u] = 4ll * dis[fa] % 1000000007 * dis[fa] % 1000000007 * (sz[fa] - sz[u]) %
1000000007;
B[u] = 4ll * dis[fa] % 1000000007 * (sz[fa] - sz[u]) % 1000000007;
C[u] = 4ll * dis[fa] % 1000000007 * (sum[fa] - sum[u]) % 1000000007;
(A[u] += A[fa]) %= 1000000007;
(B[u] += B[fa]) %= 1000000007;
(C[u] += C[fa]) %= 1000000007;
for (int i = 0; i < (int)((int)g[u].size()); i++)
if (g[u][i].first != fa) dfs1(g[u][i].first, u);
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int j = 21 - 1; ~j; j--)
if (dep[f[x][j]] >= dep[y]) x = f[x][j];
if (x == y) return x;
for (int j = 21 - 1; ~j; j--)
if (f[x][j] != f[y][j]) x = f[x][j], y = f[y][j];
return f[x][0];
}
long long cal(int x, int y) {
long long ans =
((long long)dis[x] * dis[x] % 1000000007 * sz[y] % 1000000007 + sum2[y] +
2ll * dis[x] * sum[y] % 1000000007) %
1000000007;
int lca = LCA(x, y);
if (lca != y) {
ans += 4ll * dis[lca] * dis[lca] % 1000000007 * sz[y] % 1000000007;
ans -= 4ll * dis[lca] * dis[x] % 1000000007 * sz[y] % 1000000007;
ans -= 4ll * dis[lca] * sum[y] % 1000000007;
} else {
ans += 4ll * dis[x] * dis[x] % 1000000007 * sz[x] % 1000000007;
ans -= 4ll * dis[x] * dis[x] % 1000000007 * sz[x] % 1000000007;
ans -= 4ll * dis[x] * sum[x] % 1000000007;
ans += A[x] - A[y];
ans -= (B[x] - B[y]) * dis[x] % 1000000007;
ans -= C[x] - C[y];
}
return (ans % 1000000007 + 1000000007) % 1000000007;
}
int main() {
int Q, x, y, z;
R(n);
for (int i = 1; i < n; i++)
R(x), R(y), R(z), g[x].push_back(make_pair(y, z)),
g[y].push_back(make_pair(x, z));
dfs(1, 0);
dfs1(1, 0);
for (int j = 1; j < 21; j++)
for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
for (R(Q); Q--;) {
R(x), R(y);
printf("%I64d\n", (2ll * cal(x, y) - cal(x, 1) + 1000000007) % 1000000007);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, LG = 18, Mod = 1e9 + 7;
int n, q, ts, sz[N], st[N], en[N], H[N], P[N][LG];
long long D[N], dp[N], sum[N], dp2[N], sum2[N];
vector<pair<int, long long> > Adj[N];
inline int Fix(long long a) {
a %= Mod;
if (a < 0) a += Mod;
return (a);
}
void DFS(int v, int p) {
P[v][0] = p;
sz[v] = 1;
st[v] = ts++;
for (int i = 1; i < LG; i++) P[v][i] = P[P[v][i - 1]][i - 1];
for (auto &u : Adj[v])
if (u.first != p) {
H[u.first] = H[v] + 1;
D[u.first] = (D[v] + u.second) % Mod;
DFS(u.first, v);
sz[v] += sz[u.first];
sum[v] = Fix(sum[v] + sum[u.first] + sz[u.first] * u.second);
dp[v] += Fix(dp[u.first] + u.second * u.second % Mod * sz[u.first] % Mod);
dp[v] = Fix(dp[v] + sum[u.first] * u.second * 2);
}
en[v] = ts;
}
void DFS2(int v, int p) {
for (auto &u : Adj[v])
if (u.first != p) {
sum2[u.first] = Fix(sum2[v] + sum[v] - sum[u.first] -
u.second * (sz[u.first] * 2 - n));
dp2[u.first] = Fix(dp2[v] + dp[v] - dp[u.first] -
u.second * u.second % Mod * sz[u.first]);
dp2[u.first] += Fix(sum[u.first] * u.second * (-2) % Mod +
u.second * u.second % Mod * (n - sz[u.first]));
dp2[u.first] += Fix(
u.second *
Fix(sum2[v] + sum[v] - sum[u.first] - sz[u.first] * u.second) * 2);
dp2[u.first] = Fix(dp2[u.first]);
DFS2(u.first, v);
}
}
inline int LCA(int v, int u) {
if (H[v] < H[u]) return (LCA(u, v));
for (int i = LG - 1; ~i; i--)
if ((H[v] - H[u]) & (1 << i)) v = P[v][i];
if (v == u) return (v);
for (int i = LG - 1; ~i; i--)
if (P[v][i] != P[u][i]) v = P[v][i], u = P[u][i];
return (P[v][0]);
}
inline int Dist(int v, int u) { return Fix(D[v] + D[u] - D[LCA(u, v)] * 2); }
inline bool Sub(int v, int u) { return (st[u] <= st[v] && en[v] <= en[u]); }
int main() {
scanf("%d", &n);
for (int i = 1, v, u, w; i < n; i++)
scanf("%d%d%d", &v, &u, &w), Adj[v].push_back({u, w}),
Adj[u].push_back({v, w});
DFS(1, 0);
DFS2(1, 0);
scanf("%d", &q);
for (; q; q--) {
int v, u;
scanf("%d%d", &u, &v);
long long tot = 0, d = Dist(u, v);
if (Sub(u, v) && u != v) {
tot = dp2[v] + d * d % Mod * (n - sz[v]);
tot = Fix(tot + sum2[v] * d * 2);
printf("%d\n", Fix(dp[u] + dp2[u] - tot * 2));
} else {
tot = dp[v] + d * d % Mod * sz[v];
tot = Fix(tot + d * sum[v] * 2);
printf("%d\n", Fix(tot * 2 - dp[u] - dp2[u]));
}
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int f, t;
long long int w;
} edge;
vector<edge> e[100514];
int n;
int q[100514], qs, qe;
int inq[100514];
edge* dad[100514];
long long int mod = 1000000007;
long long int ds0[100514];
long long int ds1[100514];
long long int ds2[100514];
long long int us0[100514];
long long int us1[100514];
long long int us2[100514];
int up[20][100514];
int dpt[100514];
long long int dpl[100514];
int flca(int x, int y) {
if (dpt[x] > dpt[y]) return flca(y, x);
for (int j = 19; j >= 0; j--) {
if (dpt[y] - (1 << j) >= dpt[x]) {
y = up[j][y];
}
}
if (x == y) return x;
for (int j = 19; j >= 0; j--) {
if (up[j][x] != up[j][y]) {
x = up[j][x];
y = up[j][y];
}
}
return up[0][x];
}
void sol() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
long long int w;
scanf("%d %d %I64d", &a, &b, &w);
e[a].push_back((edge){a, b, w});
e[b].push_back((edge){b, a, w});
}
qs = qe = 0;
q[qe++] = 1;
inq[1] = 1;
dad[1] = 0;
up[0][1] = 0;
dpt[1] = 1;
dpl[1] = 0;
for (; qs != qe;) {
int w = q[qs++];
for (int i = 0; i < (int)e[w].size(); i++) {
int t = e[w][i].t;
if (inq[t]) continue;
q[qe++] = t;
inq[t] = 1;
dad[t] = &e[w][i];
up[0][t] = w;
dpt[t] = dpt[w] + 1;
dpl[t] = (dpl[w] + e[w][i].w) % mod;
}
}
for (int i = 1; i <= n; i++) inq[i] = 0;
for (int j = qe - 1; j >= 0; j--) {
int w = q[j];
ds0[w] = 1;
ds1[w] = 0;
ds2[w] = 0;
for (int i = 0; i < (int)e[w].size(); i++) {
int t = e[w][i].t;
long long int tw = e[w][i].w;
ds0[w] = (ds0[w] + ds0[t]) % mod;
ds1[w] = (ds1[w] + ds1[t] + ds0[t] * tw) % mod;
ds2[w] =
(ds2[w] + ds2[t] + ds1[t] * tw % mod * 2 + ds0[t] * tw % mod * tw) %
mod;
}
}
us0[1] = 0;
us1[1] = 0;
us2[1] = 0;
for (int j = 1; j < qe; j++) {
int w = q[j];
int d = dad[w]->f;
long long int tw = dad[w]->w;
us0[w] = n - ds0[w];
long long int up1 = ds1[d] + (mod - (ds1[w] + ds0[w] * tw) % mod) + us1[d];
up1 %= mod;
us1[w] = (up1 + us0[w] * tw) % mod;
us1[w] %= mod;
long long int up2 =
ds2[d] +
(mod -
(ds2[w] + ds1[w] * tw % mod * 2 + ds0[w] * tw % mod * tw) % mod) +
us2[d];
up2 %= mod;
us2[w] = (up2 + up1 * tw % mod * 2 + us0[w] * tw % mod * tw) % mod;
}
for (int j = 1; j < 20; j++) {
for (int i = 1; i <= n; i++) {
up[j][i] = up[j - 1][up[j - 1][i]];
}
}
int Q;
scanf("%d", &Q);
for (int s = 0; s < Q; s++) {
int x, y;
scanf("%d %d", &x, &y);
int lca = flca(x, y);
if (lca != y) {
long long int dxy = (dpl[x] + dpl[y] + (mod - dpl[lca]) * 2) % mod;
long long int pa = dxy * dxy % mod * ds0[y] % mod;
pa += 2 * dxy % mod * ds1[y] % mod;
pa += ds2[y] % mod;
pa %= mod;
long long int pb = (ds2[x] + us2[x] + (mod - pa)) % mod;
printf("%I64d\n", (pa + mod - pb) % mod);
} else {
long long int dxy = (dpl[x] + dpl[y] + (mod - dpl[lca]) * 2) % mod;
long long int pa = dxy * dxy % mod * us0[y] % mod;
pa += 2 * dxy % mod * us1[y] % mod;
pa += us2[y];
pa %= mod;
long long int pb = (ds2[x] + us2[x] + (mod - pa)) % mod;
printf("%I64d\n", (pb + mod - pa) % mod);
}
}
}
int main() {
while (1) {
sol();
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long arr[100005];
arr cnt, d, sum, bot, top, T, L;
int P[100005][21];
vector<pair<int, int> > a[100005];
int n;
void DFS1(int u, int pre) {
cnt[u] = 1;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
long long gt = a[u][i].second;
if (v == pre) continue;
d[v] = (d[u] + gt) % 1000000007;
T[v] = T[u] + 1;
DFS1(v, u);
P[v][0] = u;
cnt[u] += cnt[v];
sum[u] = (sum[u] + sum[v] + gt * cnt[v] % 1000000007) % 1000000007;
bot[u] = (bot[u] + bot[v] + (gt * gt % 1000000007 * cnt[v] % 1000000007) +
2ll * sum[v] * gt % 1000000007) %
1000000007;
}
}
void DFS2(int u, int pre) {
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
long long gt = a[u][i].second;
if (v == pre) continue;
L[v] = (L[u] + (sum[u] - sum[v] - gt * cnt[v] % 1000000007) +
gt * (n - cnt[v]) % 1000000007) %
1000000007;
top[v] = (top[u] + 2ll * L[u] * gt % 1000000007 +
gt * gt % 1000000007 * (n - cnt[u]) % 1000000007) %
1000000007;
long long W =
(bot[u] - bot[v] - (gt * gt % 1000000007 * cnt[v] % 1000000007) -
2ll * sum[v] * gt % 1000000007) %
1000000007;
top[v] =
(top[v] + W + gt * gt % 1000000007 * (cnt[u] - cnt[v]) % 1000000007 +
2ll * gt * (sum[u] - sum[v] - gt * cnt[v] % 1000000007) % 1000000007) %
1000000007;
DFS2(v, u);
}
}
void Build_LCA() {
for (int j = 1; j < 20; j++)
for (int i = 1; i <= n; i++) P[i][j] = P[P[i][j - 1]][j - 1];
}
int LCA(int u, int v) {
if (T[u] < T[v]) swap(u, v);
int hi = T[u] - T[v];
for (int i = 0; i < 20; i++)
if (((hi >> i) & 1)) u = P[u][i];
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (P[u][i] != P[v][i]) {
u = P[u][i];
v = P[v][i];
}
return P[u][0];
}
int main() {
cin >> n;
int u, v, gt, q;
for (int i = 1; i <= n - 1; i++) {
cin >> u >> v >> gt;
a[u].push_back(make_pair(v, gt));
a[v].push_back(make_pair(u, gt));
}
DFS1(1, 0);
DFS2(1, 0);
Build_LCA();
cin >> q;
while (q--) {
cin >> u >> v;
int Par = LCA(u, v);
long long R1 = (bot[u] + top[u]) % 1000000007;
long long kc = (d[u] + d[v] - 2ll * d[Par]) % 1000000007;
if (Par == v) {
long long R2 = (top[v] + 2ll * kc * L[v] % 1000000007 +
kc * kc % 1000000007 * (n - cnt[v]) % 1000000007) %
1000000007;
long long R3 = R1 - R2;
cout << (2ll * R3 - R1 + 3ll * 1000000007) % 1000000007 << endl;
} else {
long long R2 = (bot[v] + 2ll * kc * sum[v] % 1000000007 +
kc * kc % 1000000007 * (cnt[v]) % 1000000007) %
1000000007;
cout << (2ll * R2 - R1 + 3ll * 1000000007) % 1000000007 << endl;
}
}
}
|
#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];
long long 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;
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 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 range_minimum_query {
public:
std::vector<T> data;
std::vector<std::vector<int> > block;
std::vector<int> sblock;
std::vector<int> lookup;
int N;
int lg;
int min(int a, int b) { return data[b] < data[a] ? b : a; }
range_minimum_query() {}
range_minimum_query(std::vector<T> &t) {
data = t;
N = data.size();
lg = 32 - __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; i < (1 << lg); i++) {
if (1 << (lg - ans) <= i) ans--;
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;
range_minimum_query<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 = range_minimum_query<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;
int topstend[100000], topnode[100000], toppos, level[100000], dist[100000],
parent[100000][20];
int n, topind[100000], q, a, b, c;
int distsum[100000], distsqsum[100000], nchildren[100000];
int pdistsum[100000][20], pdistsqsum[100000][20], pnchildren[100000][20];
vector<pair<int, int> > conn[100000];
int m(long long val) { return (val % 1000000007 + 1000000007) % 1000000007; }
int pathlen(int a, int b) { return m(dist[b] - dist[a]); }
void topdfs(int pos, int lev, int curdist, int curparent) {
int curtoppos = toppos;
level[pos] = lev;
dist[pos] = curdist;
parent[pos][0] = curparent;
topnode[curtoppos] = pos;
topind[pos] = curtoppos;
toppos++;
for (int i = 0; i < conn[pos].size(); i++)
if (conn[pos][i].first != parent[pos][0])
topdfs(conn[pos][i].first, lev + 1, m(curdist + conn[pos][i].second),
pos);
topstend[curtoppos] = toppos;
}
void calcdfs(int pos) {
nchildren[pos] = 1;
for (int i = 0; i < conn[pos].size(); i++)
if (conn[pos][i].first != parent[pos][0]) {
int child = conn[pos][i].first;
calcdfs(child);
nchildren[pos] += nchildren[child];
distsum[pos] = m(distsum[pos] + distsum[child] +
1LL * nchildren[child] * conn[pos][i].second);
distsqsum[pos] =
m(distsqsum[pos] + distsqsum[child] +
2LL * distsum[child] * conn[pos][i].second +
1LL * m(1LL * conn[pos][i].second * conn[pos][i].second) *
nchildren[child]);
pnchildren[child][0] = m(-nchildren[child]);
pdistsum[child][0] =
m(-distsum[child] - 1LL * nchildren[child] * conn[pos][i].second);
pdistsqsum[child][0] =
m(-distsqsum[child] - 2LL * distsum[child] * conn[pos][i].second -
1LL * m(1LL * conn[pos][i].second * conn[pos][i].second) *
nchildren[child]);
}
for (int i = 0; i < conn[pos].size(); i++)
if (conn[pos][i].first != parent[pos][0]) {
int child = conn[pos][i].first;
pnchildren[child][0] = m(pnchildren[child][0] + nchildren[pos]);
pdistsum[child][0] = m(pdistsum[child][0] + distsum[pos]);
pdistsqsum[child][0] = m(pdistsqsum[child][0] + distsqsum[pos]);
pdistsqsum[child][0] =
m(pdistsqsum[child][0] +
2LL * conn[pos][i].second * pdistsum[child][0] +
1LL * m(1LL * conn[pos][i].second * conn[pos][i].second) *
pnchildren[child][0]);
pdistsum[child][0] = m(pdistsum[child][0] +
1LL * pnchildren[child][0] * conn[pos][i].second);
}
}
bool instree(int a, int b) {
return topind[a] <= topind[b] && topind[b] < topstend[topind[a]];
}
int getanc(int a, int b) {
if (instree(a, b)) return a;
for (int i = 19; i >= 0; i--)
if (parent[a][i] != -1 && !instree(parent[a][i], b)) a = parent[a][i];
return parent[a][0];
}
int getdistsum;
int getsumto(int pos, int anc) {
int ret = 0, rdistsum = 0, cdist = 0;
for (int i = 19; i >= 0; i--)
if (parent[pos][i] != -1 &&
(parent[pos][i] == anc || !instree(parent[pos][i], anc))) {
rdistsum =
m(rdistsum + pdistsum[pos][i] + 1LL * pnchildren[pos][i] * cdist);
ret = m(ret + pdistsqsum[pos][i] + 2LL * pdistsum[pos][i] * cdist +
1LL * m(1LL * cdist * cdist) * pnchildren[pos][i]);
cdist = m(cdist + pathlen(parent[pos][i], pos));
pos = parent[pos][i];
}
getdistsum = rdistsum;
return ret;
}
int main() {
cin.sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b >> c;
a--, b--;
conn[a].push_back(make_pair(b, c));
conn[b].push_back(make_pair(a, c));
}
topdfs(0, 0, 0, -1);
calcdfs(0);
for (int j = 1; j < 20; j++)
for (int i = 0; i < n; i++) {
if (parent[i][j - 1] != -1) {
int par = parent[i][j - 1];
parent[i][j] = parent[par][j - 1];
pnchildren[i][j] = pnchildren[i][j - 1] + pnchildren[par][j - 1];
pdistsum[i][j] = m(pdistsum[i][j - 1] + pdistsum[par][j - 1] +
1LL * pnchildren[par][j - 1] * pathlen(par, i));
pdistsqsum[i][j] = m(pdistsqsum[i][j - 1] + pdistsqsum[par][j - 1] +
2LL * pdistsum[par][j - 1] * pathlen(par, i) +
1LL * m(1LL * pathlen(par, i) * pathlen(par, i)) *
pnchildren[par][j - 1]);
} else
parent[i][j] = -1;
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> a >> b, a--, b--;
int res = 0;
if (instree(b, a)) {
res = distsqsum[a];
res = m(res + getsumto(a, b));
int bsqsum = getsumto(b, 0), cdist = pathlen(b, a);
res = m(res - bsqsum - 2LL * getdistsum * cdist -
1LL * m(1LL * cdist * cdist) * m(nchildren[0] - nchildren[b]));
} else {
res = m(-distsqsum[a] - getsumto(a, 0));
int canc = getanc(a, b), cdist = m(pathlen(canc, a) + pathlen(canc, b));
res = m(res + 2LL * m(distsqsum[b] + 2LL * cdist * distsum[b] +
1LL * m(1LL * cdist * cdist) * nchildren[b]));
}
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct node {
long long s, ms, lazy;
} t[300000];
const int cys = 1000000007;
int n, m, tot, cnt;
int v[200005], nxt[200005], c[200005], h[100005], rnk[100005], dfn[100005],
siz[100005], ans[100005], dep[100005];
vector<pair<int, int> > q[100005];
int mod(int x) { return x >= cys ? x - cys : x; }
void addedge(int x, int y, int z) {
v[++tot] = y;
c[tot] = z;
nxt[tot] = h[x];
h[x] = tot;
v[++tot] = x;
c[tot] = z;
nxt[tot] = h[y];
h[y] = tot;
}
void update(int id) {
t[id].s = mod(t[id << 1].s + t[id << 1 | 1].s);
t[id].ms = mod(t[id << 1].ms + t[id << 1 | 1].ms);
}
void build(int id, int l, int r) {
if (l == r) {
t[id].s = dep[rnk[l]], t[id].ms = 1ll * dep[rnk[l]] * dep[rnk[l]] % cys;
return;
}
int mid = (l + r) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
update(id);
}
void pushdown(int id, int l, int r) {
if (t[id].lazy) {
int mid = (l + r) / 2;
t[id << 1].lazy = mod(t[id << 1].lazy + t[id].lazy),
t[id << 1 | 1].lazy = mod(t[id << 1 | 1].lazy + t[id].lazy);
t[id << 1].ms = mod(mod(t[id << 1].ms + 1ll * (mid - l + 1) * t[id].lazy %
cys * t[id].lazy % cys) +
2ll * t[id].lazy * t[id << 1].s % cys);
t[id << 1 | 1].ms =
mod(mod(t[id << 1 | 1].ms +
1ll * (r - mid) * t[id].lazy % cys * t[id].lazy % cys) +
2ll * t[id].lazy * t[id << 1 | 1].s % cys);
t[id << 1].s = mod(t[id << 1].s + 1ll * t[id].lazy * (mid - l + 1) % cys),
t[id << 1 | 1].s =
mod(t[id << 1 | 1].s + 1ll * t[id].lazy * (r - mid) % cys);
t[id].lazy = 0;
}
}
void change(int id, int l, int r, int ql, int qr, int c) {
if (l == ql && r == qr) {
t[id].lazy = mod(t[id].lazy + c);
t[id].ms = mod(mod(t[id].ms + 1ll * (r - l + 1) * c % cys * c % cys) +
2ll * c * t[id].s % cys);
t[id].s = mod(t[id].s + 1ll * c * (r - l + 1) % cys);
return;
}
pushdown(id, l, r);
int mid = (l + r) / 2;
if (qr <= mid)
change(id << 1, l, mid, ql, qr, c);
else if (ql > mid)
change(id << 1 | 1, mid + 1, r, ql, qr, c);
else
change(id << 1, l, mid, ql, mid, c),
change(id << 1 | 1, mid + 1, r, mid + 1, qr, c);
update(id);
}
int query(int id, int l, int r, int ql, int qr) {
if (l == ql && r == qr) return t[id].ms;
pushdown(id, l, r);
int mid = (l + r) / 2;
if (qr <= mid)
return query(id << 1, l, mid, ql, qr);
else if (ql > mid)
return query(id << 1 | 1, mid + 1, r, ql, qr);
else
return mod(query(id << 1, l, mid, ql, mid) +
query(id << 1 | 1, mid + 1, r, mid + 1, qr));
}
void dfs1(int u, int fa) {
dfn[u] = ++cnt, rnk[cnt] = u, siz[u] = 1;
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == fa) continue;
dep[v[p]] = mod(dep[u] + c[p]);
dfs1(v[p], u);
siz[u] += siz[v[p]];
}
}
void dfs2(int u, int fa) {
for (int i = 0; i < q[u].size(); i++)
ans[q[u][i].second] =
mod(mod(2 * query(1, 1, n, dfn[q[u][i].first],
dfn[q[u][i].first] + siz[q[u][i].first] - 1)) +
cys - t[1].ms);
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == fa) continue;
change(1, 1, n, 1, n, c[p]);
change(1, 1, n, dfn[v[p]], dfn[v[p]] + siz[v[p]] - 1,
mod(2 * (cys - c[p])));
dfs2(v[p], u);
change(1, 1, n, 1, n, cys - c[p]);
change(1, 1, n, dfn[v[p]], dfn[v[p]] + siz[v[p]] - 1, mod(2 * c[p]));
}
}
int main() {
n = readint();
int x, y, z;
for (int i = 1; i <= n - 1; i++) {
x = readint();
y = readint();
z = readint();
addedge(x, y, z);
}
dfs1(1, -1);
build(1, 1, n);
m = readint();
for (int i = 1; i <= m; i++) {
x = readint();
y = readint();
q[x].push_back(make_pair(y, i));
}
dfs2(1, -1);
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
int c, l = 0, x;
for (; !isdigit(c = getchar()); l = c)
if (c == EOF) return 1 << 31;
for (x = c - '0'; isdigit(c = getchar()); x = x * 10 + c - '0')
if (c == EOF) break;
return l == '-' ? -x : x;
}
int buf[100];
inline int putint(int x) {
int i = 0;
x = x < 0 ? putchar('-'), -x : x;
for (; buf[i++] = x % 10, x; x /= 10)
;
for (i = i - 1 ? i - 1 : 1; i--; putchar(buf[i] + '0'))
;
putchar(10);
return 1;
}
const int N = 200100;
const int mod = 1000000007;
int K, n, m, q, tp[N], sz[N], hc[N], fa[N], clk, ne[N * 2], to[N * 2],
da[N * 2], G[N], xb;
long long dp[N], dg[N];
struct poly {
int a[4];
poly() { memset(a, 0, sizeof a); }
poly operator+(const poly& b) {
poly c;
for (int i = 0; i <= K; i++) c.a[i] = (a[i] + b.a[i]) % mod;
return c;
}
poly operator-(const poly& b) {
poly c;
for (int i = 0; i <= K; i++) c.a[i] = (a[i] - b.a[i] + mod) % mod;
return c;
}
poly operator<<(const long long& tt) {
long long t = (tt % mod + mod) % mod;
poly c;
for (int i = K; i >= 0; i--) {
for (int j = K; j; j--) c.a[j] = (t * c.a[j] + c.a[j - 1]) % mod;
c.a[0] = (t * c.a[0] + a[i]) % mod;
}
return c;
}
int operator()(const long long& x) {
long long ans = 0, s = x % mod;
for (int i = K; i >= 0; i--) ans = (ans * s + a[i]) % mod;
return ans;
}
} g[N], f[N];
void add(int x, int y, long long z) {
ne[xb] = G[x];
to[xb] = y;
da[xb] = z;
G[x] = xb++;
}
int lca(int x, int y) {
for (; tp[x] != tp[y]; x = fa[tp[x]])
if (dp[tp[x]] < dp[tp[y]]) swap(x, y);
return dp[x] < dp[y] ? x : y;
}
int dfn[N], dft[N];
bool is(int x, int y) { return dfn[x] <= dfn[y] && dfn[y] <= dft[x]; }
long long dst(int x, int y) {
int z = lca(x, y);
return dp[x] + dp[y] - 2 * dp[z];
}
void dfs2(int x) {
f[x].a[K] = 1;
for (int i = G[x]; ~i; i = ne[i])
if (to[i] != fa[x]) {
int u = to[i], v = da[i];
dp[u] = dp[x] + v;
fa[u] = x;
dfs2(u);
f[x] = f[x] + (f[u] << v);
sz[x] += sz[u];
if (sz[u] > sz[hc[x]]) hc[x] = u;
}
if (!sz[x]) sz[x] = 1;
}
void dfs3(int x, int y) {
for (int i = G[x]; ~i; i = ne[i])
if (to[i] != fa[x]) {
int u = to[i];
g[u] = (f[x] << -dp[x]) - (f[u] << dp[u] - 2 * dp[x]) + g[x];
}
dfn[x] = ++clk;
tp[x] = y;
if (hc[x]) dfs3(hc[x], y);
for (int i = G[x]; ~i; i = ne[i])
if (!dfn[to[i]]) dfs3(to[i], to[i]);
dft[x] = clk;
}
int calc(int u, int v) {
if (is(u, v)) {
poly a = g[v] - g[u];
return (f[v](0) + a(dp[v])) % mod;
} else {
poly a = f[u];
return a(dst(v, u));
}
}
int main() {
n = getint();
K = 2;
m = n - 1;
memset(G, -1, sizeof G);
for (int i = 1; i <= m; i++) {
int x = getint(), y = getint(), z = getint();
add(x, y, z);
add(y, x, z);
}
dfs2(1);
dfs3(1, 1);
q = getint();
while (q--) {
int u, v;
v = getint();
u = getint();
putint(((2 * calc(u, v) - calc(1, v)) % mod + mod) % mod);
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
vector<pair<int, int> > edge[200000];
struct INFO {
long long depth;
long long dis;
long long child;
long long down1, down2, up1, up2;
} d[200000];
int par[200000][20];
long long mod(long long x) {
return (x % 1000000007 + 1000000007) % 1000000007;
}
void back(int now, int parent) {
long long ccnt = 0, cnt1 = 0, cnt2 = 0;
par[now][0] = parent == -1 ? now : parent;
for (int i = 1; i < 20; i++) {
par[now][i] = par[par[now][i - 1]][i - 1];
}
for (auto e : edge[now]) {
if (e.first == parent) continue;
d[e.first].depth = d[now].depth + 1;
d[e.first].dis = d[now].dis + e.second;
d[e.first].dis %= 1000000007;
back(e.first, now);
ccnt += d[e.first].child;
ccnt %= 1000000007;
cnt1 += d[e.first].down1 + d[e.first].child * e.second;
cnt1 %= 1000000007;
cnt2 += d[e.first].down2 + 2 * d[e.first].down1 * e.second;
cnt2 %= 1000000007;
cnt2 += d[e.first].child * e.second % 1000000007 * e.second;
cnt2 %= 1000000007;
}
d[now].child = ccnt + 1;
d[now].down1 = cnt1;
d[now].down2 = cnt2;
}
void upback(int now, int parent, int dis) {
if (parent != -1) {
long long u = d[parent].up1 + d[parent].down1 -
(d[now].down1 + d[now].child * dis % 1000000007);
d[now].up1 = u + dis * (n - d[now].child);
d[now].up1 %= 1000000007;
u = d[parent].up2 + d[parent].down2 -
(d[now].down2 + 2 * d[now].down1 * dis % 1000000007 +
d[now].child * dis % 1000000007 * dis % 1000000007);
d[now].up2 = u +
2 * (d[now].up1 - dis * (n - d[now].child) % 1000000007) *
dis % 1000000007 +
(n - d[now].child) * dis % 1000000007 * dis % 1000000007;
d[now].up2 %= 1000000007;
}
for (auto e : edge[now]) {
if (e.first == parent) continue;
upback(e.first, now, e.second);
}
}
int getlca(int x, int y) {
if (d[x].depth < d[y].depth) swap(x, y);
int dis = d[x].depth - d[y].depth;
int i, j;
for (i = 0; i < 20; i++) {
if (dis & (1 << i)) x = par[x][i];
}
if (x == y) return x;
for (i = 19; i >= 0; i--) {
if (par[x][i] != par[y][i]) x = par[x][i], y = par[y][i];
}
return par[x][0];
}
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z), x--, y--;
edge[x].push_back(pair<int, int>(y, z));
edge[y].push_back(pair<int, int>(x, z));
}
back(0, -1);
upback(0, -1, 0);
scanf("%d", &m);
for (i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y), x--, y--;
int lca = getlca(x, y);
if (lca == y) {
long long dis = d[x].dis - d[y].dis;
long long u = d[y].up2 + 2 * dis * d[y].up1 % 1000000007 +
(n - d[y].child) * dis % 1000000007 * dis % 1000000007;
long long dab = d[x].up2 + d[x].down2 - 2 * u;
printf("%I64d\n", mod(dab));
} else {
long long dis = d[x].dis + d[y].dis - 2 * d[lca].dis;
long long u = d[y].down2 + 2 * dis * d[y].down1 % 1000000007 +
d[y].child * dis % 1000000007 * dis % 1000000007;
long long dab = 2 * u - d[x].down2 - d[x].up2;
printf("%I64d\n", mod(dab));
}
}
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 long long N = 100100, MOD = 1000 * 1000 * 1000 + 7;
long long n, q;
vector<pair<long long, long long> > adl[N];
long long ks[N], ks2[N], as[N], as2[N], ted[N], anc[N][20], len[N], hei[N];
bool chk[N];
void dfs(long long v) {
chk[v] = 1;
ted[v] = 1;
for (long long i = 0, u, w; i < adl[v].size(); ++i) {
u = adl[v][i].first;
w = adl[v][i].second;
if (!chk[u]) {
dfs(u);
ted[v] += ted[u];
ks[v] += ks[u];
ks[v] %= MOD;
ks[v] += w * ted[u];
ks[v] %= MOD;
long long w2 = w * w;
w2 %= MOD;
long long res = (w * ks[u]) % MOD;
ks2[v] += 2 * res;
ks2[v] %= MOD;
ks2[v] += ks2[u] + w2 * ted[u];
ks2[v] %= MOD;
}
}
}
void dfs(long long v, long long dad, long long wei) {
chk[v] = 1;
anc[v][0] = dad;
len[v] = len[dad] + wei;
len[v] %= MOD;
hei[v] = hei[dad] + 1;
if (!dad) {
as[v] = ks[v];
as2[v] = ks2[v];
} else {
long long other = n - ted[v];
long long dis = other - ted[v];
while (dis < 0) dis += MOD;
as[v] = as[dad] + wei * (dis);
as[v] %= MOD;
long long sdis = as[dad] - 2 * ks[v] - ted[v] * wei;
if (sdis < 0) sdis += wei * MOD;
while (sdis < 0) sdis += MOD;
sdis %= MOD;
long long w2 = wei * wei;
w2 %= MOD;
as2[v] = as2[dad] + w2 * dis;
as2[v] %= MOD;
long long res = (wei * sdis) % MOD;
as2[v] += res * 2;
as2[v] %= MOD;
}
for (long long i = 0, u, w; i < adl[v].size(); ++i) {
u = adl[v][i].first;
w = adl[v][i].second;
if (!chk[u]) dfs(u, v, w);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 1, x, y, w; i < n; ++i) {
cin >> x >> y >> w;
adl[x].push_back(pair<long long, long long>(y, w));
adl[y].push_back(pair<long long, long long>(x, w));
}
dfs(1);
memset(chk, 0, sizeof chk);
dfs(1, 0, 0);
for (long long i = 1; i < 20; ++i)
for (long long j = 1; j <= n; ++j) anc[j][i] = anc[anc[j][i - 1]][i - 1];
cin >> q;
for (long long i = 1, x, y; i <= q; ++i) {
cin >> x >> y;
long long lca, ans = 0, cx = x, cy = y;
if (hei[x] < hei[y]) swap(x, y);
long long dis = hei[x] - hei[y];
for (long long j = 19; j >= 0; --j)
if (dis & (1 << j)) x = anc[x][j];
if (x == y) {
lca = x;
if (hei[cx] >= hei[cy]) {
long long fas = len[cx] + len[cy] - 2 * len[lca];
fas %= MOD;
long long fas2 = fas * fas;
fas2 %= MOD;
long long res = ((fas * (as[cy] - ks[cy])) % MOD);
ans =
as2[cx] - 2 * (as2[cy] - ks2[cy] + fas2 * (n - ted[cy]) + 2 * res);
if (ans < 0) ans += N * MOD;
while (ans < 0) ans += MOD;
ans %= MOD;
cout << ans << "\n";
continue;
}
} else {
for (long long j = 19; j >= 0; --j)
if (anc[x][j] != anc[y][j]) {
x = anc[x][j];
y = anc[y][j];
}
lca = anc[x][0];
}
long long fas = len[cx] + len[cy] - 2 * len[lca];
fas %= MOD;
long long fas2 = fas * fas;
fas2 %= MOD;
ans = ks2[cy] + fas2 * ted[cy];
ans %= MOD;
long long res = (fas * ks[cy]) % MOD;
ans += res * 2;
ans %= MOD;
ans = ans - (as2[cx] - ans);
if (ans < 0) ans += N * MOD;
while (ans < 0) ans += MOD;
ans %= MOD;
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (a && b) {
if (a >= b)
a %= b;
else
b %= a;
}
return a + b;
}
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int getint() {
char c;
int ret = c - '0', sgn = 0;
while ((c = getchar()) && !(c >= '0' && c <= '9') && c != '-')
;
if (c == '-') sgn = 1, ret = 0;
while ((c = getchar()) && c >= '0' && c <= '9') ret = ret * 10 + c - '0';
if (sgn) ret = -ret;
return ret;
}
const int maxn = 1e5 + 10;
const int maxm = maxn * 2;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
int sz[maxn];
long long cost[maxn];
long long f[maxn], ft[maxn], f2[maxn], f1[maxn];
vector<pair<int, int> > g[maxn];
long long get(long long x, long long y) {
x %= mod, y %= mod;
x = ((x - y) % mod + mod) % mod;
return x;
}
void add(long long& x, long long y) {
x %= mod, y %= mod;
x = (x + y) % mod;
}
void dfs1(int u, int pa) {
int len = g[u].size();
sz[u] = 1;
for (int i = 0; i < len; i++) {
int v = g[u][i].first;
long long w = g[u][i].second;
if (v == pa) continue;
cost[v] = w;
dfs1(v, u);
sz[u] += sz[v];
ft[u] += (ft[v] + w * sz[v] % mod) % mod;
ft[u] %= mod;
if (ft[u] < 0) ft[u] += mod;
f[u] +=
((f[v] + w * w % mod * sz[v] % mod) % mod + w * 2 % mod * ft[v] % mod) %
mod;
f[u] %= mod;
}
}
int n;
void dfs2(int u, int pa) {
int len = g[u].size();
for (int i = 0; i < len; i++) {
int v = g[u][i].first;
long long w = g[u][i].second;
if (v == pa) continue;
long long temp = get(ft[u], sz[v] * w % mod) + (n - sz[v]) * w % mod;
temp %= mod;
long long temp2 = get(temp, ft[v]);
temp2 = get(temp2, (n - sz[v]) * w % mod);
f1[v] = temp2;
long long temp3 = f[v];
f[v] = ((f[u] - 1LL * sz[v] * w % mod * w % mod) % mod -
1LL * 2 * w % mod * ft[v] % mod) %
mod;
f[v] = (f[v] + mod) % mod;
f2[v] = get(f[v], temp3);
f[v] = (f[v] + 1LL * (n - sz[v]) * w % mod * w % mod +
2LL * w % mod * temp2 % mod) %
mod;
ft[v] = temp;
dfs2(v, u);
}
}
int deep[maxn], fa[25][maxn];
long long ds[maxn], sumdis[maxn], sumq[maxn];
void dfs(int u, int pa, int d) {
deep[u] = d;
fa[0][u] = pa;
int i;
int len = g[u].size();
sumdis[u] = ds[u], sumq[u] = ds[u] * ds[u] % mod;
for (int i = 0; i < len; i++) {
int v = g[u][i].first, w = g[u][i].second;
if (v == pa) continue;
ds[v] = ds[u] + w;
ds[v] %= mod;
dfs(v, u, d + 1);
add(sumdis[u], sumdis[v]);
add(sumq[u], sumq[v]);
}
}
void lca_init() {
for (int k = 0; k < 20; k++) {
for (int i = 1; i <= n; i++) {
if (fa[k][i] == -1)
fa[k + 1][i] = -1;
else
fa[k + 1][i] = fa[k][fa[k][i]];
}
}
}
int lca(int u, int v) {
if (deep[u] > deep[v]) swap(u, v);
for (int k = 0; k < 22; k++) {
if ((deep[v] - deep[u]) >> k & 1) {
v = fa[k][v];
}
}
if (u == v) return u;
for (int k = 21; k >= 0; k--) {
if (fa[k][u] != fa[k][v]) {
u = fa[k][u], v = fa[k][v];
}
}
return fa[0][v];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i < n; 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));
}
memset(f, 0, sizeof(f));
f1[1] = f2[1] = 0;
dfs1(1, -1);
dfs2(1, -1);
ds[1] = sumdis[1] = sumq[1] = 0;
dfs(1, -1, 1);
lca_init();
int q;
cin >> q;
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
int la = lca(u, v);
long long ans = 0;
if (la != v) {
long long cnt = sz[v] - 1;
long long x = get(ds[u] + ds[v], 2 * ds[la]), y = x;
x = get(x, ds[v]);
long long temp =
(cnt * x % mod * x % mod + get(sumq[v], ds[v] * ds[v] % mod)) % mod +
2 * x % mod * get(sumdis[v], ds[v]) % mod;
temp %= mod;
add(temp, y * y % mod);
ans = temp;
} else {
long long cnt = n - sz[v];
long long x = get(ds[u], ds[v]);
long long ww = (x + cost[v]) % mod;
long long temp = (f2[v] + cnt * ww % mod * ww % mod) % mod +
ww * 2 % mod * f1[v] % mod;
temp = temp % mod;
ans = get(f[u], temp);
}
ans = get(ans, get(f[u], ans));
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 3e5 + 10;
vector<int> e[SIZE], ev[SIZE];
int jump[20][SIZE], lv[SIZE], n;
long long dis[SIZE];
void init(int x, int lt) {
jump[0][x] = lt;
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i];
if (y != lt) {
dis[y] = dis[x] + ev[x][i];
lv[y] = lv[x] + 1;
init(y, x);
}
}
}
int adv(int x, int v) {
for (int i = 0; (1 << i) <= v; i++) {
if ((v >> i) & 1) x = jump[i][x];
}
return x;
}
int lca(int x, int y) {
if (lv[x] > lv[y])
x = adv(x, lv[x] - lv[y]);
else
y = adv(y, lv[y] - lv[x]);
if (x == y) return x;
for (int i = 19; i >= 0; i--)
if (jump[i][x] != jump[i][y]) {
x = jump[i][x];
y = jump[i][y];
}
return jump[0][x];
}
void build() {
init(1, 1);
for (int i = (1); i < (20); ++i) {
for (int x = (1); x < (n + 1); ++x)
jump[i][x] = jump[i - 1][jump[i - 1][x]];
}
}
int num[SIZE], sum[SIZE], sum2[SIZE], all_sum[SIZE], all_sum2[SIZE];
void add(int &x, long long v) { x = (x + v) % MOD; }
void dfs0(int x, int lt) {
num[x] = 1;
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i];
if (y == lt) continue;
dfs0(y, x);
num[x] += num[y];
sum[x] = (sum[x] + sum[y] + (long long)num[y] * ev[x][i]) % MOD;
sum2[x] = (sum2[x] + sum2[y] + (long long)sum[y] * 2 * ev[x][i] +
(long long)ev[x][i] * ev[x][i] % MOD * num[y]) %
MOD;
}
}
void dfs1(int x, int lt, long long v1, long long v2) {
v1 %= MOD;
v2 %= MOD;
if (v1 < 0) v1 += MOD;
if (v2 < 0) v2 += MOD;
all_sum[x] = sum[x];
all_sum2[x] = sum2[x];
add(all_sum[x], v1);
add(all_sum2[x], v2);
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i];
if (y == lt) continue;
dfs1(y, x,
v1 + (long long)(n - num[y]) * ev[x][i] % MOD + sum[x] - sum[y] -
(long long)num[y] * ev[x][i] % MOD,
all_sum2[x] - sum2[y] - sum[y] * 2LL * ev[x][i] % MOD -
(long long)ev[x][i] * ev[x][i] % MOD * num[y] +
(long long)(n - num[y]) * ev[x][i] % MOD * ev[x][i] % MOD +
2LL * ev[x][i] *
(v1 + sum[x] - sum[y] - (long long)num[y] * ev[x][i] % MOD) %
MOD);
}
}
int main() {
scanf("%d", &(n));
for (int i = (1); i < (n); ++i) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
e[x].push_back(y);
ev[x].push_back(v);
e[y].push_back(x);
ev[y].push_back(v);
}
build();
dfs0(1, 1);
dfs1(1, 1, 0, 0);
int(Q);
scanf("%d", &Q);
while (Q--) {
int u, v;
scanf("%d%d", &u, &v);
int me = lca(u, v);
int an = 0;
long long dd = dis[u] + dis[v] - 2 * dis[me];
dd %= MOD;
if (me != v) {
an = -all_sum2[u] % MOD;
add(an,
(sum2[v] + dd * dd % MOD * num[v] % MOD + dd * 2LL * sum[v] % MOD) *
2);
} else {
an = all_sum2[u];
add(an, (all_sum2[v] - sum2[v] + dd * dd % MOD * (n - num[v]) % MOD +
dd * 2LL * (all_sum[v] - sum[v]) % MOD) *
-2);
}
if (an < 0) an += MOD;
printf("%d\n", an);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const int N = 1e5 + 10;
const int M = 1e3 + 10;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
inline long long ab(long long x) { return x < 0 ? -x : x; }
inline long long mm(long long x) {
return x >= mod ? x - mod : x < 0 ? x + mod : x;
}
vector<pair<int, long long> > son[N];
struct Node {
long long sum1 = 0, sum2 = 0, cnt = 0, deep = 0, len = 0;
long long psum1 = 0, psum2 = 0, pcnt = 0;
int fa[20];
} node[N];
void dfs(int o, int fa) {
node[o].deep = node[fa].deep + 1, node[o].cnt = 1;
node[o].fa[0] = fa;
for (int i = 1; i < 20; ++i)
node[o].fa[i] = node[node[o].fa[i - 1]].fa[i - 1];
for (auto it : son[o]) {
if (it.first != fa) {
node[it.first].len = node[o].len + it.second;
dfs(it.first, o);
node[o].sum1 = (node[it.first].sum1 + node[o].sum1 +
node[it.first].cnt * it.second) %
mod;
node[o].cnt += node[it.first].cnt;
node[o].sum2 =
(node[o].sum2 + node[it.first].cnt * it.second % mod * it.second +
node[it.first].sum2 + 2 * node[it.first].sum1 * it.second) %
mod;
}
}
}
void bfs(int o, int fa) {
long long sum1, cnt, sum2;
for (auto it : son[o]) {
if (it.first != fa) {
sum1 = mm((node[o].sum1 - node[it.first].sum1 -
node[it.first].cnt * it.second + node[o].psum1) %
mod +
mod);
cnt = node[o].cnt - node[it.first].cnt + node[o].pcnt;
sum2 = mm((node[o].psum2 + node[o].sum2 -
node[it.first].cnt * it.second % mod * it.second -
node[it.first].sum2 - 2 * node[it.first].sum1 * it.second) %
mod +
mod);
node[it.first].psum1 = (sum1 + cnt * it.second) % mod;
node[it.first].pcnt = cnt;
node[it.first].psum2 = (cnt * it.second % mod * it.second % mod + sum2 +
2 * sum1 * it.second % mod) %
mod;
bfs(it.first, o);
}
}
}
int get_lca(int u, int v) {
if (node[u].deep < node[v].deep) swap(u, v);
int dd = node[u].deep - node[v].deep;
for (int i = 19; i >= 0; --i)
if ((dd >> i) & 1) u = node[u].fa[i];
if (u == v) return u;
for (int i = 19; i >= 0; --i)
if (node[u].fa[i] != node[v].fa[i]) u = node[u].fa[i], v = node[v].fa[i];
return node[u].fa[0];
}
void solve(int u, int v) {
int w = get_lca(u, v);
if (w != v) {
long long dd = (node[u].len + node[v].len - 2 * node[w].len) % mod;
long long res = (node[v].cnt * dd % mod * dd % mod + node[v].sum2 +
2 * node[v].sum1 * dd % mod) %
mod;
long long all = mm(node[u].psum2 + node[u].sum2);
printf("%I64d\n", mm((res * 2 - all) % mod + mod));
} else {
long long dd = (node[u].len - node[v].len) % mod;
long long res =
mm((node[u].sum2 + node[u].psum2 - node[v].pcnt * 1ll * dd % mod * dd -
node[v].psum2 - 2 * node[v].psum1 * dd) %
mod +
mod);
long long all = mm(node[u].psum2 + node[u].sum2);
printf("%I64d\n", mm((res * 2 - all) % mod + mod));
}
}
int main() {
int n, u, v, w, q;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d%I64d", &u, &v, &w);
son[u].push_back({v, w});
son[v].push_back({u, w});
}
dfs(1, 0);
bfs(1, 0);
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &u, &v);
solve(u, v);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int mod = 1000000000 + 7;
const int maxn = 100000 + 100;
const int maxlg = 17 + 1;
int n, q;
vector<pair<int, int> > adj[maxn];
int par[maxlg][maxn];
int dep[maxn], dis[maxn];
int dw0[maxn], dw1[maxn], dw2[maxn];
int up0[maxn], up1[maxn], up2[maxn];
inline int fix(int x) {
while (x < 0) x += mod;
if (x >= mod) x -= mod;
return x;
}
inline void addto(int &x, int y) {
x += y;
while (x < 0) x += mod;
if (x >= mod) x -= mod;
}
void dfs(int u, int parent = 0, int depth = 0, int dist = 0) {
dep[u] = depth;
dis[u] = dist;
par[0][u] = parent;
for (int l = (int)(1), _n = (int)(maxlg); l < _n; l++)
par[l][u] = par[l - 1][par[l - 1][u]];
dw0[u] = 1;
for (int i = 0, _n = (int)((int((adj[u]).size()))); i < _n; i++)
if (adj[u][i].first != parent) {
int v = adj[u][i].first, w = adj[u][i].second;
dfs(adj[u][i].first, u, depth + 1, fix(dist + w));
dw0[u] += dw0[v];
addto(dw1[u], (dw1[v] + w * (long long)dw0[v]) % mod);
addto(dw2[u], (dw2[v] + 2 * (long long)w * dw1[v] +
w * (long long)w % mod * dw0[v]) %
mod);
}
}
void dfs_up(int u, int parent = 0, int parw = 0) {
if (u != 0) {
up0[u] = n - dw0[u];
up1[u] = fix((up1[parent] + dw1[parent] + parw * (long long)n - dw1[u] -
2 * (long long)parw * dw0[u]) %
mod);
up2[u] = fix((up2[parent] + dw2[parent] +
2 * (long long)parw * (up1[parent] + dw1[parent]) +
parw * (long long)parw % mod * n) %
mod);
addto(up2[u], -(dw2[u] + 2 * (long long)2 * parw * dw1[u] +
4 * (long long)parw * parw % mod * dw0[u]) %
mod);
}
for (int i = 0, _n = (int)((int((adj[u]).size()))); i < _n; i++)
if (adj[u][i].first != parent) {
int v = adj[u][i].first, w = adj[u][i].second;
dfs_up(v, u, w);
}
}
int lca(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
for (int l = (int)(maxlg), _x = (int)(0); l-- > _x;)
if (dep[par[l][v]] >= dep[u]) v = par[l][v];
if (u == v) return u;
for (int l = (int)(maxlg), _x = (int)(0); l-- > _x;)
if (par[l][u] != par[l][v]) u = par[l][u], v = par[l][v];
return par[0][u];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int z = 0, _n = (int)(n - 1); z < _n; z++) {
int u, v, c;
cin >> u >> v >> c;
u--, v--;
adj[u].push_back(pair<int, int>(v, c));
adj[v].push_back(pair<int, int>(u, c));
}
dfs(0);
dfs_up(0);
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
u--, v--;
int t = lca(u, v);
int d = fix(dis[u] - dis[t] + dis[v] - dis[t]);
int ans = fix(dw2[u] + up2[u]);
if (t == v) {
addto(ans, -2 *
(up2[v] + 2 * (long long)d * up1[v] +
d * (long long)d % mod * up0[v]) %
mod);
} else {
addto(ans, -2 *
(dw2[v] + 2 * (long long)d * dw1[v] +
d * (long long)d % mod * dw0[v]) %
mod);
ans = fix(-ans);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> E[101000];
vector<long long> L[101000];
int n, Count[101000], Num[101000], cnt, par[101000], pp[18][101000];
long long Mod = 1000000007, D[101000], D2[101000], T[101000], T2[101000],
pL[101000], DL[101000];
int Dep[101000];
void DFS(int a, int pp) {
Num[a] = ++cnt;
int i, x, y;
x = Num[a];
Count[x]++;
par[x] = Num[pp];
for (i = 0; i < E[a].size(); i++) {
if (pp != E[a][i]) {
DFS(E[a][i], a);
y = Num[E[a][i]];
pL[y] = L[a][i];
Count[x] += Count[y];
D[x] = (D[x] + D[y] + L[a][i] * Count[y]) % Mod;
D2[x] = (D2[x] + D2[y] + L[a][i] * L[a][i] % Mod * Count[y] +
2 * L[a][i] * D[y]) %
Mod;
}
}
}
void Pro() {
int i, p;
long long X, Y;
T[1] = D[1];
for (i = 2; i <= n; i++) {
p = par[i];
DL[i] = DL[p] + pL[i];
Dep[i] = Dep[p] + 1;
X = Count[i];
Y = n - Count[i];
T[i] = (T[p] + (Y - X + Mod) % Mod * pL[i]) % Mod;
}
}
void Pro2() {
int i;
long long Gap1, Gap2, X, Y, p;
T2[1] = D2[1];
for (i = 2; i <= n; i++) {
p = par[i];
X = Count[i], Y = n - Count[i];
Gap1 = ((T[i] - D[i] - pL[i] * Y % Mod + Mod * 2) % Mod * 2 * pL[i] +
pL[i] * pL[i] % Mod * Y) %
Mod;
Gap2 = (D[i] * 2 * pL[i] % Mod + pL[i] * pL[i] % Mod * X) % Mod;
T2[i] = (T2[p] + Gap1 - Gap2 + Mod) % Mod;
}
}
void PrePro() {
int i, j;
for (i = 1; i <= n; i++) pp[0][i] = par[i];
for (i = 0; i < 17; i++) {
for (j = 1; j <= n; j++) {
pp[i + 1][j] = pp[i][pp[i][j]];
}
}
}
int LCA(int a, int b) {
if (Dep[a] < Dep[b]) return LCA(b, a);
int d = Dep[a] - Dep[b], i = 0;
while (d) {
if (d & 1) a = pp[i][a];
d >>= 1;
i++;
}
for (i = 17; i >= 0; i--) {
if (pp[i][a] != pp[i][b]) {
a = pp[i][a], b = pp[i][b];
}
}
if (a != b) a = pp[0][a], b = pp[0][b];
return a;
}
long long dist(int a, int b) {
int ppp = LCA(a, b);
return (DL[a] + DL[b] - DL[ppp] * 2 + Mod * 2) % Mod;
}
long long Solve2(int a, int b) {
long long d = dist(a, b);
long long r = (D2[b] + 2 * d * D[b] % Mod + d * d % Mod * Count[b]) % Mod;
return (r * 2 - T2[a] + Mod) % Mod;
}
long long Solve1(int a, int b) {
long long d = dist(a, b);
long long r =
((T2[b] - D2[b] + Mod) % Mod + (T[b] - D[b] + Mod) % Mod * 2 * d % Mod +
d * d % Mod * (n - Count[b])) %
Mod;
return (T2[a] - r * 2 + Mod * 2) % Mod;
}
void Output() {
int Q, a, b;
scanf("%d", &Q);
while (Q--) {
scanf("%d%d", &a, &b);
a = Num[a], b = Num[b];
if (LCA(a, b) == b) {
printf("%lld\n", Solve1(a, b));
} else {
printf("%lld\n", Solve2(a, b));
}
}
}
int main() {
int i, a, b, c;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d%d", &a, &b, &c);
E[a].push_back(b);
E[b].push_back(a);
L[a].push_back(c);
L[b].push_back(c);
}
DFS(1, 0);
Pro();
Pro2();
PrePro();
Output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
const int M = 6 * N;
const int mod = 1e9 + 7;
int add(int x, int y) {
x += y;
return x >= mod ? x - mod : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + mod : x;
}
int mul(int x, int y) { return (long long)x * y % mod; }
int pow(int x, int k) {
int ans = 1;
for (; k; k >>= 1, x = mul(x, x))
if (k & 1) ans = mul(ans, x);
return ans;
}
int inv(int x) { return pow(x, mod - 2); }
int sum_1[N], sum_2[N], lid[N], rid[N], tid, dfn[N], dep[N], n;
vector<pair<int, int>> E[N];
void DFS(int u, int p) {
lid[u] = ++tid;
dfn[tid] = u;
sum_1[tid] = add(sum_1[tid - 1], dep[u]);
sum_2[tid] = add(sum_2[tid - 1], mul(dep[u], dep[u]));
for (auto e : E[u])
if (e.first != p) dep[e.first] = add(dep[u], e.second), DFS(e.first, u);
rid[u] = tid;
}
int root[3], tsz, ls[M], rs[M], sum[M], lzy_mul[M], lzy[M];
bool persistent;
struct Node {
int c, sum, lzy_mul, lzy;
};
vector<Node> bck;
void upd(int c, int ss, int se, int x) {
if (persistent) bck.push_back({c, sum[c], lzy_mul[c], lzy[c]});
sum[c] = mul(x, se - ss + 1);
lzy[c] = x;
lzy_mul[c] = 1;
}
void upd_mul(int c, int x) {
if (persistent) bck.push_back({c, sum[c], lzy_mul[c], lzy[c]});
sum[c] = mul(sum[c], x);
if (lzy[c] != -1)
lzy[c] = mul(lzy[c], x);
else
lzy_mul[c] = mul(lzy_mul[c], x);
}
void push(int c, int ss, int se) {
if (!ls[c]) ls[c] = ++tsz, lzy[ls[c]] = -1, lzy_mul[ls[c]] = 1;
if (!rs[c]) rs[c] = ++tsz, lzy[rs[c]] = -1, lzy_mul[rs[c]] = 1;
if (lzy_mul[c] != 1) {
if (persistent) bck.push_back({c, sum[c], lzy_mul[c], lzy[c]});
upd_mul(ls[c], lzy_mul[c]);
upd_mul(rs[c], lzy_mul[c]);
lzy_mul[c] = 1;
}
if (lzy[c] != -1) {
if (persistent) bck.push_back({c, sum[c], lzy_mul[c], lzy[c]});
int mid = ss + se >> 1;
upd(ls[c], ss, mid, lzy[c]);
upd(rs[c], mid + 1, se, lzy[c]);
lzy[c] = -1;
}
}
void Set(int &c, int ss, int se, int qs, int qe, int val) {
if (qs > qe || qs > se || ss > qe) return;
if (!c) c = ++tsz, lzy_mul[c] = 1, lzy[c] = -1;
if (qs <= ss && qe >= se) {
upd(c, ss, se, val);
return;
}
push(c, ss, se);
int mid = ss + se >> 1;
Set(ls[c], ss, mid, qs, qe, val);
Set(rs[c], mid + 1, se, qs, qe, val);
if (persistent) bck.push_back({c, sum[c], lzy_mul[c], lzy[c]});
sum[c] = add(sum[ls[c]], sum[rs[c]]);
}
void Mul(int &c, int ss, int se, int qs, int qe, int val) {
if (qs > qe || qs > se || ss > qe) return;
if (!c) c = ++tsz, lzy_mul[c] = 1, lzy[c] = -1;
if (qs <= ss && qe >= se) {
upd_mul(c, val);
return;
}
push(c, ss, se);
int mid = ss + se >> 1;
Mul(ls[c], ss, mid, qs, qe, val);
Mul(rs[c], mid + 1, se, qs, qe, val);
if (persistent) bck.push_back({c, sum[c], lzy_mul[c], lzy[c]});
sum[c] = add(sum[ls[c]], sum[rs[c]]);
}
int Get(int &c, int ss, int se, int qs, int qe) {
if (qs > qe || qs > se || ss > qe) return 0;
if (!c) c = ++tsz, lzy_mul[c] = 1, lzy[c] = -1;
if (qs <= ss && qe >= se) return sum[c];
push(c, ss, se);
int mid = ss + se >> 1;
return add(Get(ls[c], ss, mid, qs, qe), Get(rs[c], mid + 1, se, qs, qe));
}
void Back(int sz) {
while (bck.size() > sz) {
sum[bck.back().c] = bck.back().sum;
lzy_mul[bck.back().c] = bck.back().lzy_mul;
lzy[bck.back().c] = bck.back().lzy;
bck.pop_back();
}
}
vector<int> Qs[N];
int a[N], b[N], ans[N];
int Solve(int u, int l, int r) {
if (l > r) return 0;
int ans = mul(mul(dep[u], dep[u]), r - l + 1);
ans = add(ans, sub(sum_2[r], sum_2[l - 1]));
int lca_2 = Get(root[0], 1, n, l, r);
ans = add(ans, mul(4, lca_2));
int dep_v = sub(sum_1[r], sum_1[l - 1]);
ans = add(ans, mul(2, mul(dep_v, dep[u])));
int lca = Get(root[1], 1, n, l, r);
ans = add(ans, mul(sub(0, 4), mul(lca, dep[u])));
ans = add(ans, mul(sub(0, 4), Get(root[2], 1, n, l, r)));
return ans;
}
void Solve(int u, int p) {
Set(root[0], 1, n, lid[u], rid[u], mul(dep[u], dep[u]));
Set(root[1], 1, n, lid[u], rid[u], dep[u]);
int sz = bck.size();
persistent = 1;
Mul(root[2], 1, n, lid[u], rid[u], dep[u]);
for (int i : Qs[u]) {
ans[i] =
sub(sub(Solve(u, lid[b[i]], rid[b[i]]), Solve(u, 1, lid[b[i]] - 1)),
Solve(u, rid[b[i]] + 1, n));
}
persistent = 0;
for (auto e : E[u])
if (e.first != p) {
int v = e.first;
Back(sz);
persistent = 1;
Mul(root[2], 1, n, lid[u], lid[v] - 1, dep[u]);
Mul(root[2], 1, n, rid[v] + 1, rid[u], dep[u]);
persistent = 0;
Solve(v, u);
Set(root[0], 1, n, lid[v], rid[v], mul(dep[u], dep[u]));
Set(root[1], 1, n, lid[v], rid[v], dep[u]);
}
Back(sz);
}
int main() {
int u, v, w, q;
scanf("%i", &n);
for (int i = 1; i < n; i++)
scanf("%i %i %i", &u, &v, &w), E[u].push_back(make_pair(v, w)),
E[v].push_back(make_pair(u, w));
DFS(1, 0);
for (int i = 1; i <= n; i++) Set(root[2], 1, n, lid[i], lid[i], dep[i]);
scanf("%i", &q);
for (int i = 1; i <= q; i++)
scanf("%i %i", &a[i], &b[i]), Qs[a[i]].push_back(i);
Solve(1, 0);
for (int i = 1; i <= q; i++) printf("%i\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int N, Q;
vector<pair<int, int> > V[100002];
vector<int> W[100002];
int Q1[100002], Q2[100002];
bool S[100002];
int in[100002], out[100002], nods[100002], tn;
int D[100002];
int SUM[4 * 100002], ARB[4 * 100002], ADD[4 * 100002], A1, A2, As;
int result[100002];
void setall(int nod, int i1, int i2) {
if (i1 == i2) {
SUM[nod] = D[nods[i1]];
ARB[nod] = ((long long)D[nods[i1]]) * D[nods[i1]] % MOD;
return;
}
int mid = (i1 + i2) / 2;
setall(nod * 2, i1, mid);
setall(nod * 2 + 1, mid + 1, i2);
ARB[nod] = (ARB[nod * 2] + ARB[nod * 2 + 1]) % MOD;
SUM[nod] = (SUM[nod * 2] + SUM[nod * 2 + 1]) % MOD;
}
void renew(int nod, int i1, int i2) {
ARB[nod] += ((long long)ADD[nod]) * ADD[nod] % MOD * (i2 - i1 + 1) % MOD;
if (ARB[nod] >= MOD) ARB[nod] -= MOD;
ARB[nod] += ((long long)ADD[nod]) * SUM[nod] * 2 % MOD;
if (ARB[nod] >= MOD) ARB[nod] -= MOD;
SUM[nod] += ((long long)ADD[nod]) * (i2 - i1 + 1) % MOD;
if (SUM[nod] >= MOD) SUM[nod] -= MOD;
if (i1 != i2) {
ADD[nod * 2] += ADD[nod];
if (ADD[nod * 2] >= MOD) ADD[nod * 2] -= MOD;
ADD[nod * 2 + 1] += ADD[nod];
if (ADD[nod * 2 + 1] >= MOD) ADD[nod * 2 + 1] -= MOD;
}
ADD[nod] = 0;
}
void update(int nod, int i1, int i2) {
if (A1 <= i1 && i2 <= A2) {
ADD[nod] += As;
if (ADD[nod] >= MOD) ADD[nod] -= MOD;
return;
}
if (ADD[nod] != 0) renew(nod, i1, i2);
int mid = (i1 + i2) / 2;
if (A1 <= mid) update(nod * 2, i1, mid);
if (A2 > mid) update(nod * 2 + 1, mid + 1, i2);
renew(nod * 2, i1, mid);
renew(nod * 2 + 1, mid + 1, i2);
ARB[nod] = (ARB[nod * 2] + ARB[nod * 2 + 1]) % MOD;
SUM[nod] = (SUM[nod * 2] + SUM[nod * 2 + 1]) % MOD;
}
void query(int nod, int i1, int i2) {
if (ADD[nod] != 0) renew(nod, i1, i2);
if (A1 <= i1 && i2 <= A2) {
As += ARB[nod];
if (As >= MOD) As -= MOD;
return;
}
int mid = (i1 + i2) / 2;
if (A1 <= mid) query(nod * 2, i1, mid);
if (A2 > mid) query(nod * 2 + 1, mid + 1, i2);
}
void Dfs(int x) {
S[x] = true;
in[x] = ++tn;
nods[tn] = x;
for (auto nod : V[x])
if (!S[nod.first]) {
D[nod.first] = (D[x] + nod.second) % MOD;
Dfs(nod.first);
}
out[x] = tn;
}
void Prop(int x) {
S[x] = true;
for (auto qn : W[x]) {
A1 = 1, A2 = N, As = 0;
query(1, 1, N);
result[qn] = (MOD - As) % MOD;
A1 = in[Q2[qn]], A2 = out[Q2[qn]], As = 0;
query(1, 1, N);
As = 2 * As % MOD;
result[qn] += As;
if (result[qn] >= MOD) result[qn] -= MOD;
}
for (auto nod : V[x])
if (!S[nod.first]) {
A1 = 1, A2 = N, As = nod.second;
update(1, 1, N);
A1 = in[nod.first], A2 = out[nod.first],
As = (2 * MOD - 2 * nod.second) % MOD;
update(1, 1, N);
Prop(nod.first);
A1 = 1, A2 = N, As = (MOD - nod.second) % MOD;
update(1, 1, N);
A1 = in[nod.first], A2 = out[nod.first], As = 2 * nod.second % MOD;
update(1, 1, N);
}
}
int main() {
cin.sync_with_stdio(false);
cin >> N;
for (int i = 1, nod1, nod2, val; i <= N - 1; ++i) {
cin >> nod1 >> nod2 >> val;
V[nod1].push_back(make_pair(nod2, val));
V[nod2].push_back(make_pair(nod1, val));
}
cin >> Q;
for (int i = 1; i <= Q; ++i) {
cin >> Q1[i] >> Q2[i];
W[Q1[i]].push_back(i);
}
Dfs(1);
setall(1, 1, N);
memset(S, 0, sizeof(S));
Prop(1);
for (int i = 1; i <= Q; ++i) cout << result[i] << '\n';
}
|
#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;
const int N = 1e5 + 5, mod = 1e9 + 7;
int zrb(int a, int b) { return (1LL * a * b % mod); }
int jm(int a, int b) {
int tmp = (a + b) % mod;
while (tmp < 0) tmp += mod;
return (tmp);
}
int A[N], D[N << 2], SM[N << 2], SMLZ[N << 2], P[N], ST[N], FT[N], n, st, q,
RT[N];
struct node {
int x, id, c;
};
vector<node> ND[N];
void build(int id = 1, int l = 0, int r = n) {
if (r - l < 2) {
D[id] = zrb(A[l], A[l]);
SM[id] = A[l];
return;
}
int mid = ((l + r) >> 1);
build((id << 1), l, mid);
build((id << 1 | 1), mid, r);
D[id] = jm(D[(id << 1)], D[(id << 1 | 1)]);
SM[id] = jm(SM[(id << 1)], SM[(id << 1 | 1)]);
}
void shift(int id, int l, int r) {
int ll = (id << 1), rr = (id << 1 | 1), mid = ((l + r) >> 1);
D[ll] = jm(D[ll], zrb(2, zrb(SM[ll], SMLZ[id])));
D[rr] = jm(D[rr], zrb(2, zrb(SM[rr], SMLZ[id])));
D[ll] = jm(D[ll], zrb(mid - l, zrb(SMLZ[id], SMLZ[id])));
D[rr] = jm(D[rr], zrb(r - mid, zrb(SMLZ[id], SMLZ[id])));
SMLZ[ll] = jm(SMLZ[ll], SMLZ[id]);
SMLZ[rr] = jm(SMLZ[rr], SMLZ[id]);
SM[ll] = jm(SM[ll], zrb(mid - l, SMLZ[id]));
SM[rr] = jm(SM[rr], zrb(r - mid, SMLZ[id]));
SMLZ[id] = 0;
}
void add(int s, int e, int d, int id = 1, int l = 0, int r = n) {
if (s >= e) return;
if (l >= e || r <= s) return;
if (l >= s && r <= e) {
int ln = r - l;
D[id] = jm(D[id], zrb(ln, zrb(d, d)));
D[id] = jm(D[id], zrb(2, zrb(SM[id], d)));
SM[id] = jm(SM[id], zrb(ln, d));
SMLZ[id] = jm(SMLZ[id], d);
return;
}
int mid = ((l + r) >> 1);
shift(id, l, r);
add(s, e, d, (id << 1), l, mid);
add(s, e, d, (id << 1 | 1), mid, r);
D[id] = jm(D[(id << 1)], D[(id << 1 | 1)]);
SM[id] = jm(SM[(id << 1)], SM[(id << 1 | 1)]);
}
int get(int s, int e, int id = 1, int l = 0, int r = n) {
if (s >= e) return (0);
if (l >= e || r <= s) return (0);
if (l >= s && r <= e) return (D[id]);
int mid = ((l + r) >> 1);
shift(id, l, r);
return (jm(get(s, e, (id << 1), l, mid), get(s, e, (id << 1 | 1), mid, r)));
}
vector<pair<int, int> > adj[N];
void prDFS(int u, int p, int d = 0) {
ST[u] = st;
A[st++] = d;
for (pair<int, int> x : adj[u])
if (x.first ^ p) {
P[x.first] = x.second;
prDFS(x.first, u, jm(d, x.second));
}
FT[u] = st;
}
void DFS(int u, int p) {
for (node nd : ND[u]) {
if (!nd.c) {
RT[nd.id] = jm(RT[nd.id], get(ST[nd.x], FT[nd.x]));
} else {
RT[nd.id] = jm(RT[nd.id], -D[1]);
RT[nd.id] = jm(RT[nd.id], get(ST[nd.x], FT[nd.x]));
}
}
for (pair<int, int> x : adj[u])
if (x.first ^ p) {
add(ST[x.first], FT[x.first], -x.second);
add(0, ST[x.first], x.second);
add(FT[x.first], n, x.second);
DFS(x.first, u);
add(ST[x.first], FT[x.first], x.second);
add(0, ST[x.first], -x.second);
add(FT[x.first], n, -x.second);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
prDFS(1, 0);
build();
scanf("%d", &q);
for (int Q = 0; Q < q; Q++) {
int a, b;
scanf("%d %d", &a, &b);
node nd = {b, Q, 0};
ND[a].push_back(nd);
nd = {b, Q, 1};
ND[a].push_back(nd);
}
DFS(1, 0);
for (int i = 0; i < q; i++) printf("%d\n", RT[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > E[100010];
int down[100010], vis[100010];
int n;
const int MOD = 1e9 + 7;
pair<int, int> S[100010];
pair<int, int> PP[100010];
void get_dfs(int x, int fa, int L, pair<int, int> &A) {
down[x] = 1;
A.first = (A.first + L) % MOD;
A.second = (A.second + (long long)L * L) % MOD;
for (auto e : E[x])
if (e.second != fa && vis[e.second] == 0) {
get_dfs(e.second, x, (L + e.first) % MOD, A);
down[x] += down[e.second];
}
}
void down_dfs(int x, int fa) {
down[x] = 1;
for (auto e : E[x])
if (e.second != fa && vis[e.second] == 0) {
down_dfs(e.second, x);
down[x] += down[e.second];
}
}
void put_dfs(int x, int fa, int L, pair<int, int> &A, int L0) {
PP[x].second = (PP[x].second + A.second + A.first * 2LL * L +
((long long)L * L) % MOD * L0) %
MOD;
PP[x].first = (PP[x].first + A.first + (long long)L0 * L) % MOD;
for (auto e : E[x])
if (e.second != fa && vis[e.second] == 0) {
put_dfs(e.second, x, (L + e.first) % MOD, A, L0);
}
}
void Do(int x) {
down_dfs(x, -1);
int c = x, h = down[x] / 2;
while (1) {
int f = 0;
for (auto e : E[c])
if (vis[e.second] == 0 && down[e.second] < down[c] &&
down[e.second] > h) {
c = e.second;
f = 1;
break;
}
if (f == 0) break;
}
vector<int> near;
vector<pair<int, int> > G;
vector<int> lu;
pair<int, int> tot = pair<int, int>(0, 0);
int L0 = 1;
for (auto e : E[c])
if (!vis[e.second]) {
near.push_back(e.second);
pair<int, int> A = pair<int, int>(0, 0);
get_dfs(e.second, c, e.first, A);
G.push_back(A);
lu.push_back(e.first);
tot.first = (tot.first + A.first) % MOD;
tot.second = (tot.second + A.second) % MOD;
L0 += down[e.second];
}
for (int i = 0; i < (int)near.size(); i++) {
int u = near[i];
pair<int, int> A =
pair<int, int>(tot.first - G[i].first, tot.second - G[i].second);
if (A.first < 0) A.first += MOD;
if (A.second < 0) A.second += MOD;
put_dfs(u, c, lu[i], A, L0 - down[u]);
}
PP[c].second = (PP[c].second + tot.second) % MOD;
PP[c].first = (PP[c].first + tot.first) % MOD;
vis[c] = 1;
for (int e : near) {
Do(e);
}
}
int dep[100010], ST[100010], EN[100010], ce;
int up[100010][20];
int Ldep[100010];
tuple<int, int, int> DP[100010];
void DFS(int x, int fa) {
get<0>(DP[x]) = 1;
ST[x] = ++ce;
for (auto e : E[x])
if (e.second != fa) {
dep[e.second] = dep[x] + 1;
Ldep[e.second] = (Ldep[x] + e.first) % MOD;
up[e.second][0] = x;
for (int i = 1; i < 20; i++)
up[e.second][i] = up[up[e.second][i - 1]][i - 1];
DFS(e.second, x);
int L = e.first;
int a0 = get<0>(DP[e.second]);
int a1 = get<1>(DP[e.second]);
int a2 = get<2>(DP[e.second]);
get<0>(DP[x]) += a0;
get<1>(DP[x]) = (a1 + get<1>(DP[x]) + (long long)L * a0) % MOD;
get<2>(DP[x]) = (get<2>(DP[x]) + ((long long)L * L) % MOD * a0 +
(long long)2 * L * a1 + a2) %
MOD;
}
EN[x] = ce;
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 0; i < 20; i++)
if (1 << i & (dep[x] - dep[y])) x = up[x][i];
for (int i = 19; i >= 0; i--)
if (up[x][i] != up[y][i]) x = up[x][i], y = up[y][i];
return x == y ? x : up[x][0];
}
void solve() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
E[x].push_back(pair<int, int>(z, y));
E[y].push_back(pair<int, int>(z, x));
}
Do(1);
DFS(1, -1);
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
if (ST[v] <= ST[u] && ST[u] <= EN[v]) {
long long ans = PP[u].second;
long long C = 0;
long long a0 = n;
long long a1 = PP[v].first;
long long a2 = PP[v].second;
a0 -= get<0>(DP[v]);
a1 -= get<1>(DP[v]);
a2 -= get<2>(DP[v]);
long long L = Ldep[u] - Ldep[v];
if (L < 0) L += MOD;
C += (L * L) % MOD * a0;
C += 2LL * L * a1;
C += a2;
ans -= 2 * C;
ans %= MOD;
if (ans < 0) ans += MOD;
printf("%lld\n", ans);
} else {
long long ans = -PP[u].second;
int a0 = get<0>(DP[v]);
int a1 = get<1>(DP[v]);
int a2 = get<2>(DP[v]);
int lc = lca(u, v);
long long L = Ldep[u] + Ldep[v] - 2LL * Ldep[lc];
if (L < 0) L += MOD;
ans += 2LL * (L * L) % MOD * a0;
ans += 4LL * L * a1;
ans += 2LL * a2;
ans %= MOD;
if (ans < 0) ans += MOD;
printf("%lld\n", ans);
}
}
}
int main() {
int Tc = 1;
for (int tc = 1; tc <= Tc; tc++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<pair<int, int> > adj[100013];
int visited[100013];
int sizst[100013];
int sumst[100013];
int sqsst[100013];
int sumsq[100013];
int sumsm[100013];
int depth[100013];
int h[100013];
int ancestor[100013][20];
int up[100013];
int MOD = 1000000007;
void dfsLCA(int x) {
visited[x] = 1;
for (int i = 0; i < adj[x].size(); i++) {
int next = adj[x][i].first;
int dist = adj[x][i].second;
if (!visited[next]) {
h[next] = h[x] + 1;
depth[next] = (depth[x] + dist) % MOD;
dfsLCA(next);
ancestor[next][0] = x;
up[next] = dist;
}
}
ancestor[x][0] = -1;
}
int findkth(int x, int k) {
int where = x;
for (int i = 19; i >= 0; i--)
if (k & (1 << i)) where = ancestor[where][i];
return where;
}
int lca(int a, int b) {
if (h[a] > h[b]) swap(a, b);
b = findkth(b, h[b] - h[a]);
if (a == b) return a;
for (int i = 19; i >= 0; i--) {
if (h[a] < (1 << i)) continue;
int na = ancestor[a][i];
int nb = ancestor[b][i];
if (na != nb) a = na, b = nb;
}
return ancestor[a][0];
}
void dfs(int x) {
visited[x] = 1;
sizst[x] = 1;
for (int i = 0; i < adj[x].size(); i++) {
int next = adj[x][i].first;
if (visited[next]) continue;
dfs(next);
int dist = adj[x][i].second;
sizst[x] += sizst[next];
sumst[x] = (sumst[x] + sumst[next] + (long long)dist * sizst[next]) % MOD;
int distsq = ((long long)dist * dist) % MOD;
sqsst[x] = (sqsst[x] + (long long)distsq * sizst[next] +
(long long)2 * dist * sumst[next] + sqsst[next]) %
MOD;
}
}
void dfs2(int x) {
visited[x] = 1;
if (x == 0) {
sumsm[x] = sumst[x];
sumsq[x] = sqsst[x];
} else {
int prev = ancestor[x][0];
int dist = up[x];
int distsq = ((long long)dist * dist) % MOD;
int below = (sqsst[x] + (long long)2 * dist * sumst[x] +
(long long)sizst[x] * distsq) %
MOD;
int abovesq = (sumsq[prev] - below + MOD) % MOD;
int abovesm =
((sumsm[prev] - sumst[x] - (long long)dist * sizst[x] + MOD) % MOD +
MOD) %
MOD;
int num = n - sizst[x];
sumsm[x] = (sumst[x] + abovesm + (long long)num * dist) % MOD;
sumsq[x] = (sqsst[x] + (long long)distsq * num +
((long long)2 * dist * abovesm) % MOD + abovesq) %
MOD;
}
for (int i = 0; i < adj[x].size(); i++)
if (!visited[adj[x][i].first]) dfs2(adj[x][i].first);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a -= 1;
b -= 1;
adj[a].push_back(make_pair(b, c));
adj[b].push_back(make_pair(a, c));
}
dfsLCA(0);
for (int i = 1; i < 20; i++) {
for (int j = 0; j < n; j++) {
if (h[j] < (1 << i))
ancestor[j][i] = -1;
else
ancestor[j][i] = ancestor[ancestor[j][i - 1]][i - 1];
}
}
for (int i = 0; i < n; i++) visited[i] = 0;
dfs(0);
for (int i = 0; i < n; i++) visited[i] = 0;
dfs2(0);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d%d", &u, &v);
u -= 1;
v -= 1;
int l = lca(u, v);
if (l == v) {
int diff = (depth[u] - depth[v] + MOD) % MOD;
int diffsq = ((long long)diff * diff) % MOD;
int abovesq = (sumsq[v] - sqsst[v] + MOD) % MOD;
int abovesm = (sumsm[v] - sumst[v] + MOD) % MOD;
int tops = ((long long)diffsq * (n - sizst[v]) +
((long long)2 * diff * abovesm) % MOD + abovesq) %
MOD;
int part1 = (sumsq[u] - tops + MOD) % MOD;
printf("%d\n", ((long long)2 * part1 - sumsq[u] + MOD) % MOD);
} else {
int diff =
((long long)depth[u] + depth[v] - 2 * depth[l] + 2 * MOD) % MOD;
int diffsq = ((long long)diff * diff) % MOD;
int part1 = ((long long)diffsq * sizst[v] +
((long long)2 * diff * sumst[v]) % MOD + sqsst[v]) %
MOD;
printf("%d\n", ((long long)2 * part1 - sumsq[u] + MOD) % MOD);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5;
const int MOD = 1e9 + 7;
struct node_t {
int sum;
int sum2;
int lazy;
node_t operator+(const node_t &other) const {
node_t ans;
ans.sum = (this->sum + other.sum) % MOD;
ans.sum2 = (this->sum2 + other.sum2) % MOD;
ans.lazy = 0;
return ans;
}
void add_val(int val, int st, int dr) {
this->lazy = (this->lazy + val) % MOD;
this->sum2 = (this->sum2 + 1LL * (1LL * val * val % MOD) * (dr - st + 1) +
2LL * val * this->sum) %
MOD;
this->sum = (this->sum + 1LL * val * (dr - st + 1)) % MOD;
}
};
node_t aint[4 * NMAX + 5];
int init_d[NMAX + 5];
int lin[NMAX + 5], len;
int fst[NMAX + 5];
int lst[NMAX + 5];
int n, q;
int ans[NMAX + 5];
vector<pair<int, int> > graph[NMAX + 5];
vector<pair<int, int> > queries[NMAX + 5];
void build(int nod, int st, int dr) {
if (st == dr) {
aint[nod].lazy = 0;
aint[nod].sum = init_d[lin[st]];
aint[nod].sum2 = 1LL * init_d[lin[st]] * init_d[lin[st]] % MOD;
return;
}
int mid = (st + dr) / 2;
build(nod * 2, st, mid);
build(nod * 2 + 1, mid + 1, dr);
aint[nod] = aint[2 * nod] + aint[2 * nod + 1];
}
void propag(int nod, int st, int dr) {
if (st == dr || aint[nod].lazy == 0) {
aint[nod].lazy = 0;
return;
}
int mid = (st + dr) / 2;
aint[nod * 2].add_val(aint[nod].lazy, st, mid);
aint[nod * 2 + 1].add_val(aint[nod].lazy, mid + 1, dr);
aint[nod].lazy = 0;
}
void update(int nod, int st, int dr, int S, int D, int val) {
propag(nod, st, dr);
if (dr < S || st > D) {
return;
}
if (S <= st && dr <= D) {
aint[nod].add_val(val, st, dr);
return;
}
int mid = (st + dr) / 2;
update(nod * 2, st, mid, S, D, val);
update(nod * 2 + 1, mid + 1, dr, S, D, val);
aint[nod] = aint[2 * nod] + aint[2 * nod + 1];
}
int query(int nod, int st, int dr, int S, int D) {
propag(nod, st, dr);
if (D < st || dr < S) {
return 0;
}
if (S <= st && dr <= D) {
return aint[nod].sum2;
}
int mid = (st + dr) / 2;
return (query(nod * 2, st, mid, S, D) +
query(nod * 2 + 1, mid + 1, dr, S, D)) %
MOD;
}
void predfs(int nod, int tata, int dist) {
init_d[nod] = dist;
lin[++len] = nod;
fst[nod] = len;
for (auto it : graph[nod]) {
if (it.first == tata) {
continue;
}
predfs(it.first, nod, (dist + it.second) % MOD);
}
lst[nod] = len;
}
void dfs(int nod, int tata) {
for (auto it : queries[nod]) {
ans[it.second] = ((2 * query(1, 1, n, fst[it.first], lst[it.first]) -
query(1, 1, n, 1, n)) %
MOD +
MOD) %
MOD;
}
for (auto it : graph[nod]) {
if (it.first == tata) {
continue;
}
update(1, 1, n, 1, n, it.second);
update(1, 1, n, fst[it.first], lst[it.first],
(2 * MOD - 2 * it.second) % MOD);
dfs(it.first, nod);
update(1, 1, n, fst[it.first], lst[it.first], 2 * it.second % MOD);
update(1, 1, n, 1, n, (MOD - it.second) % MOD);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
graph[x].push_back({y, z});
graph[y].push_back({x, z});
}
predfs(1, 0, 0);
build(1, 1, n);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int u, v;
scanf("%d %d", &u, &v);
queries[u].push_back({v, i});
}
dfs(1, 0);
for (int i = 1; i <= q; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e5 + 10, MOD = 1e9 + 7, MAX_L = 23;
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 Nmax = 100005, Mod = 1e9 + 7;
vector<pair<int, int>> G[Nmax];
int SumDown[Nmax], SumDownS[Nmax], SumUp[Nmax], SumUpS[Nmax], Total[Nmax];
int Subtree[Nmax], H[Nmax];
int Father[17][Nmax], Lvl[Nmax];
int firstE[Nmax], lastE[Nmax];
int N, E;
void dfs1(const int node, const int father) {
firstE[node] = ++E;
Subtree[node] = 1;
for (auto& p : G[node]) {
if (p.first == father) continue;
Father[0][p.first] = node;
Lvl[p.first] = Lvl[node] + 1;
H[p.first] = (H[node] + p.second) % Mod;
dfs1(p.first, node);
int x = Subtree[p.first];
Subtree[node] += x;
SumDown[node] =
(SumDown[node] + SumDown[p.first] + 1LL * p.second * x % Mod) % Mod;
SumDownS[node] = (SumDownS[node] + SumDownS[p.first] +
1LL * p.second * p.second % Mod * x % Mod +
2LL * p.second * SumDown[p.first] % Mod) %
Mod;
}
lastE[node] = ++E;
}
void dfs2(const int node, const int father, const int lastCost) {
if (father != 0) {
int x = Subtree[node];
int sumf = (SumDown[father] + SumUp[father]) % Mod;
sumf = (sumf + Mod - (SumDown[node] + 1LL * lastCost * x) % Mod) % Mod;
int sumfs = (SumDownS[father] + SumUpS[father]) % Mod;
sumfs = (sumfs + Mod -
(SumDownS[node] + 1LL * lastCost * lastCost % Mod * x % Mod +
2LL * lastCost * SumDown[node] % Mod) %
Mod) %
Mod;
SumUp[node] = (sumf + 1LL * lastCost * (N - x)) % Mod;
SumUpS[node] = (sumfs + 1LL * lastCost * lastCost % Mod * (N - x) % Mod +
2LL * lastCost * sumf % Mod) %
Mod;
}
for (auto& p : G[node])
if (p.first != father) dfs2(p.first, node, p.second);
}
void buildAscensors() {
for (int k = 1; k < 17; ++k)
for (int i = 1; i <= N; ++i) Father[k][i] = Father[k - 1][Father[k - 1][i]];
}
inline bool isAscensor(int node, int asc) {
return firstE[asc] <= firstE[node] && lastE[node] <= lastE[asc];
}
int lca(int x, int y) {
if (isAscensor(x, y)) return y;
if (isAscensor(y, x)) return x;
for (int k = 16; k >= 0; --k)
if (!isAscensor(y, Father[k][x])) x = Father[k][x];
return Father[0][x];
}
int main() {
ios::sync_with_stdio(false);
cin >> N;
for (int i = 1; i < N; ++i) {
int x, y, c;
cin >> x >> y >> c;
c %= Mod;
G[x].push_back({y, c});
G[y].push_back({x, c});
}
dfs1(1, 0);
Father[0][1] = 1;
dfs2(1, 0, 0);
buildAscensors();
for (int i = 1; i <= N; ++i) Total[i] = (SumDownS[i] + SumUpS[i]) % Mod;
int Q;
cin >> Q;
while (Q--) {
int x, y;
cin >> x >> y;
int ans = 0;
if (!isAscensor(x, y)) {
ans = (Mod - Total[x]) % Mod;
int l = lca(x, y);
int dist = ((H[x] - H[l] + Mod) % Mod + (H[y] - H[l] + Mod) % Mod) % Mod;
int add = (SumDownS[y] + 1LL * dist * dist % Mod * Subtree[y] % Mod +
2LL * dist * SumDown[y] % Mod) %
Mod;
ans = (ans + add) % Mod;
ans = (ans + add) % Mod;
} else {
ans = Total[x];
int dist = (H[x] - H[y]) % Mod;
int add = (SumUpS[y] + 1LL * dist * dist % Mod * (N - Subtree[y]) % Mod +
2LL * dist * SumUp[y] % Mod) %
Mod;
add = (Mod - add) % Mod;
ans = (ans + add) % Mod;
ans = (ans + add) % Mod;
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m, tot;
long long n;
int head[100010], to[300010], net[300010];
long long val[300010], mod = 1000000007;
void add(int x, int y, int c) {
net[++tot] = head[x], head[x] = tot, to[tot] = y, val[tot] = c;
}
int deep[100010], son[100010], fa[100010], top[100010];
struct your {
long long dis, sqr, tre;
} dp[100010], sum[100010], all[100010];
long long dis[100010], size[100010];
void dfs(int x) {
deep[x] = deep[fa[x]] + 1, size[x] = 1;
for (int i = head[x]; i; i = net[i])
if (to[i] != fa[x]) {
dis[to[i]] = (dis[x] + val[i]) % mod, fa[to[i]] = x, dfs(to[i]),
size[x] += size[to[i]];
if (size[to[i]] > size[son[x]]) son[x] = to[i];
dp[x].dis =
(dp[x].dis + dp[to[i]].dis % mod + size[to[i]] * val[i] % mod) % mod;
long long tmp = size[to[i]] * val[i] % mod * val[i] % mod;
long long nmp = (dp[to[i]].sqr + 2 * val[i] * dp[to[i]].dis % mod) % mod;
dp[x].sqr = (dp[x].sqr + tmp + nmp) % mod;
}
}
void dfs2(int x) {
for (int i = head[x]; i; i = net[i]) {
if (to[i] == fa[x]) continue;
long long tmp = (sum[x].dis + (n - 2 * size[to[i]]) * val[i]) % mod;
long long nmp = (dp[x].dis - dp[to[i]].dis + mod) % mod;
sum[to[i]].dis = (tmp + nmp) % mod;
tmp = (sum[x].sqr + 2 * sum[x].dis * val[i] % mod +
(n - size[x]) * val[i] % mod * val[i] % mod) %
mod;
long long dx, dy, dc;
dx = ((dp[x].sqr - dp[to[i]].sqr - 2 * val[i] * dp[to[i]].dis % mod -
size[to[i]] * val[i] % mod * val[i] % mod) %
mod +
mod) %
mod;
dy = (size[x] - size[to[i]]) * val[i] % mod * val[i] % mod;
dc = (2 * val[i] *
(dp[x].dis - dp[to[i]].dis - val[i] * size[to[i]] % mod) % mod +
mod) %
mod;
sum[to[i]].sqr = (tmp + dx + dy + dc) % mod;
dfs2(to[i]);
}
}
void dfs3(int x, int temp) {
top[x] = temp;
if (son[x]) dfs3(son[x], temp);
for (int i = head[x]; i; i = net[i])
if (to[i] != fa[x] && to[i] != son[x]) dfs3(to[i], to[i]);
}
int lca(int x, int y) {
while (top[x] != top[y]) {
if (deep[top[x]] < deep[top[y]]) swap(x, y);
x = fa[top[x]];
}
return deep[x] < deep[y] ? x : y;
}
void check(int x, int y);
int main() {
scanf("%lld", &n);
for (int x, y, c, i = 1; i < n; i++)
scanf("%d%d%d", &x, &y, &c), add(x, y, c), add(y, x, c);
dfs(1), dfs2(1), dfs3(1, 1);
for (int i = 1; i <= n; i++) {
all[i].dis = (sum[i].dis + dp[i].dis) % mod;
all[i].sqr = (sum[i].sqr + dp[i].sqr) % mod;
all[i].tre = (sum[i].tre + dp[i].tre) % mod;
}
scanf("%d", &m);
for (int x, y, i = 1; i <= m; i++) scanf("%d%d", &x, &y), check(x, y);
return 0;
}
void check(int x, int y) {
int l = lca(x, y);
if (l != x && l != y) {
long long c = ((dis[x] + dis[y] - 2 * dis[l]) % mod + mod) % mod;
long long tmp = (dp[y].sqr + (long long)c * c % mod * size[y] % mod +
2 * c * dp[y].dis % mod) %
mod;
printf("%lld\n", (2 * tmp % mod - all[x].sqr + mod) % mod);
} else if (l == x) {
long long c = ((dis[x] + dis[y] - 2 * dis[l]) % mod + mod) % mod;
long long tmp = (dp[y].sqr + (long long)c * c % mod * size[y] % mod +
2 * c * dp[y].dis % mod) %
mod;
printf("%lld\n", (2 * tmp % mod - all[x].sqr + mod) % mod);
} else if (l == y) {
long long c = ((dis[x] + dis[y] - 2 * dis[l]) % mod + mod) % mod;
long long tmp = (sum[y].sqr + (long long)c * c % mod * (n - size[y]) % mod +
2 * c * sum[y].dis % mod) %
mod;
printf("%lld\n", ((all[x].sqr - 2 * tmp) % mod + mod) % mod);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
struct P {
int to;
long long dis;
};
vector<P> v[maxn];
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;
int ri() {
int x;
scanf("%d", &x);
return x;
}
const int N = 100000, MOD = (int)1e9 + 7;
vector<pair<int, int> > e[N], q[N];
int dep[N], djs[N], ans[N];
struct D {
int64_t cnt, sum, sum2;
D operator~() { return operator+(*this); }
D operator*(int64_t o) const {
return {cnt, (sum + cnt * o) % MOD,
(sum2 + sum * 2 * o + o * o % MOD * cnt) % MOD};
}
D operator+(const D &o) const {
return {cnt + o.cnt, (sum + o.sum) % MOD, (sum2 + o.sum2) % MOD};
}
D operator-(const D &o) const {
return {cnt - o.cnt, (sum - o.sum) % MOD, (sum2 - o.sum2) % MOD};
}
} a[N], s[N];
int find(int v) {
while (djs[v] != v) djs[v] = djs[djs[v]], v = djs[v];
return v;
}
void dfs(int v, int p, int d) {
dep[v] = d;
s[v] = {1, 0, 0};
for (auto ee : e[v])
if (ee.first != p) {
dfs(ee.first, v, (d + ee.second) % MOD);
s[v] = s[v] + s[ee.first] * ee.second;
}
}
void tarjan(int v, D all) {
a[v] = all;
djs[v] = v;
for (auto qq : q[v])
if (djs[qq.first] != -1) {
int x = v, y = qq.first, id = qq.second;
if (id < 0) id = ~id, swap(x, y);
int w = find(qq.first), d = (int64_t(dep[x]) + dep[y] - 2 * dep[w]) % MOD;
ans[id] =
(w == y ? a[x] - ~((a[y] - s[y]) * d) : ~(s[y] * d) - a[x]).sum2;
}
for (auto ee : e[v])
if (djs[ee.first] == -1) {
tarjan(ee.first,
(all - s[ee.first] * ee.second) * ee.second + s[ee.first]);
djs[ee.first] = v;
}
}
int main() {
int n = ri();
for (int i = (0); i < (n - 1); i++) {
int v = ri() - 1, u = ri() - 1, w = ri();
e[v].push_back({u, w});
e[u].push_back({v, w});
}
int m = ri();
for (int i = (0); i < (m); i++) {
int v = ri() - 1, u = ri() - 1;
q[v].push_back({u, i});
q[u].push_back({v, ~i});
}
dfs(0, -1, 0);
fill_n(djs, n, -1);
tarjan(0, s[0]);
for (int i = (0); i < (m); i++) printf("%d\n", (ans[i] + MOD) % MOD);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10, mod = 1e9 + 7, lg = 16 + 2;
long long n, q, par[N][lg], sumup[N][lg], tvin[N][lg], sumin[N][lg],
cntin[N][lg], sumst[N], tvst[N], cntst[N], updtv[N], updsum[N], updcnt[N],
h[N];
vector<pair<long long, long long> > gr[N];
long long mrg(long long ftv, long long fsum, long long fcnt, long long add) {
return 1ll *
(1ll * ftv + 1ll * fsum * add % mod * 2 % mod +
1ll * add * add % mod * fcnt % mod) %
mod;
}
void getSt(long long v, long long par = -1) {
for (auto p : gr[v]) {
long long u = p.first, w = p.second;
if (u != par) {
getSt(u, v);
updtv[u] = mrg(tvst[u], sumst[u], cntst[u], w),
tvst[v] = (tvst[v] + updtv[u]) % mod;
updsum[u] = (1ll * cntst[u] * w % mod + sumst[u]) % mod,
sumst[v] = (sumst[v] + updsum[u]) % mod;
updcnt[u] = cntst[u], cntst[v] = cntst[v] + updcnt[u];
}
}
cntst[v]++;
}
void getPr(long long v, long long parent = -1, long long wb = -1) {
if (parent != -1) {
h[v] = h[parent] + 1;
par[v][0] = parent, sumup[v][0] = wb;
for (long long i = 1; i < lg - 1; i++)
par[v][i] = par[par[v][i - 1]][i - 1],
sumup[v][i] = (sumup[v][i - 1] + sumup[par[v][i - 1]][i - 1]) % mod;
cntin[v][0] = cntst[parent] - updcnt[v],
sumin[v][0] = (sumst[parent] - updsum[v] + mod) % mod;
tvin[v][0] = mrg((tvst[parent] - updtv[v] + mod) % mod, sumin[v][0],
cntin[v][0], wb);
sumin[v][0] = (sumin[v][0] + 1ll * cntin[v][0] * wb % mod) % mod;
for (long long i = 1; i < lg - 1; i++) {
cntin[v][i] = (cntin[v][i - 1] + cntin[par[v][i - 1]][i - 1]) % mod;
sumin[v][i] = ((sumin[v][i - 1] + 1ll * sumup[v][i - 1] *
cntin[par[v][i - 1]][i - 1] % mod) %
mod +
sumin[par[v][i - 1]][i - 1] % mod) %
mod;
tvin[v][i] = (tvin[v][i - 1] +
mrg(tvin[par[v][i - 1]][i - 1], sumin[par[v][i - 1]][i - 1],
cntin[par[v][i - 1]][i - 1], sumup[v][i - 1])) %
mod;
}
}
for (auto p : gr[v]) {
long long u = p.first, w = p.second;
if (u != parent) getPr(u, v, w);
}
}
bool isAnc(long long v, long long u) {
long long diff = h[v] - h[u];
if (diff <= 0) return false;
for (long long i = 0; i < lg - 1; i++)
if (((diff >> i) & 1)) v = par[v][i];
if (v == u) return true;
return false;
}
long long AnsAnc(long long v, long long u) {
long long pst = tvst[v], rtr = 0, sumrn = 0;
long long diff = h[v] - h[u];
for (long long i = lg - 1; i >= 0; i--) {
if (((diff >> i) & 1)) {
rtr = (rtr + mrg(tvin[v][i], sumin[v][i], cntin[v][i], sumrn)) % mod;
sumrn = (sumrn + sumup[v][i]) % mod;
v = par[v][i];
}
}
return (rtr + pst) % mod;
}
long long getSum(long long v, long long u) {
if (h[u] > h[v]) swap(u, v);
long long diff = h[v] - h[u], rtr = 0;
for (long long i = 0; i < lg - 1; i++) {
if (((diff >> i) & 1)) rtr = (rtr + sumup[v][i]) % mod, v = par[v][i];
}
if (v == u) return rtr;
for (long long i = lg - 1; i >= 0; i--) {
if (par[v][i] != par[u][i]) {
rtr = ((rtr + sumup[v][i]) % mod + sumup[u][i]) % mod;
v = par[v][i], u = par[u][i];
}
}
rtr = ((rtr + sumup[v][0]) % mod + sumup[u][0]) % mod;
return rtr;
}
long long AnsN(long long v, long long u) {
long long sum = getSum(v, u);
return mrg(tvst[u], sumst[u], cntst[u], sum);
}
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 x, y, w;
cin >> x >> y >> w;
x--, y--;
gr[x].push_back({y, w});
gr[y].push_back({x, w});
}
getSt(0);
getPr(0);
cin >> q;
while (q--) {
long long x, y;
cin >> x >> y;
x--, y--;
long long rtr;
if (isAnc(x, y))
rtr = AnsAnc(x, y);
else
rtr = AnsN(x, y);
long long mn = AnsAnc(x, 0);
rtr = ((rtr * 2 - mn) % mod + mod) % mod;
cout << rtr << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long t, d, g, h, s, ds, dq, dis, sum;
} A[100100];
int p[100100], nxt[2 * 100100], C[2 * 100100], V[2 * 100100], f[100100],
g[100100][19], n, q, i, ed;
int gi() {
int s = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getchar();
return s;
}
void Add(int u, int v, int c) {
V[++ed] = v, C[ed] = c, nxt[ed] = p[u], p[u] = ed;
}
long long sqr(long long x) { return (x * x) % 1000000007; };
long long Mul(long long x, long long y) {
return ((x % 1000000007) * y) % 1000000007;
}
void Dfs(int x, int fa) {
f[x] = fa, A[x].s = 1, A[x].t = A[f[x]].t + 1;
for (int i = p[x]; i != -1; i = nxt[i]) {
int v = V[i];
if (v == fa) continue;
A[v].d = (A[x].d + C[i]) % 1000000007;
A[v].g = (A[x].g + A[v].d) % 1000000007;
A[v].h = (A[x].h + sqr(A[v].d)) % 1000000007;
Dfs(v, x);
A[x].s = (A[x].s + A[v].s) % 1000000007;
A[x].ds = (A[x].ds + A[v].ds + A[v].s * C[i]) % 1000000007;
A[x].dq = (A[x].dq + A[v].dq + Mul(A[v].s, sqr(C[i])) +
2LL * Mul(A[v].ds, C[i])) %
1000000007;
}
}
void Calc(int x, long long c) {
A[x].dis = (A[f[x]].dis - Mul(A[x].s, c) + Mul((n - A[x].s), c)) % 1000000007;
A[x].sum = (A[f[x]].sum + Mul(n, sqr(c))) % 1000000007;
A[x].sum = (A[x].sum - 2LL * Mul(A[x].ds + Mul(A[x].s, c), c)) % 1000000007;
A[x].sum =
(A[x].sum + 2LL * Mul(A[x].dis - A[x].ds - Mul(n - A[x].s, c), c)) %
1000000007;
for (int i = p[x]; i != -1; i = nxt[i])
if (V[i] != f[x]) Calc(V[i], C[i]);
}
int Lca(int u, int v) {
if (A[u].t < A[v].t) swap(u, v);
for (int i = 18; i >= 0; i--)
if (A[g[u][i]].t >= A[v].t) u = g[u][i];
if (u == v) return u;
for (int i = 18; i >= 0; i--)
if (g[u][i] != g[v][i]) u = g[u][i], v = g[v][i];
return f[u];
}
int main() {
memset(p, -1, sizeof(p));
scanf("%d", &n);
for (i = 1; i < n; i++) {
int u = gi(), v = gi(), c = gi();
Add(u, v, c), Add(v, u, c);
}
Dfs(1, 0);
for (i = 1; i <= n; i++) g[i][0] = f[i];
for (i = 1; i <= 17; i++)
for (int j = 1; j <= n; j++) g[j][i] = g[g[j][i - 1]][i - 1];
for (i = 1; i <= n; i++) A[1].sum += sqr(A[i].d), A[1].dis += A[i].d;
A[1].sum %= 1000000007, A[1].dis %= 1000000007;
for (i = p[1]; i != -1; i = nxt[i]) Calc(V[i], C[i]);
scanf("%d", &q);
for (i = 1; i <= q; i++) {
int u = gi(), v = gi();
int z = Lca(u, v);
long long ans, o, h, b;
if (z == v && u != v) {
o = (A[v].d - A[f[v]].d) % 1000000007;
b = (A[u].d - A[f[v]].d) % 1000000007;
h = (A[f[v]].dis - A[v].ds - Mul(o, A[v].s)) % 1000000007;
ans = (A[f[v]].sum - A[v].dq - Mul(A[v].s, sqr(o)) -
2LL * Mul(A[v].ds, o)) %
1000000007;
ans = (ans + Mul(n - A[v].s, sqr(b)) + 2LL * Mul(h, b)) % 1000000007;
ans = (A[u].sum - 2 * ans) % 1000000007;
if (v == 1) ans = A[u].sum;
} else {
long long det = (A[u].d + A[v].d - 2LL * A[z].d) % 1000000007;
ans = (A[v].dq + Mul(A[v].s, sqr(det))) % 1000000007;
o = (2LL * Mul(A[v].ds, det)) % 1000000007;
ans = (2LL * (ans + o) - A[u].sum) % 1000000007;
}
printf("%I64d\n", (1000000007 + ans) % 1000000007);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct sol_t {
int many;
int sum2;
int sum1;
sol_t() { many = sum1 = sum2 = 0; }
void include(const sol_t &other) {
many = (many + other.many) % mod;
sum2 = (sum2 + other.sum2) % mod;
sum1 = (sum1 + other.sum1) % mod;
}
void uninclude(const sol_t &other) {
many = (many - other.many + mod) % mod;
sum2 = (sum2 - other.sum2 + mod) % mod;
sum1 = (sum1 - other.sum1 + mod) % mod;
}
void increase_all(int by) {
sum2 =
(sum2 + (long long)many * by % mod * by % mod + 2LL * by * sum1) % mod;
sum1 = (sum1 + (long long)many * by) % mod;
}
};
vector<pair<int, int> > adj[100000];
int height[100000];
long long depth[100000];
sol_t down[100000];
sol_t up[100000];
sol_t full[100000];
vector<int> path;
vector<long long> pathsum;
vector<pair<int, int> > queries[100000];
sol_t result[100000];
int logn;
int parent[100000][16 + 1];
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];
}
long long dist(int a, int b) {
return depth[a] + depth[b] - 2 * depth[lca(a, b)];
}
void dfs3(int u, int p, long long sum = 0) {
path.push_back(u);
pathsum.push_back(sum);
for (pair<int, int> query : queries[u]) {
int v = query.first;
int qid = query.second;
if (height[v] < (int)path.size() && path[height[v]] == v) {
result[qid].include(full[u]);
sol_t temp = up[v];
temp.increase_all((sum - pathsum[height[v]]) % mod);
result[qid].uninclude(temp);
result[qid].uninclude(temp);
} else {
result[qid].uninclude(full[u]);
sol_t temp = down[v];
temp.increase_all(dist(u, v) % mod);
result[qid].include(temp);
result[qid].include(temp);
}
}
for (const pair<int, int> &pp : adj[u]) {
int v2 = pp.first, dist = pp.second;
if (v2 == p) continue;
dfs3(v2, u, sum + dist);
}
path.pop_back();
pathsum.pop_back();
}
void dfs2(int v, int p, sol_t got) {
up[v] = got;
full[v] = up[v];
full[v].include(down[v]);
vector<pair<int, int> > child;
for (const pair<int, int> &pp : adj[v]) {
int v2 = pp.first, dist = pp.second;
if (v2 == p) continue;
child.push_back(make_pair(v2, dist));
}
int nc = child.size();
sol_t sum = down[v];
for (int c = 0; c < nc; c++) {
sol_t just = sum;
{
sol_t temp = down[child[c].first];
temp.increase_all(child[c].second);
just.uninclude(temp);
}
just.include(got);
just.increase_all(child[c].second);
dfs2(child[c].first, v, just);
}
}
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] = sol_t();
down[v].many = 1;
for (const pair<int, int> &pp : adj[v]) {
int v2 = pp.first, dist = pp.second;
if (v2 == p) continue;
parent[v2][0] = v;
dfs(v2, v, h + 1, d + dist);
sol_t temp = down[v2];
temp.increase_all(dist);
down[v].include(temp);
}
}
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(make_pair(b, c));
adj[b].push_back(make_pair(a, c));
}
parent[0][0] = 0;
dfs(0, -1, 0, 0);
sol_t temp;
dfs2(0, -1, temp);
int nq;
scanf("%d", &nq);
for (int q = 0; q < nq; q++) {
int u, v;
scanf("%d %d", &u, &v);
u--, v--;
queries[u].push_back(make_pair(v, q));
}
dfs3(0, -1);
for (int q = 0; q < nq; q++) printf("%d\n", result[q].sum2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXL = 20, mod = 1e9 + 7;
int timer = 0, n, k, l, w, q, used[100005], ans, tin[100005], tout[100005];
long long sz[100005], dist[100005], distsq[100005], updist[100005],
updistsq[100005], two[100005][20], twodist[100005][20];
vector<long long> d[100005];
vector<int> c[100005];
void dfs(int v, int p = 0, int w = 0) {
tin[v] = timer++;
sz[v] = 1;
used[v] = 1;
two[v][0] = p;
twodist[v][0] = w;
for (int i = 1; i < MAXL; i++) {
twodist[v][i] = (twodist[v][i - 1] + twodist[two[v][i - 1]][i - 1]) % mod;
two[v][i] = two[two[v][i - 1]][i - 1];
}
for (int i = 0; i < (int)c[v].size(); i++)
if (used[c[v][i]] == 0) {
dfs(c[v][i], v, d[v][i]);
sz[v] += sz[c[v][i]];
dist[v] = (dist[v] + dist[c[v][i]] + sz[c[v][i]] * d[v][i]) % mod;
distsq[v] = (distsq[v] + distsq[c[v][i]] + 2 * d[v][i] * dist[c[v][i]] +
d[v][i] * ((d[v][i] * sz[c[v][i]]) % mod)) %
mod;
}
tout[v] = timer++;
}
void dfs2(int v) {
used[v] = 1;
for (int i = 0; i < (int)c[v].size(); i++)
if (used[c[v][i]] == 0) {
updist[c[v][i]] =
((updist[v] + dist[v] - (dist[c[v][i]] + sz[c[v][i]] * d[v][i]) +
(n - sz[c[v][i]]) * d[v][i]) %
mod +
mod) %
mod;
long long l = ((updistsq[v] + distsq[v] -
(distsq[c[v][i]] + 2 * d[v][i] * dist[c[v][i]] +
d[v][i] * ((d[v][i] * sz[c[v][i]]) % mod))) %
mod +
mod) %
mod;
updistsq[c[v][i]] =
((l - d[v][i] * ((d[v][i] * (n - sz[c[v][i]])) % mod) +
2 * d[v][i] * updist[c[v][i]]) %
mod +
mod) %
mod;
dfs2(c[v][i]);
}
}
bool upper(int v, int u) { return (tin[v] <= tin[u] && tout[v] >= tout[u]); }
int lca(int a, int b) {
int res = 0;
if (a == b) return 0;
if (upper(a, b)) {
for (int i = MAXL - 1; i >= 0; i--)
if (!upper(two[b][i], a)) {
res = (res + twodist[b][i]) % mod;
b = two[b][i];
}
return (res + twodist[b][0]) % mod;
}
if (upper(b, a)) {
for (int i = MAXL - 1; i >= 0; i--)
if (!upper(two[a][i], b)) {
res = (res + twodist[a][i]) % mod;
a = two[a][i];
}
return (res + twodist[a][0]) % mod;
}
for (int i = MAXL - 1; i >= 0; i--)
if (!upper(two[a][i], b)) {
res = (res + twodist[a][i]) % mod;
a = two[a][i];
}
for (int i = MAXL - 1; i >= 0; i--)
if (!upper(two[b][i], a)) {
res = (res + twodist[b][i]) % mod;
b = two[b][i];
}
return ((res + twodist[a][0]) % mod + twodist[b][0]) % mod;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d%d", &k, &l, &w);
k--;
l--;
c[k].push_back(l);
c[l].push_back(k);
d[k].push_back(w);
d[l].push_back(w);
}
dfs(0);
for (int i = 0; i < n; i++) used[i] = 0;
dfs2(0);
for (int i = 0; i < n; i++) used[i] = 0;
scanf("%d", &q);
for (int qq = 0; qq < q; qq++) {
scanf("%d%d", &k, &l);
k--;
l--;
long long x = lca(k, l);
if (upper(l, k))
ans = ((((distsq[k] + updistsq[k] -
2 * (updistsq[l] + x * (x * (n - sz[l]) % mod) +
2 * x * updist[l])) %
mod) +
mod) %
mod) %
mod;
else
ans = ((2 * (x * ((x * sz[l]) % mod) + distsq[l] + 2 * x * dist[l]) -
(distsq[k] + updistsq[k])) %
mod +
mod) %
mod;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ss[1 << 17], *A = ss, *B = ss;
inline char gc() {
if (A == B) {
B = (A = ss) + fread(ss, 1, 1 << 17, stdin);
if (A == B) return EOF;
}
return *A++;
}
template <class T>
inline void read(T& x) {
static char c;
static int y;
for (c = gc(), x = 0, y = 1; c < 48 || 57 < c; c = gc())
if (c == '-') y = -1;
for (; 48 <= c && c <= 57; c = gc()) x = ((x + (x << 2)) << 1) + (c ^ '0');
x *= y;
}
const int mod = 1e9 + 7;
struct node {
int next, to, z;
} w[200001];
int cnt, head[100001], f[100001][3], g[100001][3], ans, q;
int top[100001], fa[100001], deep[100001], n, hs[100001];
int dis[100001];
inline int add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
inline int dec(int x, int y) { return x - y < 0 ? x - y + mod : x - y; }
inline int mul(int x, int y) { return 1ll * x * y - 1ll * x * y / mod * mod; }
inline void add_v(int x, int y, int z) {
w[++cnt].next = head[x];
w[cnt].to = y;
head[x] = cnt;
w[cnt].z = z;
}
void dfs1(int x, int da) {
f[x][0] = 1;
fa[x] = da;
for (int i = head[x]; i; i = w[i].next) {
if (w[i].to == da) continue;
deep[w[i].to] = add(deep[x], w[i].z);
dis[w[i].to] = dis[x] + 1;
dfs1(w[i].to, x);
f[x][0] += f[w[i].to][0];
f[x][1] = add(add(f[x][1], f[w[i].to][1]), mul(f[w[i].to][0], w[i].z));
f[x][2] = add(add(f[x][2], f[w[i].to][2]),
add(mul(w[i].z * 2 % mod, f[w[i].to][1]),
mul(mul(w[i].z, w[i].z), f[w[i].to][0])));
if (f[w[i].to][0] > f[hs[x]][0]) hs[x] = w[i].to;
}
}
void dfs2(int x, int tp) {
top[x] = tp;
if (hs[x]) dfs2(hs[x], tp);
for (int i = head[x]; i; i = w[i].next)
if (w[i].to != fa[x] && w[i].to != hs[x]) dfs2(w[i].to, w[i].to);
}
void dfs3(int x) {
for (int i = head[x]; i; i = w[i].next) {
int v = w[i].to;
if (v == fa[x]) continue;
g[v][0] = g[x][0] - f[v][0];
g[v][1] = dec(g[x][1], add(mul(f[v][0], w[i].z), f[v][1]));
g[v][2] = dec(g[x][2], add(f[v][2], add(mul(f[v][0], mul(w[i].z, w[i].z)),
mul(f[v][1], w[i].z * 2 % mod))));
g[v][2] = add(g[v][2], add(mul(mul(w[i].z, w[i].z), g[v][0]),
mul(w[i].z * 2 % mod, g[v][1])));
g[v][1] = add(g[v][1], mul(w[i].z, g[v][0]));
g[v][0] = add(g[v][0], f[v][0]);
g[v][1] = add(g[v][1], f[v][1]);
g[v][2] = add(g[v][2], f[v][2]);
dfs3(v);
}
}
inline int lca(int x, int y) {
while (top[x] != top[y]) {
if (dis[top[x]] < dis[top[y]]) swap(x, y);
x = fa[top[x]];
}
if (dis[x] < dis[y]) swap(x, y);
return y;
}
int main() {
int x, y, z;
read(n);
for (int i = 1; i < n; i++) {
read(x), read(y), read(z);
add_v(x, y, z);
add_v(y, x, z);
}
dfs1(1, 0);
dfs2(1, 1);
g[1][0] = f[1][0], g[1][1] = f[1][1], g[1][2] = f[1][2];
dfs3(1);
read(q);
while (q--) {
read(x), read(y);
int l = lca(x, y);
if (l == y) {
z = dec(deep[x], deep[y]);
ans = mul(mul(z, z), dec(g[y][0], f[y][0]));
ans = add(ans, dec(g[y][2], f[y][2]));
ans = add(ans, mul(z * 2 % mod, dec(g[y][1], f[y][1])));
ans = dec(g[x][2], ans * 2 % mod);
printf("%d\n", ans);
} else {
z = dec(add(deep[x], deep[y]), deep[l] * 2 % mod);
ans = add(mul(f[y][0], mul(z, z)), mul(f[y][1], z * 2 % mod));
ans = add(ans, f[y][2]);
ans = dec(ans * 2 % mod, g[x][2]);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
struct fur {
int a, b, i;
long long ans;
bool operator<(fur k) const { return a < k.a; }
} ans[111111];
struct Trees {
long long a, b, lazy;
} tree[1111111];
int totree[1111111], tonum[1111111], fa[1111111], lfa[1111111], treetot,
line[1111111], right[1111111], next[1111111], tail[1111111], val[1111111],
num[1111111], n, tot, q, ansstart[1111111], done[1111111], nowat;
long long inilength[1111111];
bool cmp(fur x, fur y) { return x.i < y.i; }
void dfs(int k, long long length) {
totree[k] = ++treetot;
tonum[treetot] = k;
line[++line[0]] = k;
right[k] = k;
inilength[k] = length;
for (int i = next[k]; i; i = next[i])
if (fa[k] != num[i]) {
fa[num[i]] = k;
lfa[num[i]] = val[i];
dfs(num[i], length + val[i]);
right[k] = right[num[i]];
}
line[++line[0]] = k;
}
void ini(int now, int l, int r) {
if (l == r) {
tree[now].b = inilength[tonum[l]] % 1000000007;
tree[now].a = (tree[now].b * tree[now].b % 1000000007);
return;
}
int p = (l + r) / 2;
ini(now * 2, l, p);
ini(now * 2 + 1, p + 1, r);
tree[now].a = (tree[now * 2].a + tree[now * 2 + 1].a) % 1000000007;
tree[now].b = (tree[now * 2].b + tree[now * 2 + 1].b) % 1000000007;
}
void push_lazy(int now, int num) {
if (!tree[now].lazy) return;
tree[now].lazy %= 1000000007;
tree[now * 2].lazy += tree[now].lazy;
tree[now * 2 + 1].lazy += tree[now].lazy;
tree[now].b += num * tree[now].lazy % 1000000007 + 1000000007;
tree[now].a += (tree[now].lazy * tree[now].b * 2 -
num * tree[now].lazy % 1000000007 * tree[now].lazy) %
1000000007 +
1000000007;
tree[now].a %= 1000000007;
tree[now].b %= 1000000007;
tree[now].lazy = 0;
}
void change(int now, int l, int r, int x, int y, int num) {
if (x == l && y == r) {
tree[now].lazy += num;
return;
}
int p = (l + r) / 2;
push_lazy(now, r - l + 1);
if (y <= p)
change(now * 2, l, p, x, y, num);
else if (x > p)
change(now * 2 + 1, p + 1, r, x, y, num);
else {
change(now * 2, l, p, x, p, num);
change(now * 2 + 1, p + 1, r, p + 1, y, num);
}
push_lazy(now * 2, p - l + 1);
push_lazy(now * 2 + 1, r - p);
tree[now].a = (tree[now * 2].a + tree[now * 2 + 1].a) % 1000000007;
tree[now].b = (tree[now * 2].b + tree[now * 2 + 1].b) % 1000000007;
}
long long find(int now, int l, int r, int x, int y) {
push_lazy(now, r - l + 1);
if (l == x && r == y) return tree[now].a;
int p = (l + r) / 2;
if (y <= p) return find(now * 2, l, p, x, y);
if (x > p) return find(now * 2 + 1, p + 1, r, x, y);
return (find(now * 2, l, p, x, p) + find(now * 2 + 1, p + 1, r, p + 1, y)) %
1000000007;
}
void Output() {
for (int i = 1; i <= n * 2; i++)
printf("[%3d %2d %2d %2d] ", i, tree[i].a, tree[i].b, tree[i].lazy);
printf("\n");
}
int main() {
scanf("%d", &n);
for (tot = 1; tot <= n; tot++) tail[tot] = tot;
for (int i = 1; i < n; i++) {
int t1, t2, t3;
scanf("%d%d%d", &t1, &t2, &t3);
num[tail[t1] = next[tail[t1]] = ++tot] = t2;
val[tot] = t3;
;
num[tail[t2] = next[tail[t2]] = ++tot] = t1;
val[tot] = t3;
;
}
dfs(1, 0);
ini(1, 1, n);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &ans[i].a, &ans[i].b);
ans[i].i = i;
}
std::sort(ans + 1, ans + q + 1);
for (int i = q; i >= 1; i--) ansstart[ans[i].a] = i;
done[1] = 1;
nowat = 1;
for (int i = 2; i <= line[0]; i++) {
if (done[line[i]]) {
int delta = lfa[line[i]];
change(1, 1, n, 1, n, -delta);
change(1, 1, n, totree[line[i]], totree[right[line[i]]], 2 * delta);
nowat = fa[line[i]];
} else {
int delta = lfa[line[i]];
change(1, 1, n, 1, n, delta);
change(1, 1, n, totree[line[i]], totree[right[line[i]]], -2 * delta);
nowat = line[i];
done[line[i]] = 1;
}
for (int j = ansstart[nowat]; j && ans[j].a == ans[ansstart[nowat]].a; j++)
if (!ans[j].ans) {
long long minus =
find(1, 1, n, totree[ans[j].b], totree[right[ans[j].b]]);
ans[j].ans = (minus * 2 - tree[1].a + 1000000007) % 1000000007;
}
}
std::sort(ans + 1, ans + q + 1, cmp);
for (int i = 1; i <= q; i++) printf("%I64d\n", ans[i].ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const int LOGMAXN = 18;
const int MOD = 1e+9 + 7;
struct node {
int xsum, xsqr, xcnt;
node() : xsum(0), xsqr(0), xcnt(0) {}
};
int N;
vector<pair<int, int> > V[MAXN];
int dad[MAXN][LOGMAXN];
int dep[MAXN];
int sum[MAXN];
node data[MAXN];
node str[MAXN][LOGMAXN];
inline int sqr(int x) { return ((long long)x * x) % MOD; }
inline int add(int a, int b) {
int ret = a + b;
if (ret >= MOD) ret -= MOD;
return ret;
}
inline int sub(int a, int b) {
int ret = a - b + MOD;
if (ret >= MOD) ret -= MOD;
return ret;
}
inline int mul(int a, int b) { return ((long long)a * b) % MOD; }
inline int f(int curr, int k) {
return add(mul(data[curr].xcnt, sqr(k)),
add(mul(2, mul(k, data[curr].xsum)), data[curr].xsqr));
}
namespace tr {
int depth = 0;
int curr_sum = 0;
node build(int curr, int prev = 0) {
dep[curr] = depth;
sum[curr] = curr_sum;
dad[curr][0] = prev;
for (int i = 1; i < LOGMAXN - 1; ++i)
dad[curr][i] = dad[dad[curr][i - 1]][i - 1];
node ret;
ret.xcnt = 1;
for (pair<int, int> nxt : V[curr]) {
if (nxt.first == prev) continue;
depth += 1;
curr_sum = add(curr_sum, nxt.second);
node get = build(nxt.first, curr);
ret.xcnt = add(ret.xcnt, get.xcnt);
ret.xsum = add(ret.xsum, mul(get.xcnt, nxt.second));
ret.xsum = add(ret.xsum, get.xsum);
ret.xsqr = add(ret.xsqr, mul(get.xcnt, sqr(nxt.second)));
ret.xsqr = add(ret.xsqr, get.xsqr);
ret.xsqr = add(ret.xsqr, mul(2, mul(nxt.second, get.xsum)));
curr_sum = sub(curr_sum, nxt.second);
depth -= 1;
}
return data[curr] = ret;
}
void dfs(int curr, int prev = 0) {
long long tmp = 0;
str[curr][0].xsum = sub(data[dad[curr][0]].xsum, data[curr].xsum);
str[curr][0].xsum =
sub(str[curr][0].xsum,
mul(data[curr].xcnt, sub(sum[curr], sum[dad[curr][0]])));
str[curr][0].xcnt = sub(data[dad[curr][0]].xcnt, data[curr].xcnt);
str[curr][0].xsqr =
sub(data[dad[curr][0]].xsqr, f(curr, sub(sum[curr], sum[dad[curr][0]])));
for (int i = 1; i < LOGMAXN - 1; ++i) {
str[curr][i].xcnt =
str[curr][i - 1].xcnt + str[dad[curr][i - 1]][i - 1].xcnt;
int par1 = dad[curr][i - 1];
int par2 = dad[curr][i];
int edge_val = sub(sum[dad[curr][0]], sum[dad[par1][0]]);
tmp = str[curr][i - 1].xsum + (long long)str[par1][i - 1].xsum +
(long long)edge_val * str[par1][i - 1].xcnt;
str[curr][i].xsum = (tmp % MOD + MOD) % MOD;
int dist = sub(sum[dad[curr][0]], sum[dad[par1][0]]);
str[curr][i].xsqr = add(str[curr][i - 1].xsqr, str[par1][i - 1].xsqr);
str[curr][i].xsqr =
add(str[curr][i].xsqr, mul(2, mul(str[par1][i - 1].xsum, dist)));
str[curr][i].xsqr =
add(str[curr][i].xsqr, mul(str[par1][i - 1].xcnt, sqr(dist)));
}
for (pair<int, int> nxt : V[curr]) {
if (nxt.first == prev) continue;
dfs(nxt.first, curr);
}
}
} // namespace tr
int lca(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
for (int i = 16; i >= 0; --i) {
if (dep[v] - (1 << i) < dep[u]) continue;
v = dad[v][i];
}
for (int i = 16; i >= 0; --i) {
int nu = dad[u][i];
int nv = dad[v][i];
if (nu == nv) continue;
u = nu;
v = nv;
}
if (u != v) u = dad[u][0];
return u;
}
int query(int u, int v) {
int LCA = lca(u, v);
int dist = sum[u] + sum[v] - 2 * sum[LCA];
if (LCA != v || u == v) return f(v, dist);
int ret = data[u].xsqr;
int curr = u;
for (int i = 16; i >= 0; --i) {
if (dep[curr] - (1 << i) < dep[v]) continue;
const node get = str[curr][i];
int dist = sub(sum[u], sum[dad[curr][0]]);
curr = dad[curr][i];
int tmp = add(get.xsqr, mul(sqr(dist), get.xcnt));
tmp = add(tmp, mul(2, mul(get.xsum, dist)));
ret = add(ret, tmp);
ret = (ret + MOD) % MOD;
}
return (ret % MOD + MOD) % MOD;
}
int main(void) {
scanf("%d", &N);
for (int i = 1; i < N; ++i) {
int u, v, x;
scanf("%d%d%d", &u, &v, &x);
V[u].push_back({v, x});
V[v].push_back({u, x});
}
tr::build(1);
tr::dfs(1);
int Q;
scanf("%d", &Q);
while (Q--) {
int u, v;
scanf("%d%d", &u, &v);
int LCA = lca(u, v);
int dist = sum[u] + sum[v] - 2 * sum[LCA];
printf("%d\n", (sub(mul(2, query(u, v)), query(u, 1)) % MOD + MOD) % MOD);
}
return 0;
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
using std::sort;
using std::swap;
const int maxn = 100007;
const int maxm = 200007;
const int mod = 1e9 + 7;
struct E {
int v, w;
} e[maxm];
int first[maxn], nt[maxm], ES;
inline void addE(int u, int v, int w) {
e[++ES] = (E){v, w};
nt[ES] = first[u];
first[u] = ES;
return;
}
int N, Q;
int fa[maxn], dep[maxn], sz[maxn], dfn[maxn], ix, son[maxn];
long long dis[maxn], sumd[maxn], sumd2[maxn], F[maxn][2], f[maxn][2];
void dfs(int u) {
sz[u] = 1;
dfn[u] = ++ix;
for (int v, i = first[u]; i; i = nt[i]) {
v = e[i].v;
if (v == fa[u]) continue;
dep[v] = dep[u] + 1;
dis[v] = dis[u] + e[i].w;
if (dis[v] >= mod) dis[v] -= mod;
fa[v] = u;
dfs(v);
F[u][1] =
((F[u][1] + F[v][1]) % mod + 1ll * sz[v] * e[i].w % mod * e[i].w % mod +
2ll * e[i].w * F[v][0] % mod) %
mod;
F[u][0] = (F[u][0] + F[v][0] + 1ll * sz[v] * e[i].w % mod) % mod;
sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
return;
}
int top[maxn];
void dfs(int u, int tp) {
top[u] = tp;
if (son[u]) dfs(son[u], tp);
for (int v, i = first[u]; i; i = nt[i]) {
v = e[i].v;
if (v == fa[u] || v == son[u]) continue;
dfs(v, v);
}
return;
}
int LCA(int x, int y) {
while (top[x] ^ top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
void dfs2(int u) {
long long d1, d2;
for (int v, i = first[u]; i; i = nt[i]) {
v = e[i].v;
if (v == fa[u]) continue;
f[v][0] = (f[u][0] + 1ll * (N - 2 * sz[v]) * e[i].w % mod) % mod;
d1 = (F[v][0] + 1ll * sz[v] * e[i].w % mod) % mod;
d2 = (F[v][1] + 1ll * sz[v] * e[i].w % mod * e[i].w % mod +
2ll * e[i].w * F[v][0] % mod) %
mod;
f[v][1] =
((f[u][1] - d2 + 1ll * (N - sz[v]) * e[i].w % mod * e[i].w % mod) %
mod +
(2ll * e[i].w * (f[u][0] - d1) % mod + F[v][1]) % mod) %
mod;
dfs2(v);
}
return;
}
int main() {
scanf("%d", &N);
int u, v, w;
for (int i = 1; i < N; i++)
scanf("%d%d%d", &u, &v, &w), addE(u, v, w), addE(v, u, w);
dep[1] = 1;
dfs(1);
dfs(1, 1);
f[1][1] = F[1][1];
f[1][0] = F[1][0];
dfs2(1);
for (int i = 1; i <= N; i++)
(sumd[dfn[i]] += dis[i]) %= mod,
(sumd2[dfn[i]] += dis[i] * dis[i] % mod) %= mod;
for (int i = 1; i <= N; i++)
(sumd[i] += sumd[i - 1]) %= mod, (sumd2[i] += sumd2[i - 1]) %= mod;
scanf("%d", &Q);
int lca;
long long re, sumv, sumv1, sumv2;
while (Q--) {
scanf("%d%d", &u, &v);
re = 0;
lca = LCA(u, v);
if (u == v) {
re = F[u][1];
re = 2 * re - f[u][1];
re %= mod;
if (re < 0) re += mod;
printf("%lld\n", re);
continue;
} else if (lca == v) {
sumv = N - sz[v];
sumv1 = f[v][0] - F[v][0];
sumv2 = f[v][1] - F[v][1];
w = dis[u] - dis[v];
sumv2 = (sumv2 + 2ll * w * sumv1 % mod + sumv * w % mod * w % mod) % mod;
re = f[u][1] - sumv2;
re %= mod;
if (re < 0) re += mod;
re = 2 * re - f[u][1];
re %= mod;
if (re < 0) re += mod;
printf("%lld\n", re);
continue;
}
sumv = sz[v];
sumv1 = sumd[dfn[v] + sz[v] - 1] - sumd[dfn[v] - 1];
if (sumv1 < 0) sumv1 += mod;
sumv2 = sumd2[dfn[v] + sz[v] - 1] - sumd2[dfn[v] - 1];
if (sumv2 < 0) sumv2 += mod;
re =
(sumv * dis[u] % mod * dis[u] % mod + sumv2 + 2 * dis[u] * sumv1 % mod +
4 * sumv * dis[lca] % mod * dis[lca] % mod -
4 * (sumv * dis[u] % mod + sumv1) % mod * dis[lca] % mod) %
mod;
if (re < 0) re += mod;
re = 2 * re - f[u][1];
re %= mod;
if (re < 0) re += mod;
printf("%lld\n", re);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
int n;
long long h[maxn], answer[maxn];
vector<pair<int, int> > t[maxn], query[maxn];
int Time = 0, st[maxn], ft[maxn];
struct node {
long long d1;
long long d2;
long long lazy;
node() { d1 = 0, d2 = 0, lazy = 0; }
};
node seg[4 * maxn];
void propagate(int, int, int);
int get(int id, int L, int R, int l, int r) {
if (r <= L or R <= l) return 0;
if (l <= L and R <= r) return seg[id].d2;
propagate(id, L, R);
int mid = (L + R) >> 1;
return (get(2 * id + 0, L, mid, l, r) + get(2 * id + 1, mid, R, l, r)) % mod;
}
void add(int id, int L, int R, int l, int r, long long val) {
if (r <= L or R <= l) return;
if (l <= L and R <= r) {
val %= mod;
val = (val + mod) % mod;
seg[id].d2 = (seg[id].d2 + 1ll * (R - L) * val % mod * val % mod +
2ll * val % mod * seg[id].d1 % mod) %
mod;
seg[id].d1 = (seg[id].d1 + 1ll * (R - L) * val % mod) % mod;
seg[id].lazy = (seg[id].lazy + val) % mod;
return;
}
propagate(id, L, R);
int mid = (L + R) >> 1;
add(2 * id + 0, L, mid, l, r, val);
add(2 * id + 1, mid, R, l, r, val);
seg[id].d1 = (seg[2 * id + 0].d1 + seg[2 * id + 1].d1) % mod;
seg[id].d2 = (seg[2 * id + 0].d2 + seg[2 * id + 1].d2) % mod;
}
void propagate(int id, int L, int R) {
if (seg[id].lazy == 0) return;
int mid = (L + R) >> 1;
add(2 * id + 0, L, mid, L, mid, seg[id].lazy);
add(2 * id + 1, mid, R, mid, R, seg[id].lazy);
seg[id].lazy = 0;
}
void dfs(int v, int par = -1) {
for (auto Q : query[v]) {
int idx = Q.first, u = Q.second;
answer[idx] = 2ll * get(1, 0, n, st[u], ft[u]) % mod - get(1, 0, n, 0, n);
answer[idx] = (answer[idx] + mod) % mod;
}
for (auto edge : t[v]) {
int u = edge.first, w = edge.second;
if (u != par) {
add(1, 0, n, 0, n, +w);
add(1, 0, n, st[u], ft[u], -2 * w);
dfs(u, v);
add(1, 0, n, st[u], ft[u], +2 * w);
add(1, 0, n, 0, n, -w);
}
}
}
void dfs_init(int v, int par = -1) {
st[v] = Time++;
for (auto edge : t[v]) {
int u = edge.first, w = edge.second;
if (u != par) {
h[u] = h[v] + w;
dfs_init(u, v);
}
}
ft[v] = Time;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u, w;
cin >> v >> u >> w;
v--, u--;
t[v].push_back({u, w});
t[u].push_back({v, w});
}
dfs_init(0);
for (int i = 0; i < n; i++) add(1, 0, n, st[i], st[i] + 1, h[i]);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int v, u;
cin >> v >> u;
v--, u--;
query[v].push_back({i, u});
}
dfs(0);
for (int i = 0; i < q; i++) cout << answer[i] << endl;
}
|
#include <bits/stdc++.h>
const int N = 100000 + 10, MOD = 1000000007;
int n, fa[N], dep[N], size[N], son[N], top[N], map[N], dist[N];
int adj[N], to[2 * N], next[2 * N], tag[2 * N];
void link(int a, int b, int c) {
static int cnt = 2;
to[cnt] = b;
next[cnt] = adj[a];
tag[cnt] = c;
adj[a] = cnt++;
}
int f[N];
int down[N][3], up[N][3];
inline int sqr(int x) { return (long long)x * x % MOD; }
void bfs() {
static int q[N];
q[1] = dep[1] = 1;
fa[1] = 0;
for (int f = 1, r = 1; f <= r; ++f) {
int a = q[f];
for (int i = adj[a]; i; i = next[i]) {
int b = to[i], t = tag[i];
if (b != fa[a])
fa[b] = a, dep[b] = dep[a] + 1, dist[b] = (dist[a] + t) % MOD,
q[++r] = b;
}
}
for (int i = 1; i <= n; ++i) size[i] = 1;
for (int i = n; i > 1; --i) size[fa[q[i]]] += size[q[i]];
for (int i = 2; i <= n; ++i)
if (size[i] > size[son[fa[i]]]) son[fa[i]] = i;
for (int i = 1, tot = 0; i <= n; ++i) {
int a = q[i];
if (map[a]) continue;
for (int b = a; b; b = son[b]) map[b] = ++tot, top[b] = a;
}
for (int i = n; i > 0; --i) {
int a = q[i];
down[a][0] = 1;
down[a][1] = down[a][2] = 0;
for (int j = adj[a]; j; j = next[j]) {
int b = to[j], t = tag[j];
if (b == fa[a]) continue;
down[a][2] = (down[a][2] + (long long)sqr(t) * down[b][0] +
2LL * t * down[b][1] + down[b][2]) %
MOD;
down[a][1] = (down[a][1] + down[b][1] + (long long)down[b][0] * t) % MOD;
down[a][0] += down[b][0];
}
}
for (int i = 1; i <= n; ++i) {
int a = q[i];
f[a] = (up[a][2] + down[a][2]) % MOD;
int sum[3];
memcpy(sum, up[a], sizeof sum);
for (int j = adj[a]; j; j = next[j]) {
int b = to[j], t = tag[j];
if (b == fa[a]) continue;
sum[2] = (sum[2] + (long long)sqr(t) * down[b][0] + 2LL * t * down[b][1] +
down[b][2]) %
MOD;
sum[1] = (sum[1] + down[b][1] + (long long)down[b][0] * t) % MOD;
sum[0] += down[b][0];
}
++sum[0];
for (int j = adj[a]; j; j = next[j]) {
int b = to[j], t = tag[j];
if (b == fa[a]) continue;
int cur[3];
cur[2] = (sum[2] - ((long long)sqr(t) * down[b][0] +
2LL * t * down[b][1] + down[b][2])) %
MOD;
cur[1] = (sum[1] - (down[b][1] + (long long)down[b][0] * t)) % MOD;
cur[0] = sum[0] - down[b][0];
up[b][2] = ((long long)sqr(t) * cur[0] + 2LL * t * cur[1] + cur[2]) % MOD;
up[b][1] = (cur[1] + (long long)cur[0] * t) % MOD;
up[b][0] = cur[0];
}
}
}
int lca(int a, int b) {
while (top[a] != top[b]) {
if (dep[top[a]] < dep[top[b]]) std::swap(a, b);
a = fa[top[a]];
}
return dep[a] < dep[b] ? a : b;
}
int solve(int u, int v) {
int t = lca(u, v);
if (t == v) {
int temp = (dist[u] - dist[t]) % MOD;
int res =
(((long long)sqr(temp) * up[v][0] + 2LL * temp * up[v][1] + up[v][2]) %
MOD +
MOD) %
MOD;
res = ((f[u] - res) % MOD + MOD) % MOD;
return res;
} else {
int temp = (dist[u] + dist[v] - 2LL * dist[t]) % MOD;
int res = ((long long)sqr(temp) * down[v][0] + 2LL * temp * down[v][1] +
down[v][2]) %
MOD;
return (res + MOD) % MOD;
}
}
int main() {
scanf("%d", &n);
for (int i = n - 1; i--;) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
link(a, b, c);
link(b, a, c);
}
bfs();
int q;
for (scanf("%d", &q); q--;) {
int u, v;
scanf("%d%d", &u, &v);
int a = solve(u, v), b = ((f[u] - a) % MOD + MOD) % MOD;
printf("%d\n", (a - b + MOD) % MOD);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 987654321;
const long long int INF = 123456789987654321;
const long long int mod = 1000000007;
int N;
vector<vector<pair<int, int> > > adj;
vector<vector<int> > par;
vector<int> dep, sz;
vector<long long int> dist, dsum, ddsum;
void dfs(int now, int bf) {
if (bf != -1) dep[now] = dep[bf] + 1;
if (bf != -1) par[0][now] = bf;
for (int i = 1; i < 19; i++) {
int t = par[i - 1][now];
if (t == -1) break;
par[i][now] = par[i - 1][t];
}
sz[now] = 1;
dsum[now] = dist[now];
ddsum[now] = dist[now] * dist[now] % mod;
for (int i = 0; i < adj[now].size(); i++) {
int nxt = adj[now][i].first;
int d = adj[now][i].second;
if (nxt == bf) continue;
dist[nxt] = dist[now] + (long long int)d;
dist[nxt] %= mod;
dfs(nxt, now);
sz[now] += sz[nxt];
dsum[now] += dsum[nxt];
dsum[now] %= mod;
ddsum[now] += ddsum[nxt];
ddsum[now] %= mod;
}
}
void get_tree_info() {
dep = vector<int>(N, 0);
sz = vector<int>(N, 0);
par = vector<vector<int> >(19, vector<int>(N, -1));
dist = vector<long long int>(N, 0);
dsum = vector<long long int>(N, 0);
ddsum = vector<long long int>(N, 0);
dfs(0, -1);
}
int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
int diff = dep[a] - dep[b];
for (int i = 0; i < 19; i++) {
if ((diff >> i) & 1) a = par[i][a];
}
if (a == b) return a;
for (int i = 19; i--;) {
if (par[i][a] != par[i][b]) {
a = par[i][a];
b = par[i][b];
}
}
return par[0][a];
}
vector<long long int> dp, dp2, dp3;
void dfs2(int now, int bf) {
for (int i = 0; i < adj[now].size(); i++) {
int nxt = adj[now][i].first;
int d = adj[now][i].second;
if (nxt == bf) continue;
dp[nxt] = (dp[now] - dist[now] * (long long int)sz[nxt] % mod +
dist[nxt] * (long long int)sz[nxt] % mod) %
mod;
dp[nxt] = (dp[nxt] + mod) % mod;
dp2[nxt] = (dp2[now] -
(dist[now] * dist[now] % mod) * (long long int)sz[nxt] % mod +
(dist[nxt] * dist[nxt] % mod) * (long long int)sz[nxt] % mod) %
mod;
dp2[nxt] = (dp2[nxt] + mod) % mod;
dp3[nxt] =
(dp3[now] - dist[now] * dsum[nxt] % mod + dist[nxt] * dsum[nxt] % mod) %
mod;
dp3[nxt] = (dp3[nxt] + mod) % mod;
dfs2(nxt, now);
}
}
void get_dp() {
dp = vector<long long int>(N, 0);
dp2 = vector<long long int>(N, 0);
dp3 = vector<long long int>(N, 0);
dfs2(0, -1);
}
int main() {
scanf("%d", &N);
adj.resize(N);
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(pair<int, int>(b, c));
adj[b].push_back(pair<int, int>(a, c));
}
get_tree_info();
get_dp();
int Q;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
int x = lca(u, v);
long long int t2 = ((long long int)sz[0] * dist[u] % mod) * dist[u] % mod;
t2 += ddsum[0];
t2 %= mod;
t2 += 4 * (dp2[u] - dp2[0] +
((long long int)sz[0] * dist[0] % mod) * dist[0] % mod);
t2 %= mod;
t2 += 2 * dist[u] * dsum[0] % mod;
t2 %= mod;
t2 -= 4 * dist[u] * (dp[u] - dp[0] + (long long int)sz[0] * dist[0] % mod) %
mod;
t2 %= mod;
t2 -= 4 * (dp3[u] - dp3[0] + dsum[0] * dist[0] % mod) % mod;
t2 %= mod;
t2 = (t2 + mod) % mod;
if (x == v) {
long long int t = ((long long int)sz[v] * dist[u] % mod) * dist[u] % mod;
t += ddsum[v];
t %= mod;
t += 4 * (dp2[u] - dp2[v] +
((long long int)sz[v] * dist[v] % mod) * dist[v] % mod);
t %= mod;
t += 2 * dist[u] * dsum[v] % mod;
t %= mod;
t -= 4 * dist[u] *
(dp[u] - dp[v] + (long long int)sz[v] * dist[v] % mod) % mod;
t %= mod;
t -= 4 * (dp3[u] - dp3[v] + dsum[v] * dist[v] % mod) % mod;
t %= mod;
t = (t + mod) % mod;
long long int ans = (2 * t - t2) % mod;
ans = (ans + mod) % mod;
printf("%I64d\n", ans);
} else {
long long int t = ((long long int)sz[v] * dist[u] % mod) * dist[u] % mod;
t += ddsum[v];
t %= mod;
t += (4 * (long long int)sz[v] * dist[x] % mod) * dist[x] % mod;
t %= mod;
t += 2 * dist[u] * dsum[v] % mod;
t %= mod;
t -= (4 * (long long int)sz[v] * dist[u] % mod) * dist[x] % mod;
t %= mod;
t -= 4 * dsum[v] * dist[x] % mod;
t %= mod;
t = (t + mod) % mod;
long long int ans = (2 * t - t2) % mod;
ans = (ans + mod) % mod;
printf("%I64d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
long long mo(long long x) { return x % 1000000007ll; }
struct edge {
int to, nex;
long long v;
} e[200010];
long long dsum[100010], dsum2[100010], alld[100010], alld2[100010], siz[100010],
dis[100010];
int h[100010], fa[100010][17], dep[100010], tot, n;
void add(int a, int b, long long c) {
tot++;
e[tot].to = b;
e[tot].v = c;
e[tot].nex = h[a];
h[a] = tot;
}
void dfs(int x) {
siz[x] = 1;
for (int i = h[x]; i; i = e[i].nex) {
if (e[i].to != fa[x][0]) {
dis[e[i].to] = mo(dis[x] + e[i].v);
fa[e[i].to][0] = x;
dep[e[i].to] = dep[x] + 1;
dfs(e[i].to);
siz[x] += siz[e[i].to];
dsum[x] = mo(dsum[x] + dsum[e[i].to] + siz[e[i].to] * e[i].v);
dsum2[x] = mo(dsum2[x] + mo(e[i].v * e[i].v) * siz[e[i].to] +
2ll * e[i].v * dsum[e[i].to] + dsum2[e[i].to]);
}
}
}
void dfs2(int x) {
for (int i = h[x]; i; i = e[i].nex) {
if (e[i].to != fa[x][0]) {
alld[e[i].to] = mo(alld[x] + (n - 2ll * siz[e[i].to]) * e[i].v);
alld2[e[i].to] =
mo(alld2[x] +
2ll * e[i].v *
mo(alld[x] - 2ll * dsum[e[i].to] - siz[e[i].to] * e[i].v) +
(n - 2ll * siz[e[i].to]) * mo(e[i].v * e[i].v));
dfs2(e[i].to);
}
}
}
void swap(int& a, int& b) {
int c = a;
a = b;
b = c;
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int i;
for (i = 16; i >= 0; i--) {
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
}
if (x == y) return x;
for (i = 16; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int main() {
int q, i, j, u, v, uv;
long long w;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d%I64d", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
dep[1] = 1;
dfs(1);
alld[1] = dsum[1];
alld2[1] = dsum2[1];
dfs2(1);
for (j = 1; j < 17; j++) {
for (i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
scanf("%d", &q);
while (q--) {
scanf("%d%d", &u, &v);
uv = lca(u, v);
if (uv == v) {
w = mo(dis[u] - dis[v]);
w = mo((n - siz[v]) * mo(w * w) + 2ll * w * (alld[v] - dsum[v]) +
alld2[v] - dsum2[v]);
w = mo(alld2[u] - 2ll * w);
} else {
w = mo(dis[u] + dis[v] - 2ll * dis[uv]);
w = mo(siz[v] * mo(w * w) + 2ll * w * dsum[v] + dsum2[v]);
w = mo(2ll * w - alld2[u]);
}
printf("%I64d\n", mo(w + 1000000007ll));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int S = 17;
vector<pair<int, int> > g[N];
int fa[N][S + 1], deep[N];
int dis[N];
int n, m;
struct node {
int v2, v, sum;
} f[N], h[N];
const int mod = 1e9 + 7;
int add(int x, int y) {
x += y;
return x >= mod ? x - mod : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + mod : x;
}
int mul(int x, int y) { return 1ll * x * y % mod; }
int calc(int x, int y) {
int z = 1;
while (y) {
if (y & 1) z = mul(z, x);
x = mul(x, x), y >>= 1;
}
return z;
}
node operator+(node a, node b) {
a.v2 = add(a.v2, b.v2);
a.v = add(a.v, b.v);
a.sum = add(a.sum, b.sum);
return a;
}
node operator-(node a, node b) {
a.v2 = sub(a.v2, b.v2);
a.v = sub(a.v, b.v);
a.sum = sub(a.sum, b.sum);
return a;
}
node link(node a, int x) {
a.v2 = add(a.v2, add(mul(mul(2, a.v), x), mul(a.sum, mul(x, x))));
a.v = add(a.v, mul(x, a.sum));
return a;
}
void dfs(int x) {
deep[x]++;
for (int i = 0; fa[fa[x][i]][i]; i++) fa[x][i + 1] = fa[fa[x][i]][i];
f[x].sum = 1;
for (auto u : g[x])
if (u.first != fa[x][0]) {
fa[u.first][0] = x;
deep[u.first] = deep[x];
dis[u.first] = add(dis[x], u.second);
dfs(u.first);
f[x] = f[x] + link(f[u.first], u.second);
}
}
int up(int x, int y) {
for (int i = S; i >= 0; i--)
if (y >= (1 << i)) y -= (1 << i), x = fa[x][i];
return x;
}
int getlca(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
x = up(x, deep[x] - deep[y]);
for (int i = S; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return x != y ? fa[x][0] : x;
}
void dfs(int x, node up) {
h[x] = f[x] + up;
for (auto u : g[x])
if (u.first != fa[x][0]) {
dfs(u.first, link(up + f[x] - link(f[u.first], u.second), u.second));
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
g[x].push_back({y, z});
g[y].push_back({x, z});
}
dfs(1);
dfs(1, node{0, 0, 0});
scanf("%d", &m);
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
if (x == y) {
int a = h[x].v2, b = f[x].v2;
printf("%d\n", sub(mul(b, 2), a));
} else {
int lca = getlca(x, y);
int v = sub(add(dis[x], dis[y]), mul(dis[lca], 2));
if (lca == y) {
int a = h[x].v2, b = link(h[y] - f[y], v).v2;
printf("%d\n", sub(a, mul(b, 2)));
} else {
int a = h[x].v2, b = link(f[y], v).v2;
printf("%d\n", sub(mul(b, 2), a));
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int mod = 1e9 + 7;
long long sum1[maxn], sum2[maxn], size[maxn];
int dfn[maxn], dfncnt, f[maxn][20], d[maxn][20], n, dep[maxn];
vector<int> side[maxn], w[maxn];
int trans(int u, int val) {
return (sum2[u] + size[u] * val % mod * val % mod + 2 * val * sum1[u] % mod) %
mod;
}
void dfs1(int u, int fa) {
f[u][0] = fa;
dfn[u] = ++dfncnt;
size[u] = 1;
dep[u] = dep[fa] + 1;
for (int i = 0; i < side[u].size(); i++) {
int 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 (int i = (1), iend = (19); i <= iend; i++)
for (int j = (1), jend = (n); j <= jend; j++)
f[j][i] = f[f[j][i - 1]][i - 1];
for (int i = (1), iend = (19); i <= iend; i++)
for (int j = (1), jend = (n); j <= jend; j++)
d[j][i] = (d[j][i - 1] + d[f[j][i - 1]][i - 1]) % mod;
}
int get_dis(int u, int v) {
long long ans = 0;
if (dep[u] < dep[v]) swap(u, v);
for (int 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 (int 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 {
int u, v, idx;
bool insubtree;
} q[maxn];
int ans[maxn];
bool cmp(Query a, Query b) { return dfn[a.u] < dfn[b.u]; }
int now = 1, t;
void dfs2(int u, int fa) {
while (now <= t && q[now].u == u) {
int 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 (int i = 0; i < side[u].size(); i++) {
int 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];
int tmp1 = trans(v, w[u][i]),
tmp2 = trans(u, w[u][i]) - trans(v, 2 * w[u][i] % mod);
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;
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = (1), iend = (n - 1); i <= iend; i++) {
int 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 (int 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 (int i = (1), iend = (t); i <= iend; i++) {
cout << (ans[i] % mod + mod) % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S>
inline void read(S& arg) {
cin >> arg;
}
template <class S>
inline void readA(S Lptr, S Rptr) {
while (Lptr != Rptr) {
read(*Lptr);
Lptr++;
}
}
template <class S, class... T>
inline void read(S& arg, T&... rest) {
read(arg);
read(rest...);
}
char delimiter = ' ';
template <class S>
inline void write(S arg) {
cout << arg << '\n';
}
template <class S, class... T>
inline void write(S arg, T... rest) {
cout << arg << delimiter;
write(rest...);
}
template <class S>
inline void writeA(S Lptr, S Rptr) {
while (Lptr != Rptr) {
cout << *Lptr;
Lptr++;
if (Lptr != Rptr) cout << delimiter;
}
cout << '\n';
}
template <class T, class S>
inline bool smin(T& a, S b) {
return (T)b < a ? a = b, 1 : 0;
}
template <class T, class S>
inline bool smax(T& a, S b) {
return a < (T)b ? a = b, 1 : 0;
}
constexpr long long MOD = 1e9 + 7;
constexpr long long N = 1e5 + 10;
template <typename T>
inline T mod(T& v) {
return v = (v % MOD + MOD) % MOD;
}
template <typename T>
inline long long dom(T v) {
return (v % MOD + MOD) % MOD;
}
template <typename S, typename T>
inline S add(S& l, T r) {
return mod(l += r);
}
long long po(long long v, long long u) {
return u ? po(v * v % MOD, u >> 1) * (u & 1 ? v : 1) % MOD : 1;
}
long long n, a[N], b[N], A[N], B[N], q;
long long c[N], res[N];
vector<long long> adj[N], qu[N];
long long mul[N << 2], sum[N << 2], lazy[N << 2];
void shift(long long id, long long len) {
add(mul[id], 2 * lazy[id] * sum[id] + dom(lazy[id] * lazy[id]) * len);
add(sum[id], lazy[id] * len);
if (len == 1) return lazy[id] = 0, void();
add(lazy[id << 1], lazy[id]);
add(lazy[id << 1 | 1], lazy[id]);
lazy[id] = 0;
}
void segAdd(long long s, long long t, long long val, long long l = 0,
long long r = n, long long id = 1) {
shift(id, r - l);
if (l >= t || r <= s) return;
if (l >= s && r <= t) {
add(lazy[id], val);
shift(id, r - l);
return;
}
long long mid = l + r >> 1;
segAdd(s, t, val, l, mid, id << 1);
segAdd(s, t, val, mid, r, id << 1 | 1);
mul[id] = dom(mul[id << 1] + mul[id << 1 | 1]);
sum[id] = dom(sum[id << 1] + sum[id << 1 | 1]);
}
long long segGet(long long s, long long t, long long l = 0, long long r = n,
long long id = 1) {
shift(id, r - l);
if (l >= t || r <= s) return 0;
if (l >= s && r <= t) return mul[id];
long long mid = l + r >> 1;
return dom(segGet(s, t, l, mid, id << 1) + segGet(s, t, mid, r, id << 1 | 1));
}
long long st[N], en[N], TM;
long long d[N];
void dfs1(long long v = 0, long long par = 0) {
st[v] = TM++;
for (auto e : adj[v]) {
long long u = a[e] ^ b[e] ^ v;
if (u ^ par) {
segAdd(TM, TM + 1, d[v] + c[e]);
add(d[u], d[v] + c[e]);
dfs1(u, v);
}
}
en[v] = TM;
}
void dfs2(long long v = 0, long long par = 0) {
for (auto e : qu[v]) {
long long u = B[e];
add(res[e], -segGet(0, n) + 2 * segGet(st[u], en[u]));
}
for (auto e : adj[v]) {
long long u = a[e] ^ b[e] ^ v;
if (u ^ par) {
segAdd(0, n, c[e]);
segAdd(st[u], en[u], MOD - 2 * c[e]);
dfs2(u, v);
segAdd(0, n, MOD - c[e]);
segAdd(st[u], en[u], 2 * c[e]);
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read(n);
for (long long i = 1; i < (long long)n; i++) {
read(a[i], b[i], c[i]);
a[i]--, b[i]--;
adj[a[i]].push_back(i);
adj[b[i]].push_back(i);
}
read(q);
for (long long i = 0; i < (long long)q; i++) {
read(A[i], B[i]);
A[i]--, B[i]--;
qu[A[i]].push_back(i);
}
dfs1();
dfs2();
delimiter = '\n';
writeA(res, res + q);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int father[20][300005], lv[300005], n;
long long dis[300005];
vector<int> e[300005], ev[300005];
void init(int x, int lt) {
father[0][x] = lt;
for (int i = 0; i < ((int)(e[x]).size()); ++i) {
int y = e[x][i];
if (y != lt) {
dis[y] = dis[x] + ev[x][i];
lv[y] = lv[x] + 1;
init(y, x);
}
}
}
int adv(int x, int v) {
for (int i = 0; (1 << i) <= v; i++) {
if ((v >> i) & 1) x = father[i][x];
}
return x;
}
int lca(int x, int y) {
if (lv[x] > lv[y])
x = adv(x, lv[x] - lv[y]);
else
y = adv(y, lv[y] - lv[x]);
if (x == y) return x;
for (int i = 19; i >= 0; i--)
if (father[i][x] != father[i][y]) {
x = father[i][x];
y = father[i][y];
}
return father[0][x];
}
void build() {
init(1, 1);
for (int i = (1); i < (20); ++i) {
for (int x = (1); x < (n + 1); ++x)
father[i][x] = father[i - 1][father[i - 1][x]];
}
}
int num[300005], sum[300005], sum2[300005], all_sum[300005], all_sum2[300005];
void add(int &x, long long v) { x = (x + v) % 1000000007; }
void dfs0(int x, int lt) {
num[x] = 1;
for (int i = 0; i < ((int)(e[x]).size()); ++i) {
int y = e[x][i];
if (y == lt) continue;
dfs0(y, x);
num[x] += num[y];
sum[x] = (sum[x] + sum[y] + (long long)num[y] * ev[x][i]) % 1000000007;
sum2[x] = (sum2[x] + sum2[y] + (long long)sum[y] * 2 * ev[x][i] +
(long long)ev[x][i] * ev[x][i] % 1000000007 * num[y]) %
1000000007;
}
}
void dfs1(int x, int lt, long long v1, long long v2) {
v1 %= 1000000007;
v2 %= 1000000007;
if (v1 < 0) v1 += 1000000007;
if (v2 < 0) v2 += 1000000007;
all_sum[x] = sum[x];
all_sum2[x] = sum2[x];
add(all_sum[x], v1);
add(all_sum2[x], v2);
for (int i = 0; i < ((int)(e[x]).size()); ++i) {
int y = e[x][i];
if (y == lt) continue;
dfs1(y, x,
v1 + (long long)(n - num[y]) * ev[x][i] % 1000000007 + sum[x] -
sum[y] - (long long)num[y] * ev[x][i] % 1000000007,
all_sum2[x] - sum2[y] - sum[y] * 2LL * ev[x][i] % 1000000007 -
(long long)ev[x][i] * ev[x][i] % 1000000007 * num[y] +
(long long)(n - num[y]) * ev[x][i] % 1000000007 * ev[x][i] %
1000000007 +
2LL * ev[x][i] *
(v1 + sum[x] - sum[y] -
(long long)num[y] * ev[x][i] % 1000000007) %
1000000007);
}
}
int main() {
scanf("%d", &n);
for (int i = (1); i < (n); ++i) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
e[x].push_back(y);
ev[x].push_back(v);
e[y].push_back(x);
ev[y].push_back(v);
}
build();
dfs0(1, 1);
dfs1(1, 1, 0, 0);
int Q;
scanf("%d", &Q);
while (Q--) {
int u, v;
scanf("%d%d", &u, &v);
int me = lca(u, v);
int an = 0;
long long dd = dis[u] + dis[v] - 2 * dis[me];
dd %= 1000000007;
if (me != v) {
an = -all_sum2[u] % 1000000007;
add(an, (sum2[v] + dd * dd % 1000000007 * num[v] % 1000000007 +
dd * 2LL * sum[v] % 1000000007) *
2);
} else {
an = all_sum2[u];
add(an, (all_sum2[v] - sum2[v] +
dd * dd % 1000000007 * (n - num[v]) % 1000000007 +
dd * 2LL * (all_sum[v] - sum[v]) % 1000000007) *
-2);
}
if (an < 0) an += 1000000007;
printf("%d\n", an);
}
}
|
#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];
int sz[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);
sz[x] = 1;
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]));
sz[x] += sz[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;
struct node {
long long t, d, g, h, s, ds, dq, dis, sum;
} A[100100];
int p[100100], nxt[2 * 100100], C[2 * 100100], V[2 * 100100], f[100100],
g[100100][19], n, q, i, ed;
int gi() {
int s = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') s = s * 10 + c - '0', c = getchar();
return s;
}
void Add(int u, int v, int c) {
V[++ed] = v, C[ed] = c, nxt[ed] = p[u], p[u] = ed;
}
long long sqr(long long x) { return (x * x) % 1000000007; };
long long Mul(long long x, long long y) {
return ((x % 1000000007) * y) % 1000000007;
}
void Dfs(int x, int fa) {
f[x] = fa, A[x].s = 1, A[x].t = A[f[x]].t + 1;
for (int i = p[x]; i != -1; i = nxt[i]) {
int v = V[i];
if (v == fa) continue;
A[v].d = (A[x].d + C[i]) % 1000000007;
A[v].g = (A[x].g + A[v].d) % 1000000007;
A[v].h = (A[x].h + sqr(A[v].d)) % 1000000007;
Dfs(v, x);
A[x].s = (A[x].s + A[v].s) % 1000000007;
A[x].ds = (A[x].ds + A[v].ds + A[v].s * C[i]) % 1000000007;
A[x].dq = (A[x].dq + A[v].dq + Mul(A[v].s, sqr(C[i])) +
2LL * Mul(A[v].ds, C[i])) %
1000000007;
}
}
void Calc(int x, long long c) {
A[x].dis = (A[f[x]].dis - Mul(A[x].s, c) + Mul((n - A[x].s), c)) % 1000000007;
A[x].sum = (A[f[x]].sum + Mul(n, sqr(c))) % 1000000007;
A[x].sum = (A[x].sum - 2LL * Mul(A[x].ds + Mul(A[x].s, c), c)) % 1000000007;
A[x].sum =
(A[x].sum + 2LL * Mul(A[x].dis - A[x].ds - Mul(n - A[x].s, c), c)) %
1000000007;
for (int i = p[x]; i != -1; i = nxt[i])
if (V[i] != f[x]) Calc(V[i], C[i]);
}
int Lca(int u, int v) {
if (A[u].t < A[v].t) swap(u, v);
for (int i = 18; i >= 0; i--)
if (A[g[u][i]].t >= A[v].t) u = g[u][i];
if (u == v) return u;
for (int i = 18; i >= 0; i--)
if (g[u][i] != g[v][i]) u = g[u][i], v = g[v][i];
return f[u];
}
int find(int u) {
for (int i = 18; i >= 0; i--)
if (A[g[u][i]].t >= 2) u = g[u][i];
return u;
}
int main() {
memset(p, -1, sizeof(p));
scanf("%d", &n);
for (i = 1; i < n; i++) {
int u = gi(), v = gi(), c = gi();
Add(u, v, c), Add(v, u, c);
}
Dfs(1, 0);
for (i = 1; i <= n; i++) g[i][0] = f[i];
for (i = 1; i <= 17; i++)
for (int j = 1; j <= n; j++) g[j][i] = g[g[j][i - 1]][i - 1];
for (i = 1; i <= n; i++) A[1].sum += sqr(A[i].d), A[1].dis += A[i].d;
A[1].sum %= 1000000007, A[1].dis %= 1000000007;
for (i = p[1]; i != -1; i = nxt[i]) Calc(V[i], C[i]);
scanf("%d", &q);
for (i = 1; i <= q; i++) {
int u = gi(), v = gi();
int z = Lca(u, v);
long long ans, o, h, b;
if (z == v && u != v) {
o = (A[v].d - A[f[v]].d) % 1000000007;
b = (A[u].d - A[f[v]].d) % 1000000007;
h = (A[f[v]].dis - A[v].ds - Mul(o, A[v].s)) % 1000000007;
ans = (A[f[v]].sum - A[v].dq - Mul(A[v].s, sqr(o)) -
2LL * Mul(A[v].ds, o)) %
1000000007;
ans = (ans + Mul(n - A[v].s, sqr(b)) + 2LL * Mul(h, b)) % 1000000007;
ans = (A[u].sum - 2 * ans) % 1000000007;
if (v == 1) ans = A[u].sum;
} else {
long long det = (A[u].d + A[v].d - 2LL * A[z].d) % 1000000007;
ans = (A[v].dq + Mul(A[v].s, sqr(det))) % 1000000007;
o = (2LL * Mul(A[v].ds, det)) % 1000000007;
ans = (2LL * (ans + o) - A[u].sum) % 1000000007;
}
printf("%I64d\n", (1000000007 + ans) % 1000000007);
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
long long tot[100010];
int sz[100010], p[100010][20], d[100010], a[100010], b[100010], f[100010],
h[100010], l[100010], aa[100010], bb[100010];
vector<pair<int, int> > g[100010];
void dfs(int u, int fa, int w = 0) {
sz[u] = 1;
p[u][0] = fa;
d[u] = (d[fa] + w) % 1000000007;
l[u] = l[fa] + 1;
for (int i = 0; i < g[u].size(); i++) {
int j = g[u][i].first, w = g[u][i].second;
if (j == fa) continue;
dfs(j, u, w);
sz[u] += sz[j];
long long v = (a[j] + 1LL * sz[j] * w % 1000000007 * w % 1000000007 +
1LL * w * b[j] % 1000000007 * 2) %
1000000007;
a[u] = (a[u] + v) % 1000000007;
f[j] = v;
v = b[j] + 1LL * sz[j] * w % 1000000007;
v %= 1000000007;
b[u] = (b[u] + v) % 1000000007;
h[j] = v;
}
}
void go(int u, int fa, int w = 0, int first = 0, int second = 0) {
if (u > 1) {
first = (a[fa] - f[u] + first) % 1000000007;
if (first < 0) first += 1000000007;
second = (b[fa] - h[u] + second) % 1000000007;
if (second < 0) second += 1000000007;
tot[u] = (first + 1LL * (sz[1] - sz[u]) * w % 1000000007 * w % 1000000007 +
1LL * w * second % 1000000007 * 2) %
1000000007;
first = tot[u];
second = (second + 1LL * (sz[1] - sz[u]) * w % 1000000007) % 1000000007;
tot[u] = (tot[u] + a[u]) % 1000000007;
aa[u] = first, bb[u] = second;
} else
tot[1] = a[1];
for (int i = 0; i < g[u].size(); i++) {
int j = g[u][i].first, w = g[u][i].second;
if (j == fa) continue;
go(j, u, w, first, second);
}
}
int lca(int a, int b) {
if (l[a] < l[b]) swap(a, b);
int h = l[a] - l[b];
for (int i = 0; i < 18; i++)
if (h >> i & 1) a = p[a][i];
if (a == b) return a;
for (int i = 17; i >= 0; i--)
if (p[a][i] != p[b][i]) a = p[a][i], b = p[b][i];
return p[a][0];
}
int main() {
int T, i, j, m, n, ca = 0, k, now = 0;
scanf("%d", &n);
for (i = 1; i < n; i++) {
int w;
scanf("%d%d%d", &j, &k, &w);
g[j].push_back(make_pair(k, w));
g[k].push_back(make_pair(j, w));
}
dfs(1, 0);
go(1, 0);
for (i = 1; i < 19; i++)
for (j = 1; j <= n; j++) p[j][i] = p[p[j][i - 1]][i - 1];
scanf("%d", &m);
while (m--) {
int u, v, t = 1;
scanf("%d%d", &u, &v);
int fa = lca(u, v);
long long ans = 0;
if (v == fa) {
long long w = d[u] - d[v], first = aa[v], second = bb[v],
z = sz[1] - sz[v];
if (w < 0) w += 1000000007;
ans = first + z * w % 1000000007 * w % 1000000007 +
w * second % 1000000007 * 2;
ans %= 1000000007;
t = -1;
} else {
long long w = d[u] - d[fa] + d[v] - d[fa], first = a[v], second = b[v],
z = sz[v];
w %= 1000000007;
if (w < 0) w += 1000000007;
ans = first + z * w % 1000000007 * w % 1000000007 +
w * second % 1000000007 * 2;
ans %= 1000000007;
}
if (ans < 0) ans += 1000000007;
ans = 2LL * ans - tot[u];
ans *= t;
ans %= 1000000007;
if (ans < 0) ans += 1000000007;
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 23, D = 1000 * 1000 * 1000 + 7, MXLN = 17 + 3;
int mul() { return 1; }
template <typename... T>
int mul(int x, T... a) {
return 1ll * x * mul(a...) % D;
}
int add() { return 0; }
template <typename... T>
int add(int x, T... a) {
return (x + add(a...)) % D;
}
int n, e[MAXN], w[MAXN], sum[MAXN], sum2[MAXN], up[MAXN], up2[MAXN], sz[MAXN],
h[MAXN], par[MXLN][MAXN], dis[MAXN], q;
vector<int> g[MAXN];
void dfs(int v = 0, int p = -1) {
for (auto i : g[v]) {
int u = v ^ e[i];
if (u == p) continue;
h[u] = h[v] + 1;
dis[u] = add(dis[v], w[i]);
par[0][u] = v;
dfs(u, v);
sz[v] += sz[u];
sum[v] = add(sum[v], sum[u], mul(sz[u], w[i]));
sum2[v] =
add(sum2[v], mul(w[i], w[i], sz[u]), sum2[u], mul(2, w[i], sum[u]));
}
sz[v]++;
}
void ufs(int v = 0, int p = -1) {
int tmp = up[v], tmp2 = up2[v];
for (auto i : g[v]) {
int u = v ^ e[i];
if (u == p) continue;
tmp = add(tmp, sum[u], mul(sz[u], w[i]));
tmp2 = add(tmp2, mul(w[i], w[i], sz[u]), sum2[u], mul(2, w[i], sum[u]));
}
for (auto i : g[v]) {
int u = v ^ e[i];
if (u == p) continue;
up[u] = add(tmp, D - sum[u], D - mul(sz[u], w[i]), mul(w[i], (n - sz[u])));
up2[u] = add(tmp2, D - mul(w[i], w[i], sz[u]), D - sum2[u],
D - mul(2, w[i], sum[u]), mul(w[i], w[i], n - sz[u]),
mul(2, w[i], add(tmp, D - sum[u], D - mul(sz[u], w[i]))));
ufs(u, v);
}
}
int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int i = MXLN - 1; ~i; i--)
if (h[par[i][u]] >= h[v]) u = par[i][u];
if (u == v) return v;
for (int i = MXLN - 1; ~i; i--)
if (par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
return par[0][v];
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
g[--a].push_back(i), g[--b].push_back(i);
e[i] = a ^ b;
w[i] = c;
}
dfs(), ufs();
for (int i = 1; i < MXLN; i++)
for (int j = 0; j < n; j++) par[i][j] = par[i - 1][par[i - 1][j]];
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
int x = lca(--u, --v);
if (x == v) {
int fas = add(dis[u], D - dis[v]),
tmp = D - add(up2[v], mul(fas, fas, (n - sz[v])), mul(2, fas, up[v]));
cout << add(sum2[u], up2[u], tmp, tmp) << '\n';
} else {
int fas = ((x == u) ? add(dis[v], D - dis[u])
: add(dis[u], dis[v], D - dis[x], D - dis[x])),
tmp = add(mul(fas, fas, sz[v]), sum2[v], mul(2, fas, sum[v]));
cout << add(tmp, D - sum2[u], D - up2[u], tmp) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 100500;
const int mod = 1000000007;
const int maxn = 100500;
int add(int x, int y) { return (x + y) % mod; }
int add(int x, int y, int z) { return add(x, add(y, z)); }
int mul(int x, int y) { return (long long)x * y % mod; }
int sub(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
int n;
vector<pair<int, int> > e[maxn];
int p[maxn][20], wp[maxn], h[maxn], H[maxn];
int cd[maxn], cu[maxn], sd[maxn], su[maxn], sd2[maxn], su2[maxn];
int tin[maxn], tout[maxn], dtime;
inline bool anc(int u, int v) { return tin[u] <= tin[v] && tout[u] >= tout[v]; }
int getr1(int u, int w) { return add(sd[u], mul(w, add(cd[u], 1))); }
int getr2(int u, int w) {
return add(sd2[u], mul(2, mul(w, sd[u])), mul(cd[u] + 1, mul(w, w)));
}
void buildlca() {
for (int k = 0; k < (int)(20); ++k)
if (k) {
for (int i = 0; i < (int)(n); ++i) p[i][k] = p[p[i][k - 1]][k - 1];
}
}
int lca(int u, int v) {
if (H[u] < H[v]) swap(u, v);
for (int k = 0; k < (int)(20); ++k)
if ((H[u] - H[v]) & (1 << k)) {
u = p[u][k];
}
assert(H[u] == H[v]);
if (u == v) return u;
for (int k = (int)(20) - 1; k >= 0; --k) {
if (p[u][k] != p[v][k]) {
u = p[u][k];
v = p[v][k];
}
}
return p[v][0];
}
int dist(int u, int v) {
int l = lca(u, v);
return sub(add(h[u], h[v]), mul(2, h[l]));
}
void dfs1(int v, int anc) {
tin[v] = dtime++;
for (auto X : e[v]) {
int u = X.first, w = X.second;
if (u == anc) continue;
wp[u] = w;
h[u] = add(h[v], w);
H[u] = H[v] + 1;
p[u][0] = v;
dfs1(u, v);
cd[v] += cd[u] + 1;
sd[v] = add(sd[v], getr1(u, w));
sd2[v] = add(sd2[v], getr2(u, w));
}
cu[v] = n - cd[v] - 1;
tout[v] = dtime++;
}
void dfs2(int v, int anc) {
int u = anc;
int w = wp[v];
if (v != 0) {
int c = cu[u] + cd[u] - (cd[v] + 1);
int s = sub(add(su[u], sd[u]), getr1(v, w));
int s2 = sub(add(su2[u], sd2[u]), getr2(v, w));
su[v] = add(s, mul(w, add(c, 1)));
su2[v] = add(s2, mul(2, mul(w, s)), mul(c + 1, mul(w, w)));
}
for (auto X : e[v]) {
int u = X.first;
if (u != anc) {
dfs2(u, v);
}
}
}
void scan() {
scanf("%d", &n);
for (int i = 0; i < (int)(n - 1); ++i) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
e[--u].push_back(make_pair(--v, c));
e[v].push_back(make_pair(u, c));
}
}
int query(int u, int v) {
int res = add(sd2[u], su2[u]);
if (anc(v, u)) {
int W = sub(h[u], h[v]);
int C = cu[v];
int S = su[v];
int S2 = su2[v];
int radd = add(S2, mul(2, mul(S, W)), mul(C, mul(W, W)));
return sub(res, mul(2, radd));
} else {
int W = dist(u, v);
int C = cd[v] + 1;
int S = sd[v];
int S2 = sd2[v];
int radd = add(S2, mul(2, mul(S, W)), mul(C, mul(W, W)));
return sub(mul(2, radd), res);
}
}
void gen_tree(int n) {
::n = n;
for (int i = (int)(1); i <= (int)(n - 1); ++i) {
int j = rand() % i;
int c = rand() % 10 + 1;
e[j].push_back(make_pair(i, c));
e[i].push_back(make_pair(j, c));
}
}
void dfs(int v, int anc, int cd, vector<int>& a) {
a.push_back(cd);
for (int i = 0; i < (int)(e[v].size()); ++i)
if (anc != e[v][i].first) {
dfs(e[v][i].first, v, cd + e[v][i].second, a);
}
}
void solved() {
dfs1(0, -1);
dfs2(0, -1);
for (int i = 0; i < (int)(n); ++i) {
vector<int> a;
dfs(i, -1, 0, a);
int s = 0;
for (auto x : a) s += x * x;
if (s != sd2[i] + su2[i]) {
cout << "fail" << endl;
for (int v = 0; v < (int)(n); ++v) {
for (auto to : e[v]) cout << to.first << " ";
cout << endl;
}
exit(0);
} else {
cout << s << " " << sd2[i] << " " << su2[i] << endl;
}
}
}
void solve() {
dfs1(0, -1);
dfs2(0, -1);
buildlca();
int q;
scanf("%d", &q);
for (int i = 0; i < (int)(q); ++i) {
int u, v;
scanf("%d%d", &u, &v);
printf("%d\n", query(u - 1, v - 1));
}
}
int main() {
scan();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100010;
const int MOD = 1000000007;
struct Node {
int v;
long long c;
Node *nxt;
} pool[MaxN << 1], *tail = pool, *g[MaxN];
struct Pack {
long long s, s2, cnt;
Pack() {}
Pack(long long _s, long long _s2, long long _cnt)
: s(_s), s2(_s2), cnt(_cnt) {}
Pack operator*(long long t) {
t %= MOD;
return Pack(s + cnt * t % MOD,
(s2 + 2 * s * t % MOD + cnt * t % MOD * t) % MOD, cnt);
}
Pack operator+(const Pack &t) {
return Pack((s + t.s) % MOD, (s2 + t.s2) % MOD, cnt + t.cnt);
}
Pack operator-(const Pack &t) {
return Pack((s - t.s) % MOD, (s2 - t.s2) % MOD, cnt - t.cnt);
}
Pack operator+=(const Pack &t) { return *this = *this + t; }
Pack operator-=(const Pack &t) { return *this = *this - t; }
} d[MaxN], up[MaxN];
int n, q;
int h[MaxN];
long long len[MaxN];
int fa[20][MaxN];
void dfs(int u) {
d[u].cnt = 1;
for (Node *p = g[u]; p; p = p->nxt)
if (p->v != fa[0][u])
fa[0][p->v] = u, h[p->v] = h[u] + 1, len[p->v] = len[u] + p->c, dfs(p->v),
d[u] += d[p->v] * p->c;
}
void dfs2(int u) {
for (Node *p = g[u]; p; p = p->nxt)
if (p->v != fa[0][u])
up[p->v] = (d[u] - d[p->v] * p->c + up[u]) * p->c, dfs2(p->v);
}
int lca(int u, int v) {
if (h[u] < h[v]) u ^= v ^= u ^= v;
for (int i = 19; i >= 0; i--)
if (h[fa[i][u]] >= h[v]) u = fa[i][u];
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (fa[i][u] != fa[i][v]) u = fa[i][u], v = fa[i][v];
return fa[0][u];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
tail->v = v;
tail->c = c;
tail->nxt = g[u];
g[u] = tail++;
tail->v = u;
tail->c = c;
tail->nxt = g[v];
g[v] = tail++;
}
h[1] = 1;
dfs(1);
dfs2(1);
for (int i = 1; i < 20; i++)
for (int j = 1; j <= n; j++) fa[i][j] = fa[i - 1][fa[i - 1][j]];
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int u, v;
scanf("%d%d", &u, &v);
int w = lca(u, v);
long long tl = len[u] + len[v] - len[w] * 2;
Pack s1 = up[u] + d[u], s2 = w == v ? d[u] + up[u] - up[v] * tl : d[v] * tl;
printf("%I64d\n", ((s2.s2 * 2 - s1.s2) % MOD + MOD) % MOD);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007;
int n, a[200009], b[200009], c[200009], used[100009], cnt[100009], s1[100009],
s1c[100009], s2[100009], s2c[100009], par[19][100009];
int val[19][100009], q, dep[100009];
vector<int> adj[100009];
inline void Dfs1(int x) {
used[x] = 1;
cnt[x] = 1;
for (int i = 0; i < adj[x].size(); i++) {
int id = adj[x][i];
if (!used[b[id]]) {
par[0][b[id]] = x;
val[0][b[id]] = c[id];
dep[b[id]] = dep[x] + 1;
Dfs1(b[id]);
cnt[x] += cnt[b[id]];
s1c[x] = (s1c[x] + s1c[b[id]] + (long long)c[id] * cnt[b[id]]) % md;
s2c[x] =
(s2c[x] + s2c[b[id]] + (long long)c[id] * c[id] % md * cnt[b[id]] +
2ll * c[id] * s1c[b[id]]) %
md;
}
}
used[x] = 0;
}
inline void Dfs2(int x) {
used[x] = 1;
for (int i = 0; i < adj[x].size(); i++) {
int id = adj[x][i];
if (!used[b[id]]) {
int tmpcnt = n - cnt[b[id]];
int tmp1 = (s1[x] - s1c[b[id]] - (long long)c[id] * cnt[b[id]]) % md;
int tmp2 =
(s2[x] - s2c[b[id]] - (long long)c[id] * c[id] % md * cnt[b[id]] -
2ll * c[id] * s1c[b[id]]) %
md;
s1[b[id]] = (s1c[b[id]] + tmp1 + (long long)c[id] * tmpcnt) % md;
s2[b[id]] = (s2c[b[id]] + tmp2 + (long long)c[id] * c[id] % md * tmpcnt +
2ll * c[id] * tmp1) %
md;
Dfs2(b[id]);
}
}
used[x] = 0;
}
pair<int, int> Lca(int x, int y) {
if (dep[x] < dep[y]) {
swap(x, y);
}
int sum = 0;
for (int i = 17; i >= 0; i--) {
if (dep[par[i][x]] >= dep[y]) {
sum = (sum + val[i][x]) % md;
x = par[i][x];
}
}
if (x == y) {
return make_pair(x, sum);
}
for (int i = 17; i >= 0; i--) {
if (par[i][x] != par[i][y]) {
sum = (sum + val[i][x]) % md;
sum = (sum + val[i][y]) % md;
x = par[i][x];
y = par[i][y];
}
}
sum = (sum + val[0][x]) % md;
sum = (sum + val[0][y]) % md;
return make_pair(par[0][x], sum);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i + n - 1] = b[i];
b[i + n - 1] = a[i];
c[i + n - 1] = c[i];
adj[a[i]].push_back(i);
adj[b[i]].push_back(i + n - 1);
}
dep[1] = 1;
Dfs1(1);
s1[1] = s1c[1];
s2[1] = s2c[1];
Dfs2(1);
for (int i = 1; i <= 17; i++) {
for (int j = 1; j <= n; j++) {
par[i][j] = par[i - 1][par[i - 1][j]];
val[i][j] = (val[i - 1][j] + val[i - 1][par[i - 1][j]]) % md;
}
}
cin >> q;
for (int iQ = 1; iQ <= q; iQ++) {
int x, y;
cin >> x >> y;
pair<int, int> l = Lca(x, y);
if (l.first == y) {
cout << ((s2[x] - 2ll * l.second * l.second % md * (n - cnt[y]) -
2ll * (s2[y] - s2c[y]) - 4ll * l.second * (s1[y] - s1c[y])) %
md +
md) %
md
<< "\n";
} else {
cout << ((-s2[x] + 2ll * l.second * l.second % md * cnt[y] +
2ll * s2c[y] + 4ll * l.second * s1c[y]) %
md +
md) %
md
<< "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void chkmin(T &x, T y) {
if (x > y) x = y;
}
inline int read() {
int x = 0;
char c = getchar();
bool f = 0;
while (c < 48) f |= c == '-', c = getchar();
while (c > 47) x = x * 10 + (c ^ 48), c = getchar();
return f ? -x : x;
}
const int maxn = 1e5 + 10, P = 1e9 + 7;
int Inc(int x, int y) { return x + y < P ? x + y : x + y - P; }
int Dec(int x, int y) { return x < y ? x - y + P : x - y; }
void Add(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
void Sub(int &x, int y) {
x -= y;
if (x < 0) x += P;
}
int qp(int a, int k) {
int res = 1;
for (; k; k >>= 1, a = 1ll * a * a % P)
if (k & 1) res = 1ll * res * a % P;
return res;
}
int n, q;
int ecnt = 1, h[maxn];
struct edges {
int nxt, to, w;
} E[maxn << 1];
void addline(int u, int v, int w) { E[++ecnt] = {h[u], v, w}, h[u] = ecnt; }
int sum1[maxn], sum2[maxn];
int fa[maxn], sz[maxn], dep[maxn], son[maxn], top[maxn], dis[maxn], dfn[maxn];
void dfs1(int u, int f) {
fa[u] = f, sz[u] = 1, dep[u] = dep[f] + 1;
for (int i = h[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (v != f) {
dis[v] = Inc(dis[u], E[i].w), dfs1(v, u);
if (sz[son[u]] < sz[v]) son[u] = v;
sz[u] += sz[v], Add(sum1[u], (sum1[v] + 1ll * sz[v] * E[i].w) % P),
Add(sum2[u], (sum2[v] + 2ll * sum1[v] * E[i].w % P +
1ll * E[i].w * E[i].w % P * sz[v] % P) %
P);
}
}
}
int dp1[maxn], dp2[maxn];
void dfs2(int u, int tp) {
for (int i = h[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (v != fa[u]) {
dp1[v] = (dp1[u] + 1ll * E[i].w * (n - sz[v] * 2 + P) % P) % P;
dp2[v] = (dp2[u] -
(1ll * E[i].w * E[i].w % P * sz[v] % P +
2ll * E[i].w * sum1[v] % P) %
P +
1ll * E[i].w * E[i].w % P * (n - sz[v]) % P +
2ll * E[i].w % P *
(dp1[u] - sum1[v] - 1ll * E[i].w * sz[v] % P + P + P) % P) %
P;
}
}
static int now;
dfn[u] = ++now, top[u] = tp;
if (son[u]) dfs2(son[u], tp);
for (int i = h[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (v != fa[u] && v != son[u]) dfs2(v, v);
}
}
int qlca(int u, int 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;
}
struct ZZH {
int c[maxn];
void ins(int u, int x) { Add(c[dfn[u]], x), Sub(c[dfn[u] + sz[u]], x); }
void build() {
for (int i = (2), iend = (n + 1); i <= iend; ++i) Add(c[i], c[i - 1]);
}
int query(int u, int v) { return Dec(c[dfn[u]], c[dfn[v]]); }
} B1_sz, B2_sz, B1_s1, B2_s1, B1_y, B2_y, B_w;
void solve() {
cin >> n;
for (int i = (2), iend = (n); i <= iend; ++i) {
int u = read(), v = read(), w = read();
addline(u, v, w), addline(v, u, w);
}
dfs1(1, 0), dp1[1] = sum1[1], dp2[1] = sum2[1], dfs2(1, 1);
for (int i = (2), iend = (n); i <= iend; ++i) {
B1_sz.ins(i, 1ll * dis[fa[i]] * (sz[fa[i]] - sz[i]) % P);
B2_sz.ins(i, 1ll * dis[fa[i]] * dis[fa[i]] % P * (sz[fa[i]] - sz[i]) % P);
int w = Dec(dis[i], dis[fa[i]]);
B_w.ins(i, (1ll * w * w % P * sz[i] % P + 2ll * w * sum1[i] % P) % P);
int tp = (sum1[fa[i]] - sum1[i] - 1ll * w * sz[i] % P + P + P) % P;
B1_y.ins(i, tp);
B2_y.ins(i, 1ll * dis[fa[i]] * tp % P);
}
for (int i = (1), iend = (n); i <= iend; ++i) {
B1_s1.ins(i, sum1[i]);
B2_s1.ins(i, 1ll * dis[i] * sum1[i] % P);
}
B1_sz.build(), B2_sz.build(), B_w.build();
B1_s1.build(), B2_s1.build(), B1_y.build(), B2_y.build();
cin >> q;
while (q--) {
int u = read(), v = read(), res = 0;
if (dfn[u] < dfn[v] || dfn[u] >= dfn[v] + sz[v]) {
int l = (dis[u] + dis[v] - 2ll * dis[qlca(u, v)] % P + P) % P;
res = (1ll * l * l % P * sz[v] % P + 2ll * l * sum1[v] % P + sum2[v]) % P;
} else {
res = (sum2[v] + 1ll * dis[u] * dis[u] % P * (sz[v] - sz[u]) % P) % P;
res =
(res + B2_sz.query(u, v) - 2ll * dis[u] * B1_sz.query(u, v) % P + P) %
P;
res = (res - B_w.query(u, v) + P) % P;
res =
(res +
2ll * (1ll * dis[u] * B1_y.query(u, v) % P - B2_y.query(u, v) + P) %
P +
P) %
P;
}
res = (res * 2ll - dp2[u] + P) % P;
printf("%d\n", res);
}
}
signed main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int mod = 1e9 + 7;
long long mark[N], st[N], ft[N], lzy[4 * N], ans[N], n, t;
pair<long long, long long> seg[4 * N];
vector<pair<long long, long long> > adj[N], qry[N];
void add(int id, int l, int r, long long x) {
seg[id].first = (seg[id].first + 2LL * seg[id].second * x +
(x * x) % mod * 1LL * (r - l)) %
mod;
seg[id].second = (seg[id].second + x * (r - l)) % mod;
lzy[id] = (lzy[id] + x) % mod;
}
void shift(int id, int l, int r) {
int md = (l + r) >> 1;
add(id << 1, l, md, lzy[id]);
add(id << 1 | 1, md, r, lzy[id]);
lzy[id] = 0;
}
void upd(int l, int r, long long x, int s = 0, int e = n, int id = 1) {
if (e <= l || r <= s) return;
if (l <= s && e <= r) {
add(id, s, e, x);
return;
}
shift(id, s, e);
int md = (s + e) >> 1;
upd(l, r, x, s, md, id << 1);
upd(l, r, x, md, e, id << 1 | 1);
seg[id].first = (seg[id << 1].first + seg[id << 1 | 1].first) % mod;
seg[id].second = (seg[id << 1].second + seg[id << 1 | 1].second) % mod;
}
long long get(int l, int r, int s = 0, int e = n, int id = 1) {
if (e <= l || r <= s) return 0;
if (l <= s && e <= r) return seg[id].first;
shift(id, s, e);
int md = (s + e) >> 1;
return (get(l, r, s, md, id << 1) + get(l, r, md, e, id << 1 | 1)) % mod;
}
void preDFS(int v, long long d = 0) {
mark[v] = 1;
st[v] = t++;
upd(st[v], st[v] + 1, d % mod);
for (pair<long long, long long> e : adj[v])
if (!mark[e.first]) preDFS(e.first, d + e.second);
ft[v] = t;
}
void DFS(int v) {
mark[v] = 1;
for (pair<long long, long long> p : qry[v]) {
int u = p.first, id = p.second;
ans[id] = (2LL * get(st[u], ft[u]) - seg[1].first) % mod;
}
for (pair<long long, long long> e : adj[v]) {
int u = e.first, w = e.second;
if (mark[u]) continue;
upd(0, n, w);
upd(st[u], ft[u], -2 * w);
DFS(u);
upd(st[u], ft[u], 2 * w);
upd(0, n, -w);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
qry[u].push_back(make_pair(v, i));
}
preDFS(1);
memset(mark, 0, sizeof mark);
DFS(1);
for (int i = 0; i < q; i++) cout << (ans[i] + mod) % mod << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const long double EPS = 1e-12;
const int INF = 1e9 + 10;
const long long LINF = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000 + 100;
const int MN = 1e5 + 10;
const int MOD = 1e9 + 7;
int n, q;
vector<pair<int, int> > adj[MN], qr[MN];
int ans[MN];
long long mul[4 * MN], seg[4 * MN], lz[4 * MN];
int Time, st[MN], ft[MN];
long long d_tmp[MN];
int rev[MN];
void input() {
scanf("%d", &n);
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(pair<int, int>(b, c)),
adj[b].push_back(pair<int, int>(a, c));
}
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
qr[u].push_back(pair<int, int>(v, i));
}
}
void dfs_prep(int s, int pr, long long cur) {
st[s] = Time++;
rev[st[s]] = s;
d_tmp[s] = cur;
for (int i = 0; i < ((int)(adj[s]).size()); ++i) {
int v = adj[s][i].first;
if (v == pr) continue;
dfs_prep(v, s, (cur + adj[s][i].second) % MOD);
}
ft[s] = Time;
}
void change(int segnum, int val, int left, int right) {
int t = right - left + 1, mid = (left + right) >> 1;
mul[segnum] = (1ll * mul[segnum] +
((1ll * val * val) % MOD * (1ll * t * (t - 1) / 2)) % MOD) %
MOD;
mul[segnum] =
(1ll * mul[segnum] + ((seg[segnum] * (t - 1)) % MOD * val) % MOD) % MOD;
if (mul[segnum] < 0) mul[segnum] += MOD;
seg[segnum] = (1ll * seg[segnum] + 1ll * val * t) % MOD;
if (seg[segnum] < 0) seg[segnum] += MOD;
}
void shift(int segnum, int left, int right) {
int mid = (left + right) >> 1;
change(2 * segnum, lz[segnum], left, mid);
change(2 * segnum + 1, lz[segnum], mid + 1, right);
lz[2 * segnum] += lz[segnum], lz[2 * segnum + 1] += lz[segnum];
lz[2 * segnum] %= MOD, lz[2 * segnum + 1] %= MOD, lz[segnum] = 0;
}
void build(int segnum, int left, int right) {
if (left == right) {
seg[segnum] = d_tmp[rev[left]];
return;
}
int mid = (left + right) >> 1;
build(2 * segnum, left, mid), build(2 * segnum + 1, mid + 1, right);
seg[segnum] = (seg[2 * segnum] + seg[2 * segnum + 1]) % MOD;
mul[segnum] = (mul[2 * segnum] + mul[2 * segnum + 1]) % MOD;
mul[segnum] = (mul[segnum] + seg[2 * segnum] * seg[2 * segnum + 1]) % MOD;
}
void upd(int segnum, int left, int right, int l, int r, int val) {
if (r < left || right < l) return;
if (l <= left && right <= r) {
change(segnum, val, left, right);
lz[segnum] = (lz[segnum] + val) % MOD;
return;
}
shift(segnum, left, right);
int mid = (left + right) >> 1;
upd(2 * segnum, left, mid, l, r, val),
upd(2 * segnum + 1, mid + 1, right, l, r, val);
seg[segnum] = (seg[2 * segnum] + seg[2 * segnum + 1]) % MOD;
mul[segnum] = (mul[2 * segnum] + mul[2 * segnum + 1]) % MOD;
mul[segnum] =
(mul[segnum] + (seg[2 * segnum] * seg[2 * segnum + 1]) % MOD) % MOD;
}
long long get(int segnum, int left, int right, int l, int r) {
if (r < left || right < l) return 0;
if (l <= left && right <= r)
return ((seg[segnum] * seg[segnum]) % MOD - (2ll * mul[segnum]) % MOD +
MOD) %
MOD;
int mid = (left + right) >> 1;
shift(segnum, left, right);
return (get(2 * segnum, left, mid, l, r) +
get(2 * segnum + 1, mid + 1, right, l, r)) %
MOD;
}
void dfs(int s, int pr, int c) {
for (int i = 0; i < ((int)(qr[s]).size()); ++i) {
int v = qr[s][i].first;
long long val1 = get(1, 0, n - 1, st[v], ft[v] - 1);
long long val2 = get(1, 0, n - 1, 0, n - 1);
ans[qr[s][i].second] = (2ll * val1 - val2 + MOD) % MOD;
}
for (int i = 0; i < ((int)(adj[s]).size()); ++i) {
int v = adj[s][i].first, w = adj[s][i].second;
if (v == pr) continue;
upd(1, 0, n - 1, 0, n - 1, w);
upd(1, 0, n - 1, st[v], ft[v] - 1, -2 * w);
dfs(v, s, w);
}
if (pr != -1) {
upd(1, 0, n - 1, 0, n - 1, -c);
upd(1, 0, n - 1, st[s], ft[s] - 1, 2 * c);
}
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
input();
dfs_prep(0, -1, 0);
build(1, 0, n - 1);
dfs(0, -1, 0);
for (int i = 0; i < q; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
const int MOD = 1e9 + 7;
int n, q;
struct Edge {
int v, w, next;
} edge[MAXN << 1];
int head[MAXN], tail;
void insert(int u, int v, int w) {
edge[++tail] = (Edge){v, w, head[u]};
head[u] = tail;
}
namespace {
inline int add(int x) { return x >= MOD ? x - MOD : x; }
inline int sub(int x) { return x < 0 ? x + MOD : x; }
inline int mul(int x, int y) { return (long long)x * y % MOD; }
} // namespace
namespace solver1 {
int son_w2[MAXN], son_w[MAXN], up_w2[MAXN], up_w[MAXN], sz[MAXN];
int anc[MAXN][21], len[MAXN], dep[MAXN];
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
sz[u] = 1;
anc[u][0] = fa;
for (int i = 1; i <= 20; i++) anc[u][i] = anc[anc[u][i - 1]][i - 1];
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].v;
if (v == fa) continue;
len[v] = add(len[u] + edge[i].w);
dfs(v, u);
sz[u] += sz[v];
son_w2[u] =
add(son_w2[u] +
add(son_w2[v] + add(mul(edge[i].w * 2, son_w[v]) +
mul(mul(edge[i].w, edge[i].w), sz[v]))));
son_w[u] = add(son_w[u] + add(son_w[v] + mul(edge[i].w, sz[v])));
}
}
void dfs2(int u, int fa, int w2, int w) {
up_w2[u] = w2;
up_w[u] = w;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].v;
if (v == fa) continue;
int ww2 = add(
w2 + sub(son_w2[u] -
add(son_w2[v] + add(mul(edge[i].w * 2, son_w[v]) +
mul(mul(edge[i].w, edge[i].w), sz[v])))));
int ww = add(w + sub(son_w[u] - add(son_w[v] + mul(edge[i].w, sz[v]))));
dfs2(v, u,
add(ww2 + add(mul(edge[i].w * 2, ww) +
mul(mul(edge[i].w, edge[i].w), n - sz[v]))),
add(ww + mul(edge[i].w, n - sz[v])));
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) std::swap(x, y);
int k = dep[x] - dep[y];
for (int i = 20; i >= 0; i--) {
if (k & (1 << i)) {
x = anc[x][i];
}
}
if (x == y) return x;
for (int i = 20; i >= 0; i--) {
if (anc[x][i] != anc[y][i]) {
x = anc[x][i];
y = anc[y][i];
}
}
return anc[x][0];
}
void main() {
dfs(1, 0);
dfs2(1, 0, 0, 0);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
int l = lca(u, v);
int w = sub(add(len[u] + len[v]) - add(len[l] + len[l]));
int part2 = add(son_w2[u] + up_w2[u]), part1;
if (l != v) {
part1 =
add(son_w2[v] + add(mul(w * 2, son_w[v]) + mul(mul(w, w), sz[v])));
} else {
part1 = sub(
add(son_w2[u] + up_w2[u]) -
add(add(mul(mul(w, w), n - sz[v]) + up_w2[v]) + mul(w * 2, up_w[v])));
}
printf("%d\n", sub(add(part1 * 2) - part2));
}
}
} // namespace solver1
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
insert(u, v, w);
insert(v, u, w);
}
scanf("%d", &q);
solver1::main();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 100;
const int MOD = 1e9 + 7;
long long T = 0;
long long st[MAXN], fn[MAXN];
vector<pair<long long, long long>> ver[MAXN];
pair<long long, long long> q[MAXN];
vector<long long> query[MAXN];
long long d[MAXN];
long long s[MAXN];
long long sum[MAXN * 4], lazy[MAXN * 4], seg[MAXN * 4];
long long res[MAXN], n;
inline void calc(long long id, long long xl, long long xr, long long qv) {
long long sqr = qv * qv % MOD;
seg[id] = (2 * sum[id] * qv + sqr * (xr - xl) + seg[id]) % MOD;
sum[id] = (sum[id] + qv * (xr - xl)) % MOD;
lazy[id] = (lazy[id] + qv) % MOD;
}
inline void shift(long long id, long long xl, long long xr) {
if (!lazy[id]) return;
long long mid = (xl + xr) / 2;
calc(2 * id + 1, xl, mid, lazy[id]);
calc(2 * id + 2, mid, xr, lazy[id]);
lazy[id] = 0;
}
void upd(long long ql, long long qr, long long qv, long long xl = 0,
long long xr = MAXN, long long id = 0) {
if (ql <= xl && xr <= qr) return calc(id, xl, xr, qv);
if (qr <= xl || xr <= ql) return;
shift(id, xl, xr);
long long mid = (xl + xr) / 2;
upd(ql, qr, qv, xl, mid, 2 * id + 1);
upd(ql, qr, qv, mid, xr, 2 * id + 2);
seg[id] = (seg[2 * id + 1] + seg[2 * id + 2]) % MOD;
sum[id] = (sum[2 * id + 1] + sum[2 * id + 2]) % MOD;
}
long long get(long long ql, long long qr, long long xl = 0, long long xr = MAXN,
long long id = 0) {
if (ql >= qr) return 0;
if (ql <= xl && xr <= qr) return seg[id];
if (qr <= xl || xr <= ql) return 0;
shift(id, xl, xr);
long long mid = (xl + xr) / 2;
return (get(ql, qr, xl, mid, 2 * id + 1) + get(ql, qr, mid, xr, 2 * id + 2)) %
MOD;
}
void build(long long xl = 0, long long xr = MAXN, long long id = 0) {
if (xr - xl == 1) {
sum[id] = s[xl];
seg[id] = s[xl] * s[xl] % MOD;
return;
}
long long mid = (xl + xr) / 2;
build(xl, mid, 2 * id + 1);
build(mid, xr, 2 * id + 2);
sum[id] = (sum[2 * id + 1] + sum[2 * id + 2]) % MOD;
seg[id] = (seg[2 * id + 1] + seg[2 * id + 2]) % MOD;
}
void pre_dfs(long long v, long long par = 0) {
st[v] = T++;
for (auto e : ver[v]) {
long long u = e.first;
long long w = e.second;
if (u == par) continue;
d[u] = (d[v] + w) % MOD;
pre_dfs(u, v);
}
fn[v] = T;
}
void dfs(long long v, long long w = 0, long long par = 0) {
for (auto u : query[v]) {
long long k = q[u].second;
res[u] = (2 * get(st[k], fn[k]) - seg[0] + MOD) % MOD;
}
for (auto e : ver[v]) {
long long u = e.first;
long long z = e.second;
if (u == par) continue;
upd(0, n, +z);
upd(st[u], fn[u], (2 * MOD - 2 * z) % MOD);
dfs(u, z, v);
}
upd(0, n, MOD - w);
upd(st[v], fn[v], 2 * w % MOD);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 1; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
ver[x].push_back({y, z});
ver[y].push_back({x, z});
}
pre_dfs(1);
for (long long i = 1; i <= n; i++) s[st[i]] = d[i];
build();
long long nq;
cin >> nq;
for (long long i = 0; i < nq; i++) {
cin >> q[i].first >> q[i].second;
query[q[i].first].push_back(i);
}
dfs(1);
for (long long i = 0; i < nq; i++) cout << res[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
const int mod = 1e9 + 7;
int s[N], st[N], ed[N], n, tot, ans[N];
long long sq[N << 2], sum[N << 2], ch[N << 2];
vector<pair<int, int> > adj[N];
vector<int> qu[N];
int rend(int v, int b, int e, int x) {
ch[v] = (ch[v] + x) % mod;
sq[v] = (sq[v] + (x * 1LL * x % mod) * (e - b) + sum[v] * x * 2) % mod;
sum[v] = (x * 1LL * (e - b) + sum[v]) % mod;
}
void spread(int v, int b, int e) {
int mid = b + e >> 1, l = v << 1, r = l | 1;
rend(l, b, mid, ch[v]);
rend(r, mid, e, ch[v]);
ch[v] = 0;
}
void renew(int v) {
int l = v << 1, r = l | 1;
sq[v] = (sq[l] + sq[r]) % mod;
sum[v] = (sum[l] + sum[r]) % mod;
}
void update(int i, int j, int x, int v = 1, int b = 0, int e = n) {
if (i >= e || b >= j) return;
if (i <= b && e <= j) {
rend(v, b, e, x);
return;
}
int mid = b + e >> 1, l = v << 1, r = l | 1;
spread(v, b, e);
update(i, j, x, l, b, mid);
update(i, j, x, r, mid, e);
renew(v);
}
int query(int i, int j, int v = 1, int b = 0, int e = n) {
if (i >= e || b >= j) return 0;
if (i <= b && e <= j) return sq[v];
int mid = b + e >> 1, l = v << 1, r = l | 1;
spread(v, b, e);
return (query(i, j, l, b, mid) + query(i, j, r, mid, e)) % mod;
}
void dfs_init(int v, int p = -1, int d = 0) {
st[v] = tot++;
update(st[v], st[v] + 1, d);
for (int i = 0; i < (int)adj[v].size(); i++)
if (adj[v][i].first != p) {
int u = adj[v][i].first, w = adj[v][i].second;
dfs_init(u, v, (d + w) % mod);
}
ed[v] = tot;
}
void dfs_ans(int v, int p = -1) {
for (int i = 0; i < (int)adj[v].size(); i++)
if (adj[v][i].first != p) {
int u = adj[v][i].first, w = adj[v][i].second;
update(st[0], ed[0], w);
update(st[u], ed[u], (-2 * w + 2 * mod) % mod);
dfs_ans(u, v);
update(st[0], ed[0], (-w + mod) % mod);
update(st[u], ed[u], 2 * w % mod);
}
for (int i = 0; i < (int)qu[v].size(); i++) {
int id = qu[v][i], u = s[id];
ans[id] = (0LL + -query(st[0], ed[0]) + 2 * query(st[u], ed[u]) +
100 * 1LL * mod) %
mod;
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
u--, v--;
s[i] = v;
qu[u].push_back(i);
}
dfs_init(0);
dfs_ans(0);
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int MAXN = 100010;
int n;
struct edge {
int t;
long long w;
edge *next;
} epool[MAXN * 2], *e[MAXN];
int psz;
int dep[MAXN], fa[MAXN][21];
long long dis[MAXN];
struct S {
long long size, sum, sum2;
S() {}
S(long long size, long long sum, long long sum2)
: size(size), sum(sum), sum2(sum2) {}
S operator+(long long d) const {
return S(size, (sum + d * size % MOD) % MOD,
(sum2 + 2 * d * sum % MOD + d * d % MOD * size % MOD) % MOD);
}
S &operator+=(const S &b) {
size += b.size, sum += b.sum, sum2 += b.sum2;
size %= MOD, sum %= MOD, sum2 %= MOD;
return *this;
}
S &operator-=(const S &b) {
size += MOD - b.size, sum += MOD - b.sum, sum2 += MOD - b.sum2;
size %= MOD, sum %= MOD, sum2 %= MOD;
return *this;
}
} f[MAXN], g[MAXN];
void addedge(int u, int v, long long w) {
epool[psz] = (edge){v, w, e[u]};
e[u] = epool + psz++;
}
void init() {
psz = 0, memset(e, 0, sizeof(e));
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addedge(u, v, w % MOD);
addedge(v, u, w % MOD);
}
}
void dfs1(int u) {
f[u] = S(1, 0, 0);
for (int i = 0; i < 20; ++i) fa[u][i + 1] = fa[fa[u][i]][i];
for (edge *i = e[u]; i; i = i->next) {
int v = i->t;
if (v == fa[u][0]) continue;
fa[v][0] = u;
dep[v] = dep[u] + 1;
dis[v] = (dis[u] + i->w) % MOD;
dfs1(v);
f[u] += f[v] + i->w;
}
}
void dfs2(int u) {
for (edge *i = e[u]; i; i = i->next) {
int v = i->t;
if (v == fa[u][0]) continue;
g[v] = g[u] + i->w;
g[v] += f[u] + i->w;
g[v] -= f[v] + i->w * 2 % MOD;
dfs2(v);
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 20; i >= 0; --i) {
if (dep[fa[u][i]] >= dep[v]) u = fa[u][i];
}
if (u == v) return u;
for (int i = 20; i >= 0; --i) {
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
}
return fa[u][0];
}
void solve() {
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
int w = lca(u, v);
long long d = ((dis[u] + dis[v] - dis[w] * 2) % MOD + MOD) % MOD;
S s1, s2;
if (w == v) {
s2 = g[v] + d;
s1 = f[u];
s1 += g[u];
s1 -= s2;
} else {
s1 = f[v] + d;
s2 = f[u];
s2 += g[u];
s2 -= s1;
}
s1 -= s2;
printf("%d\n", (int)s1.sum2);
}
}
int main() {
init();
dep[1] = 1, dis[1] = 0;
dfs1(1);
dfs2(1);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 300;
const long long mod = 1e9 + 7;
const long long NN = 20 + 1;
vector<pair<long long, long long> > a[N];
long long p[N][NN], t[N], dp[N], dp2[N], sum[N], h[N], dp3[N], dp4[N], n;
void dfs2(long long v, long long par = -1, long long col = -1) {
dp3[v] = dp[v];
dp4[v] = dp2[v];
if (par != -1) {
dp4[v] = 0;
dp3[v] = (dp3[par] + ((n - 2 * t[v] + 2 * mod) * col) % mod) % mod;
dp4[v] = (dp4[par] + (((col * col) % mod) * (n - 1)) % mod +
2 * (col * dp3[par]) % mod) %
mod;
dp4[v] += 2 * mod - (4 * dp[v] * col) % mod -
(t[v] * 4 * ((col * col) % mod)) % mod + (col * col) % mod;
dp4[v] %= mod;
}
for (long long i = 0, u, c; i < a[v].size(); i++) {
u = a[v][i].first, c = a[v][i].second;
if (u != par) {
dfs2(u, v, c);
}
}
}
void dfs(long long v, long long par = -1) {
p[v][0] = par;
for (long long i = 1; i < NN; i++) {
if (p[v][i - 1] != -1) p[v][i] = p[p[v][i - 1]][i - 1];
}
t[v] = 1;
for (long long i = 0, u, c; i < a[v].size(); i++) {
u = a[v][i].first, c = a[v][i].second;
if (u != par) {
sum[u] = (sum[v] + c) % mod;
h[u] = h[v] + 1;
dfs(u, v);
t[v] += t[u];
dp[v] += (dp[u] + c * t[u]) % mod;
dp[v] %= mod;
dp2[v] += (dp2[u] + (t[u] * ((c * c) % mod)) % mod) % mod;
dp2[v] %= mod;
dp2[v] += 2 * ((c * dp[u]) % mod);
dp2[v] %= mod;
}
}
}
long long getp(long long v, long long k) {
for (long long i = 0; i < NN; i++) {
if ((k & (1 << i)) != 0) v = p[v][i];
}
return v;
}
long long lca(long long v, long long u) {
if (h[u] > h[v]) swap(u, v);
v = getp(v, h[v] - h[u]);
if (u == v) return v;
for (long long i = NN - 1; i >= 0; i--) {
if (p[u][i] != p[v][i]) u = p[u][i], v = p[v][i];
}
return p[u][0];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
memset(p, -1, sizeof(p));
cin >> n;
for (long long i = 0, u, v, c; i < n - 1; i++) {
cin >> u >> v >> c;
u--;
v--;
a[u].push_back(make_pair(v, c));
a[v].push_back(make_pair(u, c));
}
dfs(0);
dfs2(0);
long long m;
cin >> m;
for (long long _ = 0, u, v; _ < m; _++) {
cin >> u >> v;
u--;
v--;
long long l = lca(u, v);
long long x = sum[u] + sum[v] - 2 * sum[l] + 2 * mod;
x %= mod;
long long ans =
dp2[v] + (t[v] * ((x * x) % mod)) % mod + 2 * ((dp[v] * x) % mod);
if (v == l) {
long long h = (dp4[v] - dp2[v] + mod) % mod +
((n - t[v]) * ((x * x) % mod)) % mod +
(2 * (((dp3[v] - dp[v]) * x) % mod) % mod);
h %= mod;
ans = dp4[u] - h + mod;
}
ans %= mod;
ans *= 2;
ans += mod - dp4[u];
ans %= mod;
cout << ans << "\n";
}
return 0;
}
|
#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], sum[120000];
int w[120000], ff[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) {
ff[0][x] = fa;
for (int i = 1; i <= 20; ++i) ff[i][x] = ff[i - 1][ff[i - 1][x]];
f[x].x2 = f[x].x1 = 0;
f[x].x0 = 1;
for (auto e : E[x])
if (e.first != fa) {
dep[e.first] = dep[x] + 1;
w[e.first] = (w[x] + e.second) % mo;
dfs(e.first, x);
f[x] = f[x] + f[e.first] * e.second;
}
}
void dp(int x, int fa) {
Val tmp = {0, 0, 1};
for (auto e : E[x])
if (e.first != fa) tmp = tmp + f[e.first] * e.second;
for (auto e : E[x])
if (e.first != fa) {
int y = e.first;
sum[y] = (sum[x] + (tmp - f[y] * e.second)) * e.second;
g[y] = (tmp + g[x] - f[y] * e.second) * e.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);
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)
ans = (2ll * (f[u].x2 + (sum[u] - sum[v] * dist).x2) - (f[u] + g[u]).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 MAXN = 1e5 + 6.66;
const int LOGMAXN = 20;
const long long mod = 1e9 + 7;
vector<pair<int, long long>> tree[MAXN];
int par[MAXN];
long long upedge[MAXN];
int sz[MAXN];
int h[MAXN];
int lca[LOGMAXN][MAXN];
long long sum[LOGMAXN][MAXN];
long long down[MAXN];
long long down2[MAXN];
long long up[MAXN];
long long up2[MAXN];
long long tot[MAXN];
void lca_init_dfs(int v = 1, int p = 0, int hei = 0, int wei = 0) {
par[v] = p;
h[v] = hei;
upedge[v] = wei;
for (auto x : tree[v])
if (x.first != p) lca_init_dfs(x.first, v, hei + 1, x.second);
}
void init_lca(int n) {
lca_init_dfs();
for (int i = 1; i <= n; i++) lca[0][i] = par[i], sum[0][i] = upedge[i];
for (int i = 1; i < LOGMAXN; i++)
for (int j = 1; j <= n; j++)
lca[i][j] = lca[i - 1][lca[i - 1][j]],
sum[i][j] = sum[i - 1][j] + sum[i - 1][lca[i - 1][j]];
}
int get_par(int v, int x) {
for (; x; x ^= x & -x) v = lca[__builtin_ctz(x)][v];
return v;
}
bool is_anc(int v, int u) {
if (h[v] > h[u]) return false;
return get_par(u, h[u] - h[v]) == v;
}
int get_lca(int v, int u) {
if (h[v] > h[u]) swap(u, v);
u = get_par(u, h[u] - h[v]);
if (u == v) return v;
for (int i = LOGMAXN - 1; i > -1; i--)
if ((1 << i) <= h[v] && lca[i][v] != lca[i][u])
u = lca[i][u], v = lca[i][v];
return lca[0][u];
}
long long get_path_par(int v, int p) {
long long ans = 0;
for (int i = LOGMAXN - 1; i > -1; i--)
if (h[v] - (1 << i) >= h[p]) (ans += sum[i][v]) %= mod, v = lca[i][v];
return ans;
}
long long get_path(int v, int u) {
int lc = get_lca(u, v);
return (get_path_par(u, lc) + get_path_par(v, lc)) % mod;
}
long long pow2_sum(long long sw2, long long sw, long long x, long long s) {
sw2 %= mod, sw %= mod, x %= mod, s %= mod;
if (sw2 < 0) sw2 += mod;
if (sw < 0) sw += mod;
if (x < 0) x += mod;
return (sw2 + 2LL * x * sw % mod + 1LL * x * x % mod * s % mod) % mod;
}
void dfs_up(int v = 1, int p = 0) {
sz[v] = 1;
for (auto x : tree[v])
if (x.first != p) {
dfs_up(x.first, v);
sz[v] += sz[x.first];
(down[v] += down[x.first] + x.second * sz[x.first]) %= mod;
(down2[v] +=
pow2_sum(down2[x.first], down[x.first], x.second, sz[x.first])) %= mod;
}
}
void dfs_down(int v = 1, int p = 0, long long upp = 0, long long upp2 = 0) {
upp %= mod, upp2 %= mod;
up[v] = upp;
up2[v] = upp2;
tot[v] = (up2[v] + down2[v]) % mod;
for (auto x : tree[v])
if (x.first != p) {
long long ss = upp + down[v] - down[x.first] + 2LL * mod +
1LL * (sz[1] - 2 * sz[x.first]) * x.second % mod;
ss %= mod;
long long ss2 = pow2_sum(
upp2 + down2[v] + mod -
pow2_sum(down2[x.first], down[x.first], x.second, sz[x.first]),
upp + down[v] - down[x.first] - sz[x.first] * x.second % mod +
2LL * mod,
x.second, (sz[1] - sz[x.first]));
dfs_down(x.first, v, ss, ss2);
}
}
void initiate(int& n) {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
long long z;
scanf("%d %d %lld", &x, &y, &z);
tree[x].push_back({y, z});
tree[y].push_back({x, z});
}
init_lca(n);
dfs_up();
dfs_down();
}
int main() {
int n;
initiate(n);
int q;
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d %d", &u, &v);
long long ans = 0;
if (u == v)
ans = (down2[v] - up2[v] + mod) % mod;
else if (is_anc(v, u)) {
long long xx = pow2_sum(up2[v], up[v], get_path_par(u, v), sz[1] - sz[v]);
(ans = tot[u] - 2LL * xx + 2LL * mod) %= mod;
} else {
long long x1 = pow2_sum(down2[v], down[v], get_path(u, v), sz[v]);
(ans = 2LL * x1 - tot[u] + 2LL * mod) %= mod;
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long N = 1e5 + 100;
const long long LOG = 19;
const long long MOD = 1e9 + 7;
vector<pair<long long, long long>> g[N];
long long up[N][LOG], tin[N], tout[N], d0[N], d1[N], d2[N], sizes[N], ans[N],
ans1[N], ans2[N];
long long timer = 0;
long long n;
long long add(long long a, long long b) {
a += b;
a %= MOD;
if (a < 0) {
a += MOD;
}
return a;
}
long long mul(long long a, long long b) { return 1ll * a * b % MOD; }
void dfs0(long long v, long long p) {
tin[v] = timer++;
sizes[v] = 1;
for (long long i = 1; i < LOG; i++) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (long long i = 0; i < (long long)g[v].size(); i++) {
if (g[v][i].first == p) {
g[v].erase(g[v].begin() + i);
break;
}
}
for (auto i : g[v]) {
assert(i.first != p);
up[i.first][0] = v;
d0[i.first] = add(d0[v], i.second);
dfs0(i.first, v);
sizes[v] += sizes[i.first];
}
tout[v] = timer;
}
long long anc(long long a, long long b) {
return tin[a] <= tin[b] && tout[b] <= tout[a];
}
long long lca(long long v, long long u) {
if (anc(v, u)) {
return v;
}
if (anc(u, v)) {
return u;
}
for (long long i = LOG - 1; i >= 0; i--) {
if (!anc(up[v][i], u)) {
v = up[v][i];
}
}
return up[v][0];
}
long long getDist(long long v, long long u) {
long long w = lca(v, u);
long long ret = add(d0[v], d0[u]);
ret = add(ret, mul(-2, d0[w]));
return ret;
}
long long get_cost(long long d, long long d1, long long d2, long long n) {
long long ret = mul(mul(d, d), n);
ret = add(ret, mul(2 * d, d1));
ret = add(ret, d2);
return ret;
}
void dfs1(long long v) {
for (auto i : g[v]) {
long long u = i.first, c = i.second;
dfs1(u);
d2[v] = add(d2[v], get_cost(c, d1[u], d2[u], sizes[u]));
d1[v] = add(d1[v], mul(c, sizes[u]));
d1[v] = add(d1[v], d1[u]);
}
}
void dfs2(long long v, long long a, long long b) {
ans[v] = add(ans[v], d2[v]);
ans[v] = add(ans[v], b);
ans1[v] = a;
ans2[v] = b;
a = add(a, d1[v]);
b = add(b, d2[v]);
for (auto i : g[v]) {
long long u = i.first, c = i.second;
long long ta = a;
ta = add(ta, -d1[u]);
ta = add(ta, -mul(c, sizes[u]));
long long tb = b;
tb = add(tb, -get_cost(c, d1[u], d2[u], sizes[u]));
tb = get_cost(c, ta, tb, n - sizes[u]);
ta = add(ta, mul(c, n - sizes[u]));
dfs2(u, ta, tb);
}
}
long long stupid(long long v) {
long long ret = 0;
for (long long i = 0; i < n; i++) {
long long D = getDist(v, i);
ret = add(ret, mul(D, D));
}
return ret;
}
long long solve(long long v, long long u) {
swap(v, u);
long long ret = 0;
long long D = getDist(v, u);
if (anc(v, u)) {
ret = ans[u];
long long cur = get_cost(D, ans1[v], ans2[v], n - sizes[v]);
ret = add(ret, -mul(2, cur));
} else {
ret = add(0, -ans[u]);
long long cur = 0;
cur = get_cost(D, d1[v], d2[v], sizes[v]);
ret = add(ret, mul(2, cur));
}
return ret;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 1; i < n; i++) {
long long v, u, c;
cin >> v >> u >> c;
v--;
u--;
g[v].emplace_back(u, c);
g[u].emplace_back(v, c);
}
dfs0(0, -1);
dfs1(0);
dfs2(0, 0, 0);
long long q;
cin >> q;
while (q--) {
long long v, u;
cin >> v >> u;
v--;
u--;
cout << solve(v, u) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005, LG = 18, mod = 1000000007;
int n, p[MX][LG], lvl[MX], q;
long long d[MX], d2[MX], sz[MX], sd[MX], sd2[MX], tor[MX];
vector<pair<int, long long> > adj[MX];
int LCA(int u, int v) {
if (lvl[u] < lvl[v]) swap(u, v);
for (int j = 0; j < LG; j++)
if (lvl[u] - lvl[v] & (1 << j)) u = p[u][j];
if (u == v) return u;
for (int j = LG - 1; j >= 0; j--)
if (p[u][j] != p[v][j]) {
u = p[u][j];
v = p[v][j];
}
return p[u][0];
}
void pre(int u) {
sz[u] = 1;
for (pair<int, long long> &v : adj[u])
if (v.first != p[u][0]) {
lvl[v.first] = lvl[u] + 1;
p[v.first][0] = u;
tor[v.first] = (tor[u] + v.second) % mod;
pre(v.first);
sz[u] += sz[v.first];
(sd[u] += (sd[v.first] + sz[v.first] * v.second)) %= mod;
(sd2[u] += (sd2[v.first] + 2 * sd[v.first] * v.second +
v.second * v.second % mod * sz[v.first])) %= mod;
}
}
void dfs(int u) {
for (pair<int, long long> &v : adj[u])
if (v.first != p[u][0]) {
d[v.first] = (d[u] + v.second * (n - 2 * sz[v.first])) % mod;
d2[v.first] =
(d2[u] +
2 * v.second *
(d[u] - 2 * (sd[v.first] + v.second * sz[v.first]) % mod) % mod +
v.second * v.second % mod * n) %
mod;
dfs(v.first);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
adj[a].emplace_back(b, c);
adj[b].emplace_back(a, c);
}
p[1][0] = 1;
pre(1);
for (int j = 1; j < LG; j++)
for (int i = 1; i <= n; i++) p[i][j] = p[p[i][j - 1]][j - 1];
d[1] = sd[1];
d2[1] = sd2[1];
dfs(1);
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
int lca = LCA(u, v);
long long res = lca == v ? d2[u] : -d2[u];
long long dis = (tor[u] + tor[v] - 2 * tor[lca]) % mod;
if (lca == v) {
(res -= 2 * (((d2[v] - sd2[v]) + 2 * (d[v] - sd[v]) * dis +
dis * dis % mod * (n - sz[v])) %
mod)) %= mod;
} else {
(res +=
2 * ((sd2[v] + 2 * sd[v] * dis + dis * dis % mod * sz[v]) % mod)) %= mod;
}
cout << ((((res) % (mod)) + (mod)) % (mod)) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class sp {
public:
int q;
long long w, t, t1, t2;
sp *e, *r;
sp(int q1, long long w1, sp *e1) {
q = q1;
w = w1;
e = e1;
t = t1 = t2 = 0;
}
};
sp *a[100000], *s1[100000];
int s[100000], s2[100000], d[100000], d1[100000], d2[100000], p = 1000000007;
int u = 0, d3[100000], *f[100000], *f1[100000], h[100000], h1[100000];
int d00[100000], d01[100000], d02[100000];
long long m(long long w, long long e) {
if (w < 0) w += p;
if (e < 0) e += p;
return (w * e) % p;
}
void l(int q, sp *w) {
sp *c;
if (s[q] == -1) {
s[q] = 0;
s1[q] = w;
if (w == 0) s[q] = -2;
for (c = a[q]; c; c = c->e)
if (c != w) {
l(c->q, c->r);
d[q] += c->t;
d1[q] = (d1[q] + c->t1) % p;
d2[q] = (d2[q] + c->t2) % p;
}
}
if (s[q] == 0)
if (s1[q] == w) {
w->r->t = d[q];
w->r->t1 = (d[q] * (w->w) + d1[q]) % p;
w->r->t2 = (m(w->w, w->w) * d[q] + 2 * m(w->w, d1[q]) + d2[q]) % p;
return;
} else {
s[q] = -2;
l(s1[q]->q, s1[q]->r);
d[q] = d[q] + s1[q]->t;
d1[q] = (d1[q] + s1[q]->t1) % p;
d2[q] = (d2[q] + s1[q]->t2) % p;
}
if ((s[q] == -2) && (w != 0)) {
w->r->t = d[q] - w->t;
w->r->t1 = (m(d[q] - w->t, w->w) + d1[q] - w->t1 + p) % p;
w->r->t2 = (m(m(w->w, w->w), d[q] - w->t) + 2 * m(w->w, d1[q] - w->t1) +
d2[q] - w->t2 + p) %
p;
}
}
void l1(int q, sp *w, int t) {
sp *c;
h[q] = u;
u++;
s[t] = q;
s2[t] = 0;
if (w != 0) s2[t] = (s2[t - 1] + w->w) % p;
for (c = a[q]; c; c = c->e)
if (c != w) l1(c->q, c->r, t + 1);
h1[q] = u - 1;
if (w != 0) {
d[q] = d[q] - w->t;
d1[q] = (d1[q] - w->t1 + p) % p;
d3[q] = (d2[q] - w->t2 + p) % p;
d00[q] = w->t;
d01[q] = w->t1;
d02[q] = w->t2;
}
int e, r;
for (e = 0, r = 1; e < 17; e++, r <<= 1)
if (t >= r) {
f[q][e] = s[t - r];
f1[q][e] = s2[t] - s2[t - r];
if (f1[q][e] < 0) f1[q][e] += p;
} else
f[q][e] = -1;
}
int k(int q, int w) {
int e, c;
long long t = 0;
c = q;
for (e = 16; e >= 0; e--)
if (f[c][e] >= 0)
if (!((h[f[c][e]] <= h[w]) && (h[w] <= h1[f[c][e]]))) {
t += f1[c][e];
c = f[c][e];
}
if (f[c][0] >= 0)
if (!((h[c] <= h[w]) && (h[w] <= h1[c]))) t += f1[c][0];
c = w;
for (e = 16; e >= 0; e--)
if (f[c][e] >= 0)
if (!((h[f[c][e]] <= h[q]) && (h[q] <= h1[f[c][e]]))) {
t += f1[c][e];
c = f[c][e];
}
if (f[c][0] >= 0)
if (!((h[c] <= h[q]) && (h[q] <= h1[c]))) t += f1[c][0];
return t % p;
}
int main() {
int q, w, e, r;
long long t, c;
cin >> q;
for (w = 0; w < q; w++) {
s[w] = -1;
d[w] = 1;
d1[w] = d2[w] = 0;
a[w] = 0;
f[w] = new int[17];
f1[w] = new int[17];
}
for (w = 1; w < q; w++) {
scanf("%d%d%I64d", &e, &r, &t);
e--;
r--;
a[e] = new sp(r, t, a[e]);
a[r] = new sp(e, t, a[r]);
a[e]->r = a[r];
a[r]->r = a[e];
}
for (w = 0; w < q; w++)
if (s[w] != -2) l(w, 0);
d00[0] = d01[0] = d02[0] = 0;
d3[0] = d2[0];
l1(0, 0, 0);
for (cin >> w; w; w--) {
scanf("%d%d", &e, &r);
e--;
r--;
t = k(e, r);
if ((h[r] <= h[e]) && (h[e] <= h1[r])) {
c = (m(d00[r], m(t, t)) + 2 * m(t, d01[r]) + d02[r]) % p;
c = (d2[e] - ((c * 2) % p) + p) % p;
printf("%d\n", c);
} else {
c = (m(d[r], m(t, t)) + 2 * m(t, d1[r]) + d3[r]) % p;
c = (-(d2[e] - ((c * 2) % p)) + p) % p;
printf("%d\n", c);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int q;
struct st {
long long int lazy;
long long int sum1;
long long int sum2;
long long int cnt;
st() { cnt = lazy = sum1 = sum2 = 0; }
};
vector<pair<int, long long int> > v[100002];
long long int dist[100002];
bool use[100002];
int siz;
int star[100002];
int en[100002];
int ar[100002];
inline void dfs(int b, long long int D = 0) {
if (D >= 1000000007LL) {
D %= 1000000007LL;
}
dist[b] = D;
use[b] = true;
star[b] = siz;
ar[siz] = b;
siz++;
for (int i = 0; i < v[b].size(); i++) {
if (use[v[b][i].first] == false) {
dfs(v[b][i].first, D + v[b][i].second);
}
}
en[b] = siz;
}
st seg[100002 * 4];
st merge(st a, st b) {
st r;
r.sum1 = a.sum1 + b.sum1;
r.sum2 = a.sum2 + b.sum2;
r.cnt = a.cnt + b.cnt;
r.sum1 %= 1000000007LL;
r.sum2 %= 1000000007LL;
return r;
}
void update(int b) {
if (seg[b].lazy != 0) {
if (seg[b].lazy >= 1000000007LL) {
seg[b].lazy %= 1000000007LL;
}
if (b * 2 + 2 < 100002 * 4) {
seg[b * 2 + 1].lazy += seg[b].lazy;
if (seg[b * 2 + 1].lazy >= 1000000007LL) {
seg[b * 2 + 1].lazy %= 1000000007LL;
}
seg[b * 2 + 2].lazy += seg[b].lazy;
if (seg[b * 2 + 2].lazy >= 1000000007LL) {
seg[b * 2 + 2].lazy %= 1000000007LL;
}
}
seg[b].sum2 += (((seg[b].lazy * seg[b].lazy) % 1000000007LL) * seg[b].cnt);
if (seg[b].sum2 >= 1000000007LL) {
seg[b].sum2 %= 1000000007LL;
}
seg[b].sum2 += 2LL * seg[b].lazy * seg[b].sum1;
if (seg[b].sum2 >= 1000000007LL) {
seg[b].sum2 %= 1000000007LL;
}
seg[b].sum1 += seg[b].cnt * seg[b].lazy;
seg[b].sum1 %= 1000000007LL;
seg[b].lazy = 0;
}
}
inline void init(int b, int l, int r) {
seg[b].cnt = r - l;
if (l + 1 == r) {
seg[b].sum2 = dist[ar[l]] * dist[ar[l]];
if (seg[b].sum2 >= 1000000007LL) {
seg[b].sum2 %= 1000000007LL;
}
seg[b].sum1 = dist[ar[l]];
if (seg[b].sum1 >= 1000000007LL) {
seg[b].sum1 %= 1000000007LL;
}
return;
}
init(b * 2 + 1, l, (l + r) >> 1);
init(b * 2 + 2, (l + r) >> 1, r);
seg[b] = merge(seg[b * 2 + 1], seg[b * 2 + 2]);
}
long long int ans[100002];
vector<pair<int, int> > vv[100002];
inline void add(int b, int l, int r, int ll, int rr, long long int x) {
if (x >= 1000000007LL) {
x %= 1000000007LL;
}
update(b);
if (r <= ll || rr <= l) {
return;
}
if (ll <= l && r <= rr) {
seg[b].lazy += (long long int)(x);
update(b);
return;
}
add(b * 2 + 1, l, (l + r) >> 1, ll, rr, x);
add(b * 2 + 2, (l + r) >> 1, r, ll, rr, x);
seg[b] = merge(seg[b * 2 + 1], seg[b * 2 + 2]);
}
inline st query(int b, int l, int r, int ll, int rr) {
update(b);
if (ll <= l && r <= rr) {
return seg[b];
}
if (rr <= l || r <= ll) {
return st();
}
return merge(query(b * 2 + 1, l, (l + r) >> 1, ll, rr),
query(b * 2 + 2, (l + r) >> 1, r, ll, rr));
}
inline void dfs2(int b) {
use[b] = false;
for (int i = 0; i < v[b].size(); i++) {
if (use[v[b][i].first] == true) {
add(0, 0, siz, 0, siz, v[b][i].second);
add(0, 0, siz, star[v[b][i].first], en[v[b][i].first],
(1000000007LL - v[b][i].second) * 2LL);
dfs2(v[b][i].first);
add(0, 0, siz, 0, siz, 1000000007LL - v[b][i].second);
add(0, 0, siz, star[v[b][i].first], en[v[b][i].first],
v[b][i].second * 2LL);
}
}
long long int D = query(0, 0, siz, 0, siz).sum2;
D %= 1000000007LL;
D = 1000000007LL - D;
D %= 1000000007LL;
for (int i = 0; i < vv[b].size(); i++) {
ans[vv[b][i].second] =
2LL * query(0, 0, siz, star[vv[b][i].first], en[vv[b][i].first]).sum2 +
D;
ans[vv[b][i].second] %= 1000000007LL;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
v[a].push_back(make_pair(b, c));
v[b].push_back(make_pair(a, c));
}
cin >> q;
dfs(0);
init(0, 0, n);
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
vv[a].push_back(make_pair(b, i));
}
dfs2(0);
for (int i = 0; i < q; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
return __gcd(a, b);
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int inf = 1e9 + 143;
const long long longinf = 1e18 + 143;
inline int read() {
int x;
scanf(" %d", &x);
return x;
}
const int N = 101001;
const int LOG = 17;
const int mod = 1e9 + 7;
inline int add(int x, int y) { return (x + y >= mod) ? x + y - mod : x + y; }
inline int mul(int x, int y) { return (long long)x * y % mod; }
struct info {
int a, b, c;
info() : a(0), b(0), c(0) {}
info(int _a, int _b, int _c) : a(_a), b(_b), c(_c) {}
info operator+(const info &other) {
return info(add(a, other.a), add(b, other.b), add(c, other.c));
}
info operator-(const info &other) {
return info(add(a, mod - other.a), add(b, mod - other.b),
add(c, mod - other.c));
}
info operator*(const int &x) {
info res;
res.a = add(a, mul(b, mul(2, x)));
res.a = add(res.a, mul(c, mul(x, x)));
res.b = add(b, mul(c, x));
res.c = c;
return res;
}
void newnode() { ++c; }
};
vector<pair<int, int> > g[N];
info down[N], up[N];
int d[N], de[N];
int anc[N][LOG];
void dfs1(int u, int p) {
anc[u][0] = p;
for (int i = 1; i < LOG; i++) anc[u][i] = anc[anc[u][i - 1]][i - 1];
for (__typeof((g[u]).begin()) it = (g[u]).begin(); it != (g[u]).end(); it++) {
int v = it->first;
int c = it->second;
if (v != p) {
d[v] = add(d[u], c);
de[v] = de[u] + 1;
dfs1(v, u);
down[u] = down[u] + (down[v] * c);
}
}
down[u].newnode();
}
void dfs2(int u, int p) {
info sum;
for (__typeof((g[u]).begin()) it = (g[u]).begin(); it != (g[u]).end(); it++) {
int v = it->first;
int c = it->second;
if (v != p) {
sum = sum + (down[v] * c);
}
}
for (__typeof((g[u]).begin()) it = (g[u]).begin(); it != (g[u]).end(); it++) {
int v = it->first;
int c = it->second;
if (v != p) {
up[v] = sum - (down[v] * c) + up[u];
up[v].newnode();
up[v] = up[v] * c;
dfs2(v, u);
}
}
}
int getlca(int u, int v) {
if (de[u] < de[v]) swap(u, v);
for (int i = 0; i < LOG; i++) {
if ((de[u] - de[v]) & (1 << i)) u = anc[u][i];
}
if (u == v) return u;
for (int i = LOG - 1; i >= 0; i--)
if (anc[u][i] != anc[v][i]) {
u = anc[u][i];
v = anc[v][i];
}
return anc[u][0];
}
int main() {
int n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read(), c = read();
g[u].push_back(pair<int, int>(v, c));
g[v].push_back(pair<int, int>(u, c));
}
dfs1(1, 0);
dfs2(1, 0);
int q = read();
while (q--) {
int u = read(), v = read();
int lca = getlca(u, v);
int dist = add(d[u], add(d[v], mod - mul(2, d[lca])));
if (lca == v) {
info toall = up[u] + down[u];
info unsub = up[v] * dist;
0;
printf("%d\n", add(toall.a, mod - mul(2, unsub.a)));
} else {
info toall = up[u] + down[u];
info sub = down[v] * dist;
0;
printf("%d\n", mod - add(toall.a, mod - mul(2, sub.a)));
}
}
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);
getLca(4, 3);
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;
const long long N = 100100;
vector<pair<long long, long long> > G[N];
long long n, ht[N], dist[N], sum[N], sum2[N], all2[N], size[N], all[N];
long long parent[N], p[N][20];
static bool vis[N][2], vis_[N];
void dfs(long long v) {
vis_[v] = true;
long long i, sz = G[v].size();
size[v] = 1;
for (i = 0; i < sz; i++)
if (!vis_[G[v][i].first]) {
dfs(G[v][i].first);
size[v] += size[G[v][i].first];
sum[v] = (sum[v] + (size[G[v][i].first] * G[v][i].second) % 1000000007 +
sum[G[v][i].first] % 1000000007) %
1000000007;
sum2[v] = (sum2[v] + sum2[G[v][i].first] +
(2LL * sum[G[v][i].first] * G[v][i].second) % 1000000007 +
(size[G[v][i].first] *
((G[v][i].second * G[v][i].second) % 1000000007)) %
1000000007) %
1000000007;
}
}
void bfs(long long v) {
long long i, sz, h;
vis[v][0] = vis[v][1] = true;
parent[v] = dist[v] = ht[v] = 0;
queue<long long> q;
q.push(v);
while (!q.empty()) {
h = q.front();
sz = G[h].size();
for (i = 0; i < sz; i++)
if (!vis[G[h][i].first][0]) {
dist[G[h][i].first] = (dist[h] + G[h][i].second) % 1000000007;
ht[G[h][i].first] = ht[h] + 1;
parent[G[h][i].first] = h;
vis[G[h][i].first][0] = true;
q.push(G[h][i].first);
}
q.pop();
}
for (long long i = 1; i <= n; i++)
all[v] = (all[v] + dist[i]) % 1000000007,
all2[v] = (all2[v] + (dist[i] * dist[i]) % 1000000007) % 1000000007;
q.push(v);
while (!q.empty()) {
h = q.front();
sz = G[h].size();
for (i = 0; i < sz; i++)
if (!vis[G[h][i].first][1]) {
all[G[h][i].first] =
((all[h] + (n - 2LL * size[G[h][i].first]) * G[h][i].second) %
1000000007 +
1000000007) %
1000000007;
all2[G[h][i].first] =
((all2[h] -
(n * ((G[h][i].second * G[h][i].second) % 1000000007) %
1000000007) +
2LL * (all[G[h][i].first] - 2LL * sum[G[h][i].first]) *
G[h][i].second) %
1000000007 +
1000000007) %
1000000007;
vis[G[h][i].first][1] = true;
q.push(G[h][i].first);
}
q.pop();
}
}
void init() {
long long i, j;
for (i = 1; i < n + 1; i++) p[i][0] = parent[i];
for (j = 1; (1 << j) < n; j++)
for (i = 1; i < n + 1; i++) p[i][j] = p[p[i][j - 1]][j - 1];
}
long long lca(long long u, long long v) {
if (ht[u] < ht[v]) swap(u, v);
long long log, i;
for (log = 1; (1 << log) <= ht[u]; log++)
;
log--;
for (i = log; i >= 0; i--)
if (ht[u] - (1 << i) >= ht[v]) u = p[u][i];
if (u == v) return u;
for (i = log; i >= 0; i--)
if (p[u][i] and (p[u][i] != p[v][i])) u = p[u][i], v = p[v][i];
return p[u][0];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
long long a, b, c, i, q;
for (i = 1; i < n; i++) {
cin >> a >> b >> c;
G[a].push_back(make_pair(b, c));
G[b].push_back(make_pair(a, c));
}
dfs(1);
bfs(1);
init();
cin >> q;
while (q--) {
cin >> a >> b;
long long k = lca(a, b), ans;
if (k != b) {
long long d =
((dist[a] + dist[b] - 2LL * dist[k]) % 1000000007 + 1000000007) %
1000000007;
long long c = size[b], s = sum[b], s2 = sum2[b], A = all2[a];
ans = (((2LL * c * ((d * d) % 1000000007)) % 1000000007 +
(4LL * d * s) % 1000000007 + 2LL * s2 - A) %
1000000007 +
1000000007) %
1000000007;
} else {
long long d = (dist[a] - dist[b] + 1000000007) % 1000000007;
long long c = size[b], s = sum[b], s2 = sum2[b];
long long A2a = all2[a], A2b = all2[b], Ab = all[b];
ans =
((A2a -
(2LL * ((d * d) % 1000000007) * (n - c + 1000000007)) % 1000000007 -
4LL * (d * (Ab - s + 1000000007)) % 1000000007 -
2LL * (A2b - s2 + 1000000007) % 1000000007) %
1000000007 +
1000000007) %
1000000007;
}
cout << ans << '\n';
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.