2. 程式人生 > >【模板】圖論演算法模板（持更）

【模板】圖論演算法模板（持更）

阿新 • • 發佈：2019-02-20

圖論

圖論是個大板塊，建模在圖論中佔有很重要的地位，至於演算法就是理解之後程式碼多敲敲，具體的架構還是差不多的。
圖論大概有3個級別，第一級別就是沒有邊權的圖，用於遍歷或者強連通SCC跑一波等等；第二級別就是有邊權的，這下演算法多了，各種最短路和最小生成樹都有了，一二級別有時候可以合併，遍歷時沒有邊權實際上邊權就是1；然後第三級別就是有流量（dalao們的網路流），當然還有各種變種，比如說加個費用啊什麼的。

第一級別

SCC_Tarjan

struct Graph {
    struct edgetype {
        int to, next;
    };
    int
 
 n, dfs_clock, scc_cnt;
    std::vector< edgetype > edge;
    std::vector< int > head, dfn, low, scc;
    std::stack< int > Stack;
    Graph() : n(0), edge(0), head(0), dfn(0), low(0), scc(0) {}
    Graph(int n) : n(n), head(n + 1, -1), dfn(n + 1), low(n + 1), scc(n + 1) {}
    void AddEdge(int
 
 from, int to) {
        edge.push_back((edgetype){to, head[from]});
        head[from] = edge.size() - 1;
    }
    void DFS(int u) {
        dfn[u] = low[u] = ++dfs_clock;
        Stack.push(u);
        int v;
        for (int i = head[u]; i != -1; i = edge[i].next) {
            v = edge[i].to;
            if
 
 (!dfn[i]) {
                DFS(v);
                low[u] = min(low[u], dfn[v]);
            }
            else if (!scc[v])
                low[u] = min(low[u], low[v]);
        }
        if (low[u] == dfn[u]) {
            scc_cnt++;
            do {
                v = Stack.top();
                Stack.pop();
                scc[v] = scc_cnt;
            } while (u != v);
        }
    }
    int Get_SCC() {
        dfs_clock = scc_cnt = 0;
        while (!Stack.empty()) Stack.pop();
        for (int i = 1; i <= n; i++) 
            if (!dfn[i]) 
                DFS(i);
        return scc_cnt;
    }
};

第二級別

由於分塊比較多，我直接按演算法全部給出了。

SPFA

struct Graph {
    struct edgetype {
        int to, next, dist;
    };
    int n;
    std::vector< int > head;
    std::vector< long long > dist;
    std::vector< edgetype > edge;
    std::vector< bool > inQ;
    std::queue< int > Q;
    Graph() : n(0), head(0), dist(0), edge(0), inQ(0) {}
    Graph(int n, ) : n(n), head(n + 1, -1), dist(n + 1), inQ(n + 1) {}
    void AddEdge(int from, int to, int dist) {
        edge.push_back((edgetype){to, head[from], dist});
        head[from] = edge.size() - 1;
    }
    void SSSP(int s) {
        dist.assign(n + 1, 0x3f3f3f3f);
        inQ.assign(n + 1, false);
        while (!Q.empty()) Q.pop();
        Q.push(s); dist[s] = 0; inQ[s] = true;
        while (!Q.empty()) {
            int u = Q.front(); Q.pop(); inQ[u] = false;
            for (int i = head[u]; i != -1; i = edge[i].next) {
                int v = edge[i].to;
                if (dist[v] > dist[u] + edge[i].dist) {
                    dist[v] = dist[u] + edge[i].dist;
                    if (!inQ[v]) {
                        Q.push(v);
                        inQ[v] = true;
                    }
                }
            }
        }
    }
    long long Distance(int s, int t) {
        SSSP(s);
        return dist[t];
    }
};

Dijkstra

struct Graph {
    struct EdgeType {
        int to, next, dist;
    };
    struct HeapNode {
        int point;
        long long dist;
        bool operator < (const HeapNode& rhs) const {
            return dist > rhs.dist;
        }
    };
    int n;
    std::vector< int > head;
    std::vector< long long >dist;
    std::vector< bool > done;
    std::vector< EdgeType > edge;
    std::priority_queue< HeapNode > Q; 
    Graph() : n(0), head(0), dist(0), done(0), edge(0) {}
    Graph(int n) : n(n), head(n + 1, -1), dist(n + 1), done(n + 1) {}
    void AddEdge(int from, int to, int dist) {
        edge.push_back((EdgeType){to, head[from], dist});       
        head[from] = edge.size() - 1;
    }
    void SSSP(int s) {
        dist.assign(n + 1, 0x3f3f3f3f);
        done.assign(n + 1, false);
        while (!Q.empty()) Q.pop();
        Q.push((HeapNode){s, 0}); dist[s] = 0;
        while (!Q.empty()) {
            HeapNode node = Q.top(); 
            Q.pop();
            if (done[node.point]) continue;
            int u = node.point;
            done[u] = true;
            for (int i = head[u]; i != -1; i = edge[i].next) {
                int v = edge[i].to;
                if (dist[v] > dist[u] + edge[i].dist) {
                    dist[v] = dist[u] + edge[i].dist;
                    Q.push((HeapNode){v, dist[v]});
                }
            }
        }
    }
    long long Distance(int s, int t) {
        SSSP(s);
        return dist[t];
    }
};

Kruskal

struct Graph { 
    struct edgetype { 
        int from, to, dist; 
        bool operator < (const edgetype& rhs) const {
            return dist < rhs.dist;
        }
    };  
    int n;
    std::vector< edgetype > edge; 
    std::vector< int > f;
    Graph() : n(0), edge(0), f(0) {}  
    Graph(int n) : n(n), f(n + 1) {}
    void AddEdge(int from, int to, int dist) {  
        edge.push_back((edgetype){from, to, dist});  
    }  
    inline int FindRoot(int x) {
        return f[x] == x ? x : f[x] = FindRoot(f[x]);
    }
    long long MST() {
        int num = 0;
        long long ans = 0;
        for (int i = 1; i <= n; i++) f[i] = i;
        sort(edge.begin(), edge.end());
        for (unsigned int i = 0; i < edge.size(); i++) {
            int fu = FindRoot(edge[i].from);
            int fv = FindRoot(edge[i].to);
            if (fu != fv) {
                f[fu] = fv;
                ans += edge[i].dist;
                if (++num == n - 1) break;
            }
        }
        return ans;
    }
};

Prim

struct Graph {
    struct edgetype {
        int to, next, dist;
    };
    struct heapnode {
        int point, dist;
        bool operator < (const heapnode& rhs) const {
            return dist > rhs.dist;
        }
    };
    int n;
    std::vector< int > head, dist;
    std::vector< edgetype > edge;
    std::priority_queue< heapnode > Q; 
    Graph() : n(0), head(0), dist(0), edge(0) {}
    Graph(int n) : n(n), head(n + 1, -1), dist(n + 1) {}
    inline void AddEdge(int from, int to, int dist) {
        edge.push_back((edgetype){to, head[from], dist});       
        head[from] = edge.size() - 1;
    }
    long long MST() {
        long long ans = 0;
        dist.assign(n + 1, 0x3f3f3f3f);
        while (!Q.empty()) Q.pop();
        Q.push((heapnode){1, 0});
        dist[1] = 0;
        while (!Q.empty()) {
            int u = Q.top().point;
            Q.pop();
            ans += dist[u];
            dist[u] = 0;
            for (int i = head[u]; i != -1; i = edge[i].next) {
                int v = edge[i].to;
                if (dist[v] > edge[i].dist) {
                    dist[v] = edge[i].dist;
                    Q.push((heapnode){v, dist[v]});
                }
            }
        }
        return ans;
    }
};

Negative_Cycle

struct Graph {
    struct edgetype {
        int to, next, dist;
    };
    int n;
    std::vector< int > head, dist;
    std::vector< edgetype > edge;
    std::vector< bool > visit;
    Graph() : n(0), head(0), dist(0), edge(0), visit(0) {}
    Graph(int n) :n(n), head(n + 1, -1), dist(n + 1), visit(n + 1) {}
    void AddEdge(int from, int to, int dist) {
        edge.push_back((edgetype){to, head[from], dist});
        head[from] = edge.size() - 1;
    }
    void Negative_Cycle_Search(bool& exist, int u) {
        if (exist) return;
        visit[u] = true;
        for (int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if (dist[v] > dist[u] + edge[i].dist) {
                dist[v] = dist[u] + edge[i].dist;
                if (visit[v]) {
                    exist = true;
                    return;
                }
                Negative_Cycle_Search(exist, v);
            }
        }
        visit[u] = false;
    }
    bool Negative_Cycle() {
        dist.assign(n + 1, 0);
        visit.assign(n + 1, false);
        bool exist = false;
        for (int i = 1; i <= n && !exist; i++) 
            Negative_Cycle_Search(exist, i);
        return exist;
    }
};

第三級別

最大流

連續最短增廣路（Dinic）

struct Graph {
    static const int infty = 0x7f7f7f7f;
    struct edgetype {
        int to, next, flow, cap;
    };
    int n, s, t;
    std::vector< edgetype > edge;
    std::vector< bool > visit;
    std::vector< int > head, d, cur;
    std::queue< int > Q;
    Graph() : n(0), edge(0), visit(0), head(0), d(0), cur(0) {}
    Graph(int n) : n(n), visit(n + 1), head(n + 1, -1), d(n + 1), cur(n + 1) {}
    void AddEdge(int from, int to, int cap) {
        edge.push_back((edgetype){to, head[from], 0, cap});
        head[from] = edge.size() - 1;
        edge.push_back((edgetype){from, head[to], 0, 0});
        head[to] = edge.size() - 1;
    }
    bool BFS() {
        visit.assign(n + 1, false);
        d.assign(n + 1, 0);
        while (!Q.empty()) Q.pop();
        Q.push(s); visit[s] = true;
        while (!Q.empty()) {
            int u = Q.front(); Q.pop();
            for (int i = head[u]; i != -1; i = edge[i].next) {
                int v = edge[i].to;
                if (!visit[v] && edge[i].flow < edge[i].cap) {
                    visit[v] = true;
                    d[v] = d[u] + 1;
                    Q.push(v);
                }
            }
        }
        return visit[t];
    }
    long long DFS(int u, int alpha) {
        if (u == t || alpha == 0) return alpha;
        long long flow = 0, f;
        for (int& i = cur[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if (d[u] + 1 == d[v] && (f = DFS(v, min(alpha, edge[i].cap - edge[i].flow))) > 0) {
                edge[i].flow += f; edge[i ^ 1].flow -= f; flow += f; alpha -= f;
                if (alpha == 0) break;
            }
        }
        return flow;
    }
    long long Maxflow(int s, int t) {
        this->s = s; this->t = t;
        long long maxflow = 0;
        while (BFS()) {
            cur.assign(head.begin(), head.end());
            maxflow += DFS(s, infty);
        }
        return maxflow;
    }
};

一般預流推進

struct Graph {
    static const int infty = 0x7f7f7f7f;
    struct edgetype {
        int to, next, flow, cap;
    };
    int n, s, t;
    std::vector< edgetype > edge;
    std::vector< int > head, h, excess;
    std::queue< int > Q;
    Graph() : n(0), edge(0), head(0), h(0), excess(0) {}
    Graph(int n) : n(n), head(n + 1, -1), h(n + 1), excess(n + 1) {}
    void AddEdge(int from, int to, int cap) {
        edge.push_back((edgetype){to, head[from], 0, cap});
        head[from] = edge.size() - 1;
        edge.push_back((edgetype){from, head[to], 0, 0});
        head[to] = edge.size() - 1;
    }
    void Push(int u, long long& maxflow) {
        for (int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            int f = min(edge[i].cap - edge[i].flow, excess[u]);
            if (f > 0 && (u == s || h[u] == h[v] + 1)) {
                edge[i].flow += f; edge[i ^ 1].flow -= f;
                excess[u] -= f; excess[v] += f;
                if (v == t) maxflow += f;
                else if (v != s) Q.push(v);
            }
        }
    }
    void Relabel(int u) {
        if (u != s && u != t && excess[u] > 0) h[u]++, Q.push(u); 
    }
    long long Maxflow(int s, int t) {
        this->s = s; this->t = t;
        long long maxflow = 0;
        excess.assign(n + 1, 0);
        h.assign(n + 1, 0); h[s] = n;
        excess[s] = infty; excess[t] = -infty;
        Q.push(s);
        while (!Q.empty()) {
            int u = Q.front();
            Q.pop();
            Push(u, maxflow);
            Relabel(u);
        }
        return maxflow;
    }
};

最大標號預流推進

struct Graph {
    static const int infty = 0x7f7f7f7f;
    struct edgetype {
        int to, next, flow, cap;
    };
    struct node {
        int u, d;
        bool operator < (const node& rhs) const {
            return d < rhs.d;
        }
    };
    int n, s, t;
    std::vector< edgetype > edge;
    std::vector< int > head, h, excess;
    std::priority_queue< node > Q;
    Graph() : n(0), edge(0), head(0), h(0), excess(0) {}
    Graph(int n) : n(n), head(n + 1, -1), h(n + 1), excess(n + 1) {}
    void AddEdge(int from, int to, int cap) {
        edge.push_back((edgetype){to, head[from], 0, cap});
        head[from] = edge.size() - 1;
        edge.push_back((edgetype){from, head[to], 0, 0});
        head[to] = edge.size() - 1;
    }
    void Push(int u, long long& maxflow) {
        for (int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            int f = min(edge[i].cap - edge[i].flow, excess[u]);
            if (f > 0 && (u == s || h[u] == h[v] + 1)) {
                edge[i].flow += f; edge[i ^ 1].flow -= f;
                excess[u] -= f; excess[v] += f;
                if (v == t) maxflow += f;
                else if (v != s) Q.push((node){v, h[v]});
            }
        }
    }
    void Relabel(int u) {
        if (u != s && u != t && excess[u] > 0) h[u]++, Q.push((node){u, h[u]}); 
    }
    long long Maxflow(int s, int t) {
        this->s = s; this->t = t;
        long long maxflow = 0;
        excess.assign(n + 1, 0);
        h.assign(n + 1, 0); h[s] = n;
        excess[s] = infty; excess[t] = -infty;
        Q.push((node){s, n});
        while (!Q.empty()) {
            int u = Q.top().u;
            Q.pop();
            Push(u, maxflow);
            Relabel(u);
        }
        return maxflow;
    }
};

最小費用最大流

struct Graph {
    static const int infty = 0x7f7f7f7f;
    struct edgetype {
        int to, next, flow, cap, cost;
    };
    int n, s, t;
    std::vector< edgetype > edge;
    std::vector< bool > inQ;
    std::vector< int > head, dist, path;
    std::queue< int > Q;
    Graph() : n(0), edge(0), inQ(0), head(0), dist(0), path(0) {}
    Graph(int n) : n(n), inQ(n + 1), head(n + 1, -1), dist(n + 1), path(n + 1) {}
    void AddEdge(int from, int to, int cap, int cost) {
        edge.push_back((edgetype){to, head[from], 0, cap, cost});
        head[from] = edge.size() - 1;
        edge.push_back((edgetype){from, head[to], 0, 0, -cost});
        head[to] = edge.size() - 1;
    }
    bool FindPath() {
        dist.assign(n + 1, infty);
        inQ.assign(n + 1, false);
        path.assign(n + 1, -1);
        while (!Q.empty()) Q.pop();
        Q.push(s); dist[s] = 0; inQ[s] = true; 
        while (!Q.empty()) {
            int u = Q.front(); Q.pop(); inQ[u] = false;
            for (int i = head[u]; i != -1; i = edge[i].next) {
                int v = edge[i].to;
                if (edge[i].flow < edge[i].cap && dist[v] > dist[u] + edge[i].cost) {
                    dist[v] = dist[u] + edge[i].cost; path[v] = i; 
                    if (!inQ[v]) {
                        Q.push(v);
                        inQ[v] = true;
                    }
                }
            }
        }
        return path[t] != -1;
    }
    void Argument(long long& Maxflow, long long& Mincost) {
        long long alpha = infty;
        for (int i = path[t]; i != -1; i = path[edge[i ^ 1].to]) 
            alpha = min(alpha, edge[i].cap - edge[i].flow);
        Maxflow += alpha; Mincost += dist[t] * alpha;
        for (int i = path[t]; i != -1; i = path[edge[i ^ 1].to]) {
            edge[i].flow += alpha;
            edge[i ^ 1].flow -= alpha;
        }
    }
    std::pair< long long, long long > MincostMaxflow(int s, int t) {
        this->s = s; this->t = t;
        long long Maxflow = 0, Mincost = 0;
        while (FindPath())
            Argument(Maxflow, Mincost);
        return std::make_pair(Maxflow, Mincost);
    }
};

這也要慢慢來，，，總結總是需要時間的

相關推薦

【模板】圖論演算法模板（持更）

圖論 圖論是個大板塊，建模在圖論中佔有很重要的地位，至於演算法就是理解之後程式碼多敲敲，具體的架構還是差不多的。 圖論大概有3個級別，第一級別就是沒有邊權的圖，用於遍歷或者強連通SCC跑一波等等；第二級別就是有邊權的，這下演算法多了，各種最短路和最

【NOIp複習】圖論演算法模板合集

最小生成樹 Kruskal //Kruskal struct edge{ int from,to,val; }e[maxn]; bool operator < (const

【ACM】杭電OJ 1284（待更）

#include<iostream> using namespace std; int main(){ int n; while(cin>>n){ int ans=0; for(int i=0;i<=n/3;i++){ /

【ACM】杭電OJ 2036（待更）

AC程式碼  #include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <cstdlib> #include &l

【模板】圖論

線段樹優化 cpp 算法 圖論 n) while uil ont 堆優化 基礎圖論 鏈式前向星 帶權值 int head[400001],ver[2000001],nxt[2000001],val[2000001],tot=0; void add(int x,int y,i

圖論演算法模板

Under the bridge downtown Forgot about my love Under the bridge downtown I gave my life away Luogu P4779【模板】單源最短路徑（標準版） //時間複雜度O((n+m)log

【LeetCode】圖論 graph（共20題）

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px Helvetica } 【133】Clone Graph  【207】Course Schedule  【210】Course Schedule II  【261】G

模板庫(三) - 圖論演算法模板

寫在前面 “模板庫”這一系列文章用來複習 O I OI

【模板】POJ 2449 K短路（A*+dijkstra）

Remmarguts’ Date Time Limit: 4000MS Memory Limit: 65536K Total Submissions: 28521 Accepted: 7746 Descriptio

【NTT】【多項式】多項式快速插值（log^3）模板

#include<cstdio> #include<cstring> #include<algorithm> #include<cmath> #define SF scanf #define PF printf #define MAXN 3

Luogu3835 【模板】可持久化平衡樹（fhq-treap）

　　fhq-treap，也即非旋treap，可以在不進行旋轉操作的前提下維護treap。由於不需要旋轉，可以對其可持久化。 　　fhq-treap的基本操作是merge和split，並且通過這兩個操作實現對treap的各項維護。 　　merge用來合併兩棵treap，且要求滿足其中一棵treap中的最小值

【NOIP2017模擬賽】思維+轉化+圖論 徒然Children（好題）

題目描述 全世界都在談戀愛，只有我深愛著學習。——前言。 2333身為單身狗卻意外喜歡的吃狗糧的yuki堅信著：“自古紅藍出cp，黑白天生是夫妻，最是銷魂紅綠配，天然金紫成雙對，生死相隨紅與黃，白紫一逢春滿堂，千里緣牽白與綠，紅黑生來為相聚。”的cp配對原則

【結論】圖論相關結論

ron n-2 pan 計數 完全 blog strong size tro 一、生成樹相關 　　1.完全圖生成樹計數 n^n-2 　　2.左邊n個點右邊m個點的完全圖生成樹計數 (n^m-1)*(m^n-1) 　　3..... ……【結論】圖論相關結論

【WIP_S9】圖論算法

bsp idt pan 關系 order center table -a -s 創建: 2018/06/01 圖的概念 有向邊 有向圖 無向邊 無向圖 點的次數: 點連接的邊的數量 閉路: 起點和重點一樣 連接圖: 任意兩點之間都可到

【TensorFlow原始碼系列】【四】圖優化演算法：constant folding和CSE

TensorFlow中使用的圖優化演算法有：constant folding 和CSE（common-subexpression elimination） 【演算法一】constant folding 該演算法，是將graph中常量的計算合併起來。例如： C = A+B，其中A和B都是con

【精選】JAVA入門演算法題（一）

跌倒了，一定要爬起來。不爬起來，別人會看不起你，你也會失去機會。 1.題目：打印出楊輝三角形（要求打印出10行） 什麼是楊輝三角呢？下面這個就是 楊輝三角最大的特性就是每個數字都是該數字肩上的兩個數字之和，這道題經常在學習二維陣列和迴圈控制中出現 我們可以假設

【收集】圖論相關原理 持續更新

原文：http://blog.csdn.net/leolin_/article/details/7199688 最小邊覆蓋 = 最大獨立集 = |V| - 最大匹配數 這個是在原圖是二分圖上進行的 最小路徑覆蓋和最小邊覆蓋不同，不要求給的圖是二分圖，而是要求是N x N的有向圖

【精選】JAVA入門演算法題（三）

把敬業變成習慣。短期來看是為了僱主，長期來看是為了自己。 1.題目：輸入一行字元，分別統計出其中英文字母、空格、數字和其它字元的個數。 估計統計字元是所有人都做過的題 這裡給出兩種思路，第一種思路是比較ASCII碼，第二種是使用正則匹配 private static

【精選】JAVA入門演算法題（四）

把敬業變成習慣。短期來看是為了僱主，長期來看是為了自己。 1.題目：全排列問題 這種問題在演算法題中應用很多,主要思路是使用遞迴來求，求n個數的全排列就是把第一個數固定後求n-1個數的全排列，不斷遞迴到只有一個數 private static void Method1(

【精選】JAVA入門演算法題（二）

時時要有危機意識。別以為你命好運也好。 1.題目：打印出所有的 水仙花數 ，所謂 水仙花數 是指一個三位數，其各位數字立方和等於該數本身。 例如：153是一個 水仙花數 ，因為153=1的三次方＋5的三次方＋3的三次方。 題非常簡單，只要用for迴圈，取出數的個位、十位