POJ 3417 network (lca+ differential on tree)

The question ：n A spanning tree of points , also m Additional edges , Delete an edge of the spanning tree and an additional edge , Make it become two connected components , There are several options .

Answer key ：lca+ The difference in the tree
For each additional edge <x, y>, take x To y Of lca Edge markers on the path , That is, delete any edge on the path , Then delete the additional edge to meet the requirements , But the premise of this method is that the edge on the path is covered only once . This is the first case ,ans++.

The second case is that the edge is not covered , Then delete the edge and it can be divided into two connected blocks , So you can delete any additional edge ,ans += m.

How to cover , Use the difference above the tree .

vector Drawing construction meeting t, Use chain forward star storage , The constant is smaller .

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
#define pii pair<int, int>
using namespace std;
const int MAXN = 1e5 + 5;
int n, m;
vector<int> v[MAXN];
int fa[MAXN][31], dep[MAXN];
int d[MAXN];
int head[MAXN], k;
struct node {
    
    int v, next;
}edge[MAXN << 1];
void add(int u, int v) {
    
    edge[++k].next = head[u];
    edge[k].v = v;
    head[u] = k;
}
void init() {
    
    for (int i = 1; i <= n; i++) v[i].clear();
    // memset(fa, 0, sizeof(fa));
    // memset(cost, 0, sizeof(cost));
    // memset(dep, 0, sizeof(dep));
}
void dfs(int root, int fno) {
       //1 0
    fa[root][0] = fno;
    dep[root] = dep[fa[root][0]] + 1;
    for (int i = 1; i < 31; ++i) {
    
        fa[root][i] = fa[fa[root][i - 1]][i - 1];
    }
    for (int i = head[root]; i; i = edge[i].next) {
    
        int v = edge[i].v;
        if (v == fno) continue;
        dfs(v, root);
    }
}
int lca(int x, int y) {
    
    if (dep[x] > dep[y]) swap(x, y);
    int tmp = dep[y] - dep[x];
    for (int j = 0; tmp; ++j, tmp >>= 1)
        if (tmp & 1) y = fa[y][j];
    if (y == x) return x;
    for (int j = 30; j >= 0 && y != x; --j) {
    
        if (fa[x][j] != fa[y][j]) {
    
            x = fa[x][j];
            y = fa[y][j];
        }
    }
    return fa[x][0];
}
void dfs1(int u, int pre) {
    
    for (int i = head[u]; i; i = edge[i].next) {
    
        int v = edge[i].v;
        if (v == pre) continue;
        dfs1(v, u);
        d[u] += d[v];
    }
}
int main() {
    
    scanf("%d%d", &n, &m);
    int x, y;
    for (int i = 1; i < n; i++) {
    
        scanf("%d%d", &x, &y);
        add(x, y);
        add(y, x);
    }
    dfs(1, 0);
    for (int i = 1; i <= m; i++) {
    
        scanf("%d%d", &x, &y);
        ++d[x];
        ++d[y];
        d[lca(x, y)] -= 2;
    }
    dfs1(1, 0);
    int ans = 0;
    for (int i = 2; i <= n; i++) {
    
        if (d[i] == 0) ans += m;
        else if (d[i] == 1) ans++;
    }
    printf("%d\n", ans);
	return 0;
}