GESP8 考前晨读卡 · 完整版 2026-06-27 下午考 · 弱点 = 倍增 LCA + MST 路径最值(真题 P14080)· 上午只确认手感,不开新题

int fa[N], sz[N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
// init: for (i) { fa[i] = i; sz[i] = 1; }

void merge(int a, int b) {
  a = find(a); b = find(b);
  if (a == b) return;
  if (sz[a] < sz[b]) swap(a, b);         // 小的挂到大的下
  fa[b] = a; sz[a] += sz[b];
}
// 连通块数 = #{ fa[i] == i };每成功合并一次,块数 -1

typedef pair<long long, int> pli;        // (距离, 点)
vector<pli> g[N]; long long dist[N];      // g[u] 存 {w, v}
// init dist[i] = INF;

priority_queue<pli, vector<pli>, greater<pli> > pq;   // 小根堆,两 > 留空格
dist[s] = 0; pq.push(make_pair(0LL, s));
while (!pq.empty()) {
  pli t = pq.top(); pq.pop();
  long long dd = t.first; int u = t.second;
  if (dd > dist[u]) continue;            // 过期项必须跳
  for (size_t i = 0; i < g[u].size(); i++) {
    long long w = g[u][i].first; int v = g[u][i].second;
    if (dist[u] + w < dist[v]) {
      dist[v] = dist[u] + w; pq.push(make_pair(dist[v], v));
    }
  }
}

const long long INF = 1e18;
long long d[305][305];
// init d[i][j] = INF, d[i][i] = 0, 读边取 min(无向加反向)

for (int k = 1; k <= n; k++)             // k 必须最外层!
  for (int i = 1; i <= n; i++)
    for (int j = 1; j <= n; j++)
      if (d[i][k] < INF && d[k][j] < INF)
        d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
// 传递闭包: f[i][j] |= f[i][k] && f[k][j];

int g[N][N]; int dis[N]; bool vis[N];    // dis[v]: v 到"当前树"的最短连边
// init dis[i] = INF; dis[1] = 0;

long long tot = 0;
for (int i = 1; i <= n; i++) {
  int u = -1;
  for (int v = 1; v <= n; v++)           // 选树外离树最近的点
    if (!vis[v] && (u == -1 || dis[v] < dis[u])) u = v;
  if (dis[u] == INF) break;              // 图不连通
  vis[u] = true; tot += dis[u];
  for (int v = 1; v <= n; v++)           // 用新点 u 更新其它树外点
    if (!vis[v] && g[u][v] < dis[v]) dis[v] = g[u][v];
}

vector<int> g[N]; int indeg[N];           // 有向边 u→v: g[u].push_back(v), indeg[v]++
queue<int> q; vector<int> order;
for (int i = 1; i <= n; i++) if (!indeg[i]) q.push(i);
while (!q.empty()) {
  int u = q.front(); q.pop(); order.push_back(u);
  for (int v : g[u]) if (--indeg[v] == 0) q.push(v);
}
// 判环: order.size() < n  ⇒  有环
// DAG-DP: 按 order 转移 dp[v] = best(dp[v], dp[u] + w);

int ans = 0; bool vis[N];
int dfs(int u, int p) {                  // 返回以 u 为顶向下的最长链(节点数)
  vis[u] = true;
  int d1 = 0, d2 = 0;                    // 最长、次长向下链
  for (int v : g[u]) if (v != p) {
    int d = dfs(v, u);
    if (d > d1) { d2 = d1; d1 = d; } else if (d > d2) d2 = d;
  }
  ans = max(ans, d1 + d2 + 1);           // 过 u 的最长路径(节点数)
  return d1 + 1;                         // 只把最长链给父亲
}
// 森林: for (i) if (!vis[i]) dfs(i, 0);

// 路径 u→v 每点 +d, L = lca(u, v)
diff[u] += d; diff[v] += d; diff[L] -= d; diff[fa[L]] -= d;   // 点差分
// 边差分(挂深端点): diff[u] += d; diff[v] += d; diff[L] -= 2*d;

int dfs(int u, int p) {                  // 自底向上汇总
  int s = diff[u];
  for (int v : g[u]) if (v != p) s += dfs(v, u);
  val[u] = s; return s;
}

int st[N][20], lg[N];
// 预处理 st[i][0] = a[i]; lg[i] = lg[i/2] + 1 (i >= 2)
for (int j = 1; j < 20; j++)
  for (int i = 1; i + (1 << j) - 1 <= n; i++)
    st[i][j] = max(st[i][j-1], st[i + (1 << (j-1))][j-1]);

// 查询 [l, r]
int k = lg[r - l + 1];
int ans = max(st[l][k], st[r - (1 << k) + 1][k]);   // 两块重叠覆盖

const int LOG = 18;
int nxt[N], f[N][LOG];                    // 序列要开 2n
// f[i][0] = nxt[i]; 走不动的位置 → 哨兵(指向不会再跳进的下标)
for (int j = 1; j < LOG; j++)
  for (int i = 1; i <= n; i++)
    f[i][j] = f[f[i][j-1]][j-1];

// 落点 ≤ R 前提下尽量多跳并计步
int cur = u, steps = 0;
for (int j = LOG-1; j >= 0; j--)
  if (f[cur][j] <= R) { cur = f[cur][j]; steps += 1 << j; }

long long C[N][N];                        // C[i][j] = C(i, j),n ≤ 2000~5000
for (int i = 0; i < N; i++) {
  C[i][0] = 1;
  for (int j = 1; j <= i; j++)
    C[i][j] = (C[i-1][j-1] + C[i-1][j]) % MOD;
}

typedef long long ll;
ll power(ll a, ll b, ll mod) {            // a^b % mod
  ll r = 1; a %= mod;
  while (b > 0) { if (b & 1) r = r * a % mod; a = a * a % mod; b >>= 1; }
  return r;
}

const int MOD = 1e9 + 7;
ll fac[N];
// fac[0] = 1; for (i) fac[i] = fac[i-1] * i % MOD;
ll inv(ll x) { return power(x, MOD - 2); }     // 费马,MOD 须质数
ll C(int n, int m) {
  return fac[n] * inv(fac[m]) % MOD * inv(fac[n-m]) % MOD;
}

// 每个数把贡献加给它的倍数,O(K log K)
for (int d = 1; d <= K; d++)
  for (int m = d; m <= K; m += d)
    cnt[m] += ...;          // 如 +1 统计因数个数 / +d 求约数和