【算法第四版 读书笔记】图——有向图

//有向图的数据类型
class Digraph
{
private:
    int V;
    int E;
    int* adj;
public:
    Digraph(int V);                      //创建一个含有V个顶点不含边的有向图
    int V() { return V; }                //顶点总数
    int E() { return E; }                //边的总数
    void addEdge(int v, int w);          //添加一条边v->w
    int& adj(int v) { return adj[v]; }   //又v指出边所连接的所有顶点
    Digraph reverse();                   //该图的反向图
    String toString();                   //对象的字符串表示
}

Digraph::Digraph(int v)
{
    V = v;
    E = 0;
    adj = new int[v];
    for (int i = 0; i < V; ++i)
    {
        adj[i] = new int[V - 1];
        adj[i] = 0;
    }
}

void Digraph::addEdge(int v, int w)
{
    adj[v].add(w);
    E++;
}

Digraph::reverse()
{
    Digraph R = new Digraph(V);
    for (int v = 0; v < V; ++v)
        for (int w : adj(v))
            R.addEdge(w, v);
    return R;
}


//有向图的可达性
//代码同无向图


//寻找有向环
class DirectedCycle
{
private:
    bool* marked;
    int* edgeTo;
    stack<int> cycle;
    bool* onStack;
    void dfs(Digraph G, int v)
    {
        onStack[v] = true;
        marked[v] = true;
        for (int w : G.adj(v))
        {
            if (hasCycle()) return;
            else if(!marked[w])
            {
                edgeTo[w] = v;
                dfs(G, w);
            }
            else if (onStack[w])
            {
                for (int x = v; x != w; x = edgeTo[x])
                    cycle.push(x);
                cycle.psuh(w);
                cycle.push(v);
            }
        }
        onStack[v] = false;
    }
public:
    DirectedCycle(Digraph G)
    {
        onStack = new bool[G.V()];
        marked = new bool[G.V()];
        edgeTo = new int[G.V()];
        for (int v = 0; v < G.V(); ++v)
            if (!marked[v]) dfs(G, v);
    }
    bool hasCycle() { return !cycle.empty(); }
    stack<int> cycle() { return cycle; }
}


//有向图中基于深度优先搜索的顶点排序
class DepthFirstOrder
{
private:
    bool* marked[];
    queue<int> pre;             //前序排列
    queue<int> post;            //后序排列
    stack<int> reversePost;     //逆后序排列

    void dfs(Digraph G, int v)
    {
        pre.push(v);

        marked[v] = true;
        for (int w : v.adj())
            if (!marked[v])  dfs(G, w);
        
        post.push(v);
        reversePost.push(v);
    } 

public:
    DepthFirstOrder(Digraph G)
    {
        marked = new bool[G.V()];
        for (int v = 0; v < G.V(); ++v)
            if (!marked[v])  dfs(G, v);
    }

    //.......
}


//拓扑排序
//逆后序排列


//强连通分量
//与无向图相比， 顶点访问顺序变为反向图的逆后序排列