圖算法小結

本目總結常見的圖算法。

kruskal

構造mst，按邊從小到大遍歷，如果邊的響鈴節點位於不同的集合，那麼該邊是mst當中的一條邊。這個地方需要並查集的知識。

• 題目：[jobdu-1017]
• 代碼

#include <iostream>
#include <vector>
#include <algorithm>
#define N 100
int tree[N + 8];

struct Edge {
    int u;
    int v;
    int w;
    Edge() {}
    Edge( int uu, int vv, int ww ) : u(uu), v(vv), w(ww) {}
    bool operator<( const Edge& rhs ) const {
        return w< rhs.w;
    }
};

typedef std::vector<Edge> EdgeList;

int find_root(int x){
    if( tree[x] == -1 ) return x;
    else{
        int tmp = find_root( tree[x] );
        tree[x] = tmp;
        return tmp;
    }
}

int main( void ){
    int n = 0;
    while( std::cin >> n, n ){
        EdgeList edge_list;
        for( int i = 1; i <= n; ++i ) tree[i] = -1;
        for( int i = 0; i < n*(n-1)/2; ++i ){
            int u, v, w;
            std::cin >> u >> v >> w;

            Edge edge(u, v, w);
            edge_list.push_back(edge);
        }

        std::sort( edge_list.begin(), edge_list.end() );

        int ans = 0;
        int n = edge_list.size();
        for(int i = 0; i < n; ++i){
            int uu = edge_list[i].u;
            int vv = edge_list[i].v;
            int ww = edge_list[i].w;

            int a = find_root(uu);
            int b = find_root(vv);
            if( a == b ) continue;
            else{
                ans += ww;
                tree[a] = b;
            }
        }
        std::cout << ans << std::endl;
    }
    return 0;
}

dijkstra

基於路徑長度依次遞增，所以w > 0

• 題目：[jobdu-1447]
• 代碼

#include <iostream>
#include <vector>
#include <limits.h>
#define N 100

struct Edge {
    int node;
    int weight;
    Edge() {}
    Edge( int n, int w ) : node(n), weight(w) {}
};

typedef std::vector<Edge> EdgeList;

EdgeList adj_list[N + 8];
int d[N+8];
int flag[N+8];

int dijk( int n, int s, int t );
void relax( int u, int v, int w );

int main( void ){
    int n,m;
    while(std::cin >> n >> m){
        if( !n && !m ) break;
        for( int i = 1; i <= n; ++i ) adj_list[i].clear();

        for( int i = 0; i < m; ++i ){
            int u,v,w;
            std::cin >> u >> v >> w;
            Edge edge(v,w);
            adj_list[u].push_back(edge);
            Edge edge1(u,w);
            adj_list[v].push_back(edge1);
        }

        int ans = dijk( n, 1, n );
        std::cout << ans << std::endl;
    }
    return 0;
}

int dijk( int n, int s, int t ){
    for( int i = 1; i <= n; ++i ){
        d[i] = INT_MAX;
    }
    d[s] = 0;

    for( int i = 1; i <= n; ++i ) flag[i] = 0;

    int cnt = n;
    while(cnt--){
        int u;
        int min = INT_MAX;
        for( int i = 1; i <= n; ++i ){
            if( flag[i] ) continue;
            if( d[i] < min ){
                u = i;
                min = d[i];
            }
        }

        flag[u] = 1;
        if( u == t ) break;

        int sz = adj_list[u].size();
        for( int k = 0; k < sz; ++k ){
            int v = adj_list[u][k].node;
            int w = adj_list[u][k].weight;
            relax(u, v, w);
        }
    }
    return d[t];
}

void relax( int u, int v, int w ){
    if( d[u] + w < d[v] )
        d[v] = d[u] + w;
}

bellman-ford

需要注意的是,bellman-ford的基本思路是按照層次依次鬆弛的做法。而dijk則是按照路徑長度依次遞增。整體思路不同。
bellman-ford之所以要鬆弛V-1次，原因在於，圖最長的一條路徑是他退化成鏈表的情形。此時N個頂點的圖，最長的邊爲N-1。每次，鬆弛所有邊。
如果，鬆弛完所有層次之後。
再鬆弛依次發現還可以鬆弛，那麼證明，這個圖當中存在負邊。

• 題目：同上
• 代碼

#include <iostream>
#include <vector>
#include <limits.h>
#define N 100

struct Edge {
    int node;
    int weight;
    Edge() {}
    Edge( int n, int w ) : node(n), weight(w) {}
};

typedef std::vector<Edge> EdgeList;

EdgeList adj_list[N + 8];
int d[N+8];

int bellman_ford( int n, int s, int t );
void relax( int u, int v, int w );

int main( void ){
    int n,m;
    while(std::cin >> n >> m){
        if( !n && !m ) break;
        for( int i = 1; i <= n; ++i ) adj_list[i].clear();

        for( int i = 0; i < m; ++i ){
            int u,v,w;
            std::cin >> u >> v >> w;
            Edge edge(v,w);
            adj_list[u].push_back(edge);
            Edge edge1(u,w);
            adj_list[v].push_back(edge1);
        }

        int ans = bellman_ford( n, 1, n );
        std::cout << ans << std::endl;
    }
    return 0;
}

int bellman_ford( int n, int s, int t ){
    for(int i = 1; i <= n; ++i) d[i] = INT_MAX;
    d[s] = 0;

    for( int cnt = 0; cnt < n-1; ++cnt ){ // V-1 
        // relax every edge
        for( int u = 1; u <= n; ++u ){
            int sz = adj_list[u].size();
            for( int k = 0; k < sz; ++k ){
                int v = adj_list[u][k].node;
                int w = adj_list[u][k].weight;
                relax(u, v, w);
            }
        }
    }

    for( int u = 1; u <= n; ++u ){
        int sz = adj_list[u].size();
        for( int k = 0; k < sz; ++k ){
            int v = adj_list[u][k].node;
            int w = adj_list[u][k].weight;
            if( d[u] + w < d[v] )
                return -1;
        }
    }
    return d[t];
}

void relax( int u, int v, int w ){
    if( d[u] + w < d[v] )
        d[v] = d[u] + w;
}

spfa

大體的思想來自於bellman-ford，但是，每次只是鬆弛有效的邊，不用鬆弛所有的邊。這是他的主要思想。
增加了兩個數據結構：
visited[v]，表示v這個節點是否在隊列中
count[v],表示v的入隊次數，如果超過N-1次。存在負邊，比如只有兩個頂點的圖，存在兩條邊，有一條是負的。存在這種情形。

#include <iostream>
#include <vector>
#include <limits.h>
#include <queue>
#define N 100

struct Edge {
    int node;
    int weight;
    Edge() {}
    Edge( int n, int w ) : node(n), weight(w) {}
};

typedef std::vector<Edge> EdgeList;

EdgeList adj_list[N + 8];
int d[N+8];
int visited[N+8]; // in the queue or not
int count[N+8];

int spfa( int n, int s, int t );

int main( void ){
    int n,m;
    while(std::cin >> n >> m){
        if( !n && !m ) break;
        for( int i = 1; i <= n; ++i ) adj_list[i].clear();

        for( int i = 0; i < m; ++i ){
            int u,v,w;
            std::cin >> u >> v >> w;
            Edge edge(v,w);
            adj_list[u].push_back(edge);
            Edge edge1(u,w);
            adj_list[v].push_back(edge1);
        }

        int ans = spfa( n, 1, n );
        std::cout << ans << std::endl;
    }
    return 0;
}

int spfa( int n, int s, int t ){
    for(int i = 1; i <= n; ++i) d[i] = INT_MAX;
    d[s] = 0;

    for( int i = 1; i <= n; ++i ){ visited[i] = 0; count[i] = 0; }

    std::queue<int> que;
    que.push(s);
    visited[s] = 1;
    count[s] += 1;

    while( !que.empty() ){
        int u = que.front();
        que.pop();
        visited[u] = 0;

        int sz = adj_list[u].size();
        for( int k = 0; k < sz; ++k ){
            int v = adj_list[u][k].node;
            int w = adj_list[u][k].weight;
            if( d[u] + w < d[v] ){
                d[v] = d[u] + w;
                if( visited[v] == 0 ){
                    que.push(v);
                    visited[v] = 1;
                    count[v] += 1;
                    if( count[v] > n-1 )
                        return -1;
                }
            }
        }
    }
    return d[t];
}

topsort

拓撲排序是這樣一種頂點序列，如果vi到vj存在一條邊，那麼vi排在vj的前面。具體的做法是每次尋找度爲0的點，然後刪除這些點所指向的邊。重複n次或者指導沒有度爲0的點可以刪除。

拓撲排序之所以可能存在多種的情形在於，度爲0的點選擇不同。

• 題目: [jobdu-1448]
• 代碼

#include <iostream>
#include <vector>
#include <queue>
#define N 100

typedef std::vector<int> EdgeList;
EdgeList adj_list[N + 8];
int indegree[N + 8];

int main( void ){
    int n, m;
    while( std::cin >> n >> m ){
        if( !n && !m ) break;
        for( int i = 0; i < n; ++i ){ adj_list[i].clear(); indegree[i] = 0; }
        for( int i = 0; i < m; ++i ){
            int u,v;
            std::cin >> u >> v;
            adj_list[u].push_back(v);
            ++indegree[v];
        }

        std::queue<int> q;
        for( int i = 0; i < n; ++i ){
            if( !indegree[i] )
                q.push(i);
        }

        int cnt = 0;
        while(!q.empty()){
            int u = q.front();
            q.pop();
            ++cnt;

            int sz = adj_list[u].size();
            for( int k = 0; k < sz; ++k ){
                int v = adj_list[u][k];
                --indegree[v];
                if( !indegree[v] ) q.push(v);
            }
        }

        if( cnt == n ) std::cout << "YES" << std::endl;
        else std::cout << "NO" << std::endl;
    }

    return 0;
}