《算法导论》笔记 第22章 总结与思考

【总结】

【思考】

22-1 通过广度优先搜索对边进行分类

22-2 挂接点、桥以及双连通分支

a) G_π的根是G的挂接点，当且仅当在G_π中该根顶点至少有两个子女。

b) 设v是G_π中的某一非根顶点，证明v是G的挂接点当且仅当v有一个子顶点s，使得不存在从s或s的任何后裔顶点指向v的某个真祖先顶点的反向边。

c) 设low[v]=min(d[v],d[w])，d[w]：对v的后裔u，(u,w)是反向边

试说明对所有顶点v∈V，如何在O(E)时间内计算出low[v]。

----

资料：https://www.byvoid.com/blog/biconnect

----

const int maxn=1111;  
const int maxm=5111;  
int n,m;  
  
struct EDGENODE{  
    int to;  
    int w;  
    bool cut;  
    int next;  
};  
struct SEDGE{  
    int u;  
    int v;  
    SEDGE(int uu=0,int vv=0){u=uu;v=vv;}  
};  
struct BCC_GRAPH{  
    int head[maxn];  
    EDGENODE edges[maxm];  
    int edge;  
    void init()  
    {  
        clr(head,-1);  
        edge=0;  
    }  
    void addedge(int u,int v,int c=0)  
    {  
        edges[edge].cut=0,edges[edge].w=c,edges[edge].to=v,edges[edge].next=head[u],head[u]=edge++;  
    }  
    //BCC_Tarjan  
    int dfn[maxn],low[maxn],bccno[maxn],dfs_clock,bcc_cnt;  
    bool iscut[maxn];  
    vector<int>bcc[maxn];  
    stack<SEDGE>stk;  
    int dfs(int u,int fa)  
    {  
        int lowu=dfn[u]=++dfs_clock;  
        int child=0;  
        for (int i=head[u];i!=-1;i=edges[i].next)  
        {  
            int v=edges[i].to;  
            if (v==fa) continue;  
            SEDGE e=SEDGE(u,v);  
            if (!dfn[v])  
            {  
                stk.push(e);  
                child++;  
                int lowv=dfs(v,u);  
                lowu=min(lowu,lowv);  
                if (dfn[u]<=lowv) //cut 割点  
                {  
                    iscut[u]=true;  
                    //done 点双连通  
                    bcc_cnt++;  
                    bcc[bcc_cnt].clear();  
                    SEDGE x;  
                    do{  
                        x=stk.top();  
                        stk.pop();  
                        if (bccno[x.u]!=bcc_cnt)  
                        {  
                            bcc[bcc_cnt].push_back(x.u);  
                            bccno[x.u]=bcc_cnt;  
                        }  
                        if (bccno[x.v]!=bcc_cnt)  
                        {  
                            bcc[bcc_cnt].push_back(x.v);  
                            bccno[x.v]=bcc_cnt;  
                        }  
                    }while (x.u!=u||x.v!=v);  
                    //over  
                }  
                if (dfn[u]<lowv)  //cut 桥  
                {  
                    edges[i].cut=true;  
                    edges[i^1].cut=true;  
                }  
            }  
            else if (dfn[v]<dfn[u])  
            {  
                stk.push(e);//done  
                lowu=min(lowu,dfn[v]);  
            }  
        }  
        if (fa<0&&child==1) iscut[u]=0;  
        low[u]=lowu;  
        return lowu;  
    }  
    void find_bcc(int n)  
    {  
        while (!stk.empty()) stk.pop();  
        clr(dfn,0);  
        clr(iscut,0);  
        clr(bccno,0);  
        dfs_clock=bcc_cnt=0;  
        REP_1(i,n)  
        {  
            if (!dfn[i]) dfs(i,-1);  
        }  
    }  
    //another  
    int block[maxn];  
    int vis[maxn];  
    int b_num;  
    void b_dfs(int u)  
    {  
        vis[u]=true;  
        block[u]=b_num;  
        for (int i=head[u];i!=-1;i=edges[i].next)  
        {  
            if (edges[i].cut) continue;  
            int v=edges[i].to;  
            if (!vis[v]) b_dfs(v);  
        }  
    }  
    void find_block(int n)  
    {  
        //find_block 边双连通  
        clr(block,0);  
        clr(vis,0);  
        b_num=0;  
        REP_1(i,n)  
        {  
            if (!vis[i])  
            {  
                b_num++;  
                b_dfs(i);  
            }  
        }  
    }  
}solver;  

----

22-3 欧拉回路

使用深度优先搜索，如果某条边被搜索到，则标记这条边为已选择，并且即使回溯也不能将当前边的状态改回未选择，每次回溯时，记录回溯路径。深度优先搜索结束后，记录的回溯路径就是欧拉回路。

----

void dfs(int u)  
{  
    for (int i=1;i<=n;i++)  
    {  
        if (a[u][i])  
        {  
            a[u][i]=false;  
            a[i][u]=false;  
            dfs(i);  
            ans[++cnt]=i;  
        }  
    }  
}  

----

22-4 可达性