[暑假前集训]图论

---

2022年暑假前集训——图论

[题A]蜘蛛的网

解题思路

引入定义

图的边连通度：对于给定的无向图，如果至少删除\(K\)条边，可以使这个图不连通，则\(K\)称为图的边连通度;

无向图的割：有无向图\(G = (V, E)\),设\(C\)为图\(G\)中一些弧的集合，若从\(G\)中删去\(C\)中的所有弧能使图\(G\)不是连通图，称\(C\)图\(G\)的一个割;

全局最小割：包含的弧的权和最小的割，称为全局最小割。

显然，对于弧权均为1的图，求出全局最小割的大小，即可求出图的边连通度

而对于全局最小割的大小，有Stoer-Wagner算法可以求解

PS. Stoer-Wagner算法学习结合OI Wiki 和一篇博客

代码

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int INF = 1e9;
int sumw[310], n, m, edg[310][310];
bool vis[310], dlt[310];
int stcut(int &s, int &t){
    memset(sumw, 0, sizeof(sumw));
    memset(vis, 0, sizeof(vis));
    int maxw, k, mincut;
    for(int i = 1; i <= n; i++){
        maxw = -1, k = -1;
        for(int j = 1; j <= n; j++){
            if(!dlt[j] && !vis[j] && sumw[j] > maxw) 
                k = j, maxw = sumw[j];
        }
        if(k == -1) return mincut;
        s = t, t = k, mincut = maxw, vis[k] = 1;
        for(int j = 1; j <= n; j++)
            if(!dlt[j] && !vis[j]) sumw[j] += edg[j][k];
    }
    return mincut;
}
int Stoer_Wager(){
    int mincut = INF, s, t;
    for(int i = 1; i < n; i++){
        mincut = min(mincut, stcut(s, t));
        dlt[t] = 1;
        for(int j = 1; j <= n; j++)
            if(!dlt[j]) edg[s][j] = (edg[j][s] += edg[t][j]);
    }
    return mincut;
}

int main(){
    ios::sync_with_stdio(false);
    cin >> n >> m;
    int u, v;
    for(int i = 1; i <= m; i++){
        cin >> u >> v;
        edg[u][v] = edg[v][u] = 1;
    }
    cout << Stoer_Wager() << endl;
    return 0;
}

---

[K题]居民都居住在房屋里

解题思路

给定图中任意两点间有且只有一条路径可达，显然给定的图是一颗树

则问题即\(m\)次查询树上两点间距离，即两点到其公共祖先的距离之和

使用常用的倍增法求LCA

#include <iostream>
#include <cstdio>
using namespace std;

struct Edges{ int v, nxt; } edg[1000010]; int fir[500010], ct = 0;
void add(int u, int v){
    edg[++ct] = (Edges){v, fir[u]}, fir[u] = ct;
}

int dep[500010], fa[500010][22], lg[500010];
void dfs(int u, int frm){
    fa[u][0] = frm, dep[u] = dep[frm] + 1;
    for(int i = 1; i <= lg[dep[u]]; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
    for(int i = fir[u]; i; i = edg[i].nxt) 
        if(edg[i].v != frm) dfs(edg[i].v, u);
}
int lca(int x, int y){
    if(dep[x] < dep[y]) swap(x, y);
    while(dep[x] > dep[y]) x = fa[x][lg[dep[x] - dep[y]] - 1];
    if(x == y) return x;
    for(int k = lg[dep[x]] - 1; k >= 0; k--)
        if(fa[x][k] != fa[y][k]) x = fa[x][k], y = fa[y][k];
    return fa[x][0];
}

int main(){
    int n, m, u, v, x, y, cofa;
    scanf("%d%d", &n, &m);
    for(int i = 1; i < n; i++){
        scanf("%d%d", &u, &v);
        add(u, v), add(v, u);
    }
    for(int i = 1; i <= n; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
    dfs(1, 0);
    for(int i = 1; i <= m; i++){
        scanf("%d%d", &x, &y), cofa = lca(x, y);
        printf("%d\n", dep[x] + dep[y] - 2 * dep[cofa]);
    }
    return 0;
}

---

[O题]纯白色的少年郎，如今只身在何方

解题思路

单源最短路模板
使用堆优化Dijkstra解决

代码

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

typedef long long ll;
struct Edges{int v, w, nxt;}edg[200010]; int ct = 0, fir[100010];
struct Nodes{
    ll d; int id;
    bool operator < (const Nodes &a) const {return d > a.d;}
};
void add(int u, int v, int w){
    edg[++ct] = (Edges){v, w, fir[u]}, fir[u] = ct;
}
const ll INF = 1e18; ll dis[100010]; bool vis[100010];
priority_queue <Nodes> que;
void dijkstra(int s){
    dis[s] = 0, que.push((Nodes){0, s});
    while(!que.empty()){
        int u = que.top().id; que.pop(); if(vis[u]) continue; vis[u] = 1;
        for(int i = fir[u]; i; i = edg[i].nxt){
            int v = edg[i].v;
            if(dis[u] + (ll)edg[i].w < dis[v])
                dis[v] = dis[u] + (ll)edg[i].w, que.push((Nodes){dis[v], v});
        }
    }
}

int main(){
    int n, m, s, u, v, w;
    scanf("%d%d%d", &n, &m, &s);
    for(int i = 1; i <= m; i++) scanf("%d%d%d", &u, &v, &w), add(u, v, w);
    for(int i = 1; i <= n; i++) dis[i] = INF;
    dijkstra(s);
    for(int i = 1; i <= n; i++) 
        printf("%lld\n", dis[i] != INF ? dis[i] : -1);
    return 0;
}

---

[C题]魔法少女

解题思路

看作有一个\((N+1)*(M+1)\)的方阵图，每个小方形的顶点为图中的点，对角线为图中的边。
左上角点序号为\(1\),右下角点序号为\((N+1)*(M+1)\)，
对于读入的符号，看作权值为0的边，而未读入的对角线看作权值为1的边，
在上述图中求起点到终点的最短路即为所求答案。

代码

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

struct Edges{int v, w, nxt;}edg[1000010]; int ct = 0, fir[300010];
struct Nodes{
    int d, id;
    bool operator < (const Nodes &a) const {return d > a.d;}
};
void add(int u, int v, int w){
    edg[++ct] = (Edges){v, w, fir[u]}, fir[u] = ct;
    edg[++ct] = (Edges){u, w, fir[v]}, fir[v] = ct;
}
int dis[300010]; const int INF = 1e9; bool vis[300010];
priority_queue <Nodes> que;
void dijkstra(){
    dis[1] = 0; que.push((Nodes){0, 1});
    while(!que.empty()){
        int u = que.top().id; que.pop(); if(vis[u]) continue; vis[u] = 1;
        for(int i = fir[u]; i; i = edg[i].nxt){
            int v = edg[i].v;
            if(dis[u] + edg[i].w < dis[v])
                dis[v] = dis[u] + edg[i].w, que.push((Nodes){dis[v], v});
        }
    }
}

int main(){
    int n, m; char c;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            scanf(" %c", &c);
            add((i - 1) * (m + 1) + j, i * (m + 1) + j + 1, (int)c == 92 ? 0 : 1);
            add(i * (m + 1) + j, (i - 1) * (m + 1) + j + 1, c == '/' ? 0 : 1);
        }
    }
    int tag = (n + 1) * (m + 1);
    for(int i = 1; i <= tag; i++) dis[i] = INF;
    dijkstra();
    if(dis[tag] != INF) printf("%d\n", dis[tag]);
    else printf("NO SOLUTION\n");
    return 0;
}

---

[L题]最小生成树

解题思路

实际上是最小生成树计数问题
首先考虑生成树计数问题，需要引入矩阵树定理

\(Matrix-Tree \ Theorem:\)设图\(G=(V,E),\)构造\(G\)的拉普拉斯矩阵\(L,\)则\(G\)的生成树的个数等于\(detL_0,\)其中\(L_0\)是去掉\(L\)第\(i\)行第\(i\)列的子矩阵（\(i\)任意）。
其中\(L(G)\)是一个\(n\times n\)矩阵(\(n\)为节点数)，且

\[L_{i,j}= \begin{cases} -m_{i,j}, \ i\ne j\ (m_{i,j}是v_i与v_j之间的边数)\\ deg(v_i),\ i=j \end{cases}\]

详细证明见知乎文章，其中引理\(Binet-Cauchy\ 定理\)的证明见百度百科

然后考虑最小生成树的性质，若按照边的权值大小将边分为若干组，在\(Kruskal\)求最小生成树的过程中，从每一组边中选择的边数必相等，且每处理完一组边，将这组中被选择的边加入图中后，图的连通性是固定的。

那么考虑\(Kruska\)l的过程，从最小权值的边集开始，将这些边全部加入图中，形成若干连通块，对这若干连通块分别利用矩阵树定理求最小生成树的数量（记为\(t_i\)），然后将每一个连通块缩点，再处理权值第二小的边集，重复上述过程，直至\(Kruskal\)结束。则$ \prod t_i$即为全图最小生成树个数。

\(Ps.\)求矩阵的行列式要用到高斯消元法,时间复杂度为\(O(n^3)\),由于题目要求取模，且计算过程涉及到除法，正常情况下要用到乘法逆元。本题中模数为合数，部分数无逆元，所以用辗转相除法消元

• 缩点过程用并查集实现，遍历连通块过程中将所有点指向同一父节点，后续加边过程中将连通块内点用这一父节点代替
• 对于高斯消元的相关学习见某博客

代码

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

struct Edges{ int u, v, w; }e[1010];
struct realEdges{ int v, w, nxt; } edg[2020]; int ct = 0, fir[1010];
int n, m, L[110][110], num, fa[110], pos[110]; const int p = 10000;
bool cmp(Edges a, Edges b){ return a.w < b.w; }
int find(int x){ return (fa[x] ? fa[x] = find(fa[x]) : x); }
void add(int i){
    int u = find(e[i].u), v = find(e[i].v);
    edg[++ct] = (realEdges){v, e[i].w, fir[u]}, fir[u] = ct;
    edg[++ct] = (realEdges){u, e[i].w, fir[v]}, fir[v] = ct;
} 
void dfs(int u, int w, int fu){
    if(u != fu) fa[u] = fu;
    pos[u] = num++;
    for(int i = 0; i <= pos[u]; i++) L[i][pos[u]] = L[pos[u]][i] = 0;
    for(int i = fir[u]; edg[i].w == w; i = edg[i].nxt){
        int v = edg[i].v;
        if(pos[v] == -1) dfs(v, w, fu);
        L[pos[u]][pos[v]]--, L[pos[u]][pos[u]]++;
    }
}
int solve(int L[110][110], int n){
    int det = 1; n--;
    for(int i = 0; i < n; i++){
        for(int j = i + 1; j < n; j++){
            while(L[j][i]){
                int t = L[i][i] / L[j][i];
                for(int k = i; k < n; k++) 
                    L[i][k] = (L[i][k] - 1ll * L[j][k] * t % p + p) % p;
                swap(L[i], L[j]), det *= -1;
            }
            if(!L[i][i]) return 0;
        }
        det = 1ll * det * L[i][i] % p;
    }
    return (det + p) % p;
}
int ans = 1;
void Divide(){
    for(int i = 0; i < m; ){
        int j = i;
        while(j < m && e[j].w == e[i].w) j++;
        for(int k = i; k < j; k++) add(k);
        for(int k = 1; k <= n; k++) pos[k] = -1;
        for(int k = 1; k <= n; k++) if(find(k) == k){
            num = 0, dfs(k, e[i].w, k);
            ans = ans * solve(L, num) % p;
        }
        i = j;
    }
}

int main(){
    ios::sync_with_stdio(false);
    int u, v, w;
    cin >> n >> m;
    for(int i = 0; i < m; i++) cin >> e[i].u >> e[i].v >> e[i].w;
    sort(e, e + m, cmp);
    Divide();
    int t = 0;
    for(int i = 1; i <= n; i++) t += (find(i) == i);
    printf("%d\n", t > 1 ? 0 : ans);
    return 0;
}

---

[J题]tarjan

解题思路

\(tarjan\)求割点、桥以及点双的问题模板
\(tarjan\)的\(dfs\)过程中，当前节点为\(u\),目标子节点为\(v\),所在树根节点为\(root\)

若\(low_v \ge dfn_u \land u \ne root\),则\(u\)为割点，所维护栈中从栈顶到\(v\)的点及点\(u\)构成点双
若存在两个及以上子节点满足\(low_v \ge dfn_u\)，则\(root\)为割点
若\(low_v > dfn_u\)则边\(u \to v\)是桥

代码

#include <iostream>
#include <cstdio>
using namespace std;
struct Edges { int v, nxt; }edg[1000010]; int ct = 0, fir[1010];
void add(int u, int v) { edg[++ct] = (Edges){v, fir[u]}, fir[u] = ct; }
int dfn[1010], low[1010], fa[1010], vn, en, col[1010];
int sta[1000010], til, cirmax, cirn, cir[1010], t2, e[1010][1010];
void countcir(){
    int ret = 0;
    for(int i = 1; i <= t2 - 1; i++){
        for(int j = i + 1; j <= t2; j++){
            if(e[cir[i]][cir[j]]) ret++;
        }
    }
    cirmax = max(cirmax, ret);
}
void tarjan(int u, int rt, int k){
    dfn[u] = low[u] = ++ct; int flg = 0;
    for(int i = fir[u]; i; i = edg[i].nxt){
        int v = edg[i].v; if(v == fa[u]) continue;
        if(!dfn[v]){
            fa[v] = u, sta[++til] = i;
            tarjan(v, rt, i), low[u] = min(low[u], low[v]);
            en += (low[v] > dfn[u]);
            if(low[v] >= dfn[u]){
                t2 = 0, flg++;
                while(sta[til] != i) cir[++t2] = edg[sta[til--]].v;
                til--, cir[++t2] = v, cir[++t2] = u, countcir(), cirn++;
            }
        }else low[u] = min(low[u], dfn[v]);
    }
    vn += (u == rt && flg > 1 || u != rt && flg);
}
        
int main(){
    ios::sync_with_stdio(false);
    int n, m, u, v;
    cin >> n >> m;
    for(int i = 1; i <= m; i++){
        cin >> u >> v;
        add(u, v), add(v, u);
        e[u][v] = e[v][u] = 1;
    }
    ct = 0;
    for(int i = 1; i <= n; i++) if(!dfn[i]) tarjan(i, i, 0);
    cout << vn << ' ' << en << ' ' << cirn << ' ' << cirmax << endl;
    return 0;
}