图论小结

一.图论的基本概念

• 有向图(有向边)，无向图(无向边)，顶点集合，边集合，顶点数(阶)，边数；
• 完全图，有向完全图，稀疏图，稠密图，平凡图(只有一个顶点)，零图(没有边)；
• 顶点的度数，奇点，偶点，最小度，最大度；
• 基本定理：度数之和等于边数的两倍；
• 度序列，可图(有限序列是度序列)；
• Havel-Hakimi定理：判断序列是否可图；
• 二部图(偶图)，完全二部图，二部图判定(无奇圈)；
• 同构；
• 子图，生成树(极小(边数)连通子图)；
• 路径(通路)，简单路径，回路，简单回路(圈)；
• 连通性，连通分量(极大(顶点数)连通子图)，强连通图，强连通分量；
• 权值，加权图(网络)，有向网，无向网；
• 邻接矩阵，邻接表。

二. 图和树

具有V个顶点的图G满足下列条件之一，就是一棵树：
1. 有V-1条边，且无环；
2. 有V-1条边，且连通；
3. 连通，删除任意一边就不连通了；
4. 无环，增加任意一边就有环了；
5. 任意两个顶点仅存在一条简单路径；

三. 构建图

class Graph {
private:
    int V;  //顶点数，假设1~V
    int E;  //边数
    vector<list<int>> adj; //邻接表
    vector<int> visited;    //是否访问，DFS和BFS用到
public:
    Graph(int v) : V(v), E(0) {
        adj = vector<list<int>>(v);
        visited.resize(v, 0);   //初始为0
    }

    void addEdge(int v, int w) {
        ++E;
        adj[v - 1].push_back(w);    //相邻节点放入邻接表
        adj[w - 1].push_back(v);
    }
    void addVertex() {
        //顶点默认为V+1
        ++V;
        visited.push_back(0);
        adj.push_back(list<int>());
    }
    int getV() const { return V; }
    int getE() const { return E; }
    list<int> getAdj(int v) const{
        return adj[v - 1];
    }
    int& getVisited(int v) {
        return visited[v - 1];
    }
    void reset() {
        for(int i = 0; i < V; ++i) {
            visited[i] = 0;
        }
    }
};

使用邻接表形式存储，用C++语言实现则是：vector和list结合起来使用。动态增加顶点集和边集还好，动态减少感觉有点复杂，暂时没想清楚。

四. 常见的API

1. 查找与顶点v连通的所有节点， 返回集合， 使用DFS。

vector<int> Search(Graph &G, int v) {
    //采用DFS
    DFS(G, v);
    vector<int> result(G.getV());
    int j = 0;
    for(int i = 1; i <= G.getV(); ++i) {
        if(G.getVisited(i) == 1) {
            result[j++] = i;
        }
    }
    G.reset();    //重置DFS的visited
    result.resize(j);
    return result;
}

1. 查找与顶点v连通的所有节点的个数。

int Count(Graph &G, int v) {
    return Search(G, V).size();
}

1. 判断两个顶点v, w是否是连通的(这里也可以使用我们之前介绍的并查集算法——Union Find)。

bool IsConnected(Graph &G, int v, int w) {
    DFS(G, v);
    bool ic = G.getVisited(w);
    G.reset();     //重置DFS的visited
    return ic;
}

五. DFS与BFS

深度优先搜索： Depth First Search.
深度优先搜索的思想很简单，就和我们牵着绳子走迷宫一样:
- 选择一条没有标记过的通路，在走过的每一条路上都铺上绳子(等价于visited对应位置标为1)；
- 标记第一次走过的路口；
- 当来到一个已经被标记的路口时，回退到上一个路口；
- 当回退到的路口已经没有可走的通路时，继续回退。

void DFS(Graph &G, int v) {
    G.getVisited(v) = 1;
    for(auto w : G.getAdj(v)) {
        if(!G.getVisited(w)) {
            DFS(G, w);
        }
    }
}

未完待续