Light OJ 1291 - Real Life Traffic (构造双连通图)

原创 2015年07月09日 20:14:19

传送门:http://lightoj.com/volume_showproblem.php?problem=1291
http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=27001

题目大意:给定无向图,求最少添加多少条边使各个点至少在一个简单环中。

解题思路:添边构造双连通图,通过Tarjian求出各个双连通分支后缩点,统计出树中度为1的节点的个数,即为叶节点的个数,记为leaf。则至少在树上添加(leaf+1)/2条边,就能使树达到边二连通,所以至少添加的边数就是(leaf+1)/2。具体方法为,首先把两个最近公共祖先最远的两个叶节点之间连接一条边,这样可以把这两个点到祖先的路径上所有点收缩到一起,因为一个形成的环一定是双连通的。然后再找两个最近公共祖先最远的两个叶节点,这样一对一对找完,恰好是(leaf+1)/2次,把所有点收缩到了一起。(证明来自于下面Byvoid的博客链接)

参考:https://www.byvoid.com/blog/biconnect/

Code:

/*   W          w           w        mm          mm             222222222       7777777777777    */
/*    W        w w         w        m  m        m  m          222        22              7777    */
/*    w        w w         w        m  m        m  m                     22              777     */
/*     w      w   w       w        m    m      m    m                    22              77      */
/*     w      w    w      w        m    m      m    m                 222                77      */
/*      w    w      w    w        m      m    m      m              222                  77      */
/*      w    w      w    w        m      m    m      m            222                    77      */
/*       w  w        w  w        m        m  m        m         222                      77      */
/*       w  w        w  w        m        m  m        m      222                         77      */
/*        ww          ww        m          mm          m     222222222222222             77      */

//#pragma comment(linker, "/STACK:102400000,102400000")
//C++
//int size = 256 << 20; // 256MB
//char *p = (char*)malloc(size) + size;
//__asm__("movl %0, %%esp\n" :: "r"(p));
//G++
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<ctime>
#include<deque>
#include<cmath>
#include<vector>
#include<string>
#include<cctype>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<sstream>
#include<iostream>
#include<algorithm>
#define REP(i,s,t) for(int i=(s);i<=(t);i++)
#define REP2(i,t,s) for(int i=(t);i>=s;i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned long ul;

const int MAXN=10005;
const int MAXM=40005;
int T;
int n,m;
struct BCC
{
    struct Edge
    {
        int to,next;
        bool cut;//是否是桥标记
    } edge[MAXM];
    int head[MAXN],tot;
    int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];//Belong数组的值是1~block
    int Index,top;
    int degree[MAXN];
    int block;//边双连通块数
    bool Instack[MAXN];
    int bridge;//桥的数目
    void init()
    {
        Index=block=tot=0;
        memset(DFN,0,sizeof(DFN));
        memset(Instack,0,sizeof(Instack));
        memset(head,-1,sizeof(head));
        memset(degree,0,sizeof(degree));
    }
    void addedge(int u,int v)
    {
        edge[tot].to = v;
        edge[tot].next = head[u];
        edge[tot].cut=false;
        head[u] = tot++;
    }
    void Tarjan(int u,int pre)
    {
        int v;
        Low[u] = DFN[u] = ++Index;
        Stack[top++] = u;
        Instack[u] = true;
        for(int i = head[u]; i != -1; i = edge[i].next)
        {
            v = edge[i].to;
            if(v == pre)continue;
            if( !DFN[v] )
            {
                Tarjan(v,u);
                if( Low[u] > Low[v] )Low[u] = Low[v];
                if(Low[v] > DFN[u])
                {
                    bridge++;
                    edge[i].cut = true;
                    edge[i^1].cut = true;
                }
            }
            else if( Instack[v] && Low[u] > DFN[v] )
                Low[u] = DFN[v];
        }
        if(Low[u] == DFN[u])
        {
            block++;
            do
            {
                v = Stack[--top];
                Instack[v] = false;
                Belong[v] = block;
            }
            while( v!=u );
        }
    }
    int find_bcc()
    {
        for(int i=0; i<n; i++)
        {
            if(!DFN[i])
            {
                Tarjan(i,-1);
            }
        }
    }
    int solve()
    {
        memset(degree,0,sizeof(degree));
        for(int i=0;i<n;i++)
        {
            for(int j=head[i];j!=-1;j=edge[j].next)
            {
                int v=edge[j].to;
                if(Belong[i]!=Belong[v])
                {
                    degree[Belong[i]]++;
                }
            }
        }
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            if(degree[i]==1)
            {
                ans++;
            }
        }
        return (ans+1)/2;
    }
    void debug()
    {
        for(int i=0; i<n; i++)
        {
            printf("Belong[%d]=%d\n",i,Belong[i]);
        }
        for(int i=1;i<=n;i++)
        {
            printf("degree[%d]=%d\n",i,degree[i]);
        }
    }
} solver;
int main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("test.in","r",stdin);
#endif
    int ca=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        solver.init();
        REP(i,1,m)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            solver.addedge(u,v);
            solver.addedge(v,u);
        }
        solver.find_bcc();
        printf("Case %d: %d\n",ca++,solver.solve());
        //solver.debug();
    }
    return 0;
}

九度OJ 1109 连通图

题目描述:     给定一个无向图和其中的所有边,判断这个图是否所有顶点都是连通的。 输入:     每组数据的第一行是两个整数 n 和 m(0 输出:   ...
  • Jaster_wisdom
  • Jaster_wisdom
  • 2016年08月07日 10:54
  • 390

【连通图|边双连通+缩点】POJ-3177 Redundant Paths

给出一个无向图,保证是连通的,问要把这个无向图变成边双连通图需要至少修建几条新路。...
  • u012325552
  • u012325552
  • 2014年12月28日 10:09
  • 1213

无向图的双连通分量

无向图的双连通分量         点-双连通图:一个连通的无向图内部没有割点,那么该图是点-双连通图。         注意:孤立点,以及两点一边这两种图都是点-双连通的。因为它们都是内部无割点...
  • u013480600
  • u013480600
  • 2015年04月02日 18:45
  • 2243

【双连通】双连通模板 Tarjan

比起求无向图关节点的算法,只是多了一个栈,用来储存不存在关节点的所有边,遇到关节点之后弹出所有边进行储存...
  • u012325552
  • u012325552
  • 2014年12月26日 02:22
  • 1122

无向图的双连通性

目录目录 无向图的双连通性 RTarjan算法求关节点的算法 代码实现无向图的双连通性本Markdown编辑器使用[StackEdit][6]修改而来,用它写博客,将会带来全新的体验哦: 相关概念 关...
  • idevede
  • idevede
  • 2016年04月08日 17:10
  • 2969

图的割点、桥和双连通分支的基本概念

ACM模版[点连通度与边连通度] 在一个无向连通图中,如果有一个顶点集合,删除这个顶点集合,以及这个集合中所有顶点相关联的边以后,原图变成多个连通块,就称这个点集为割点集合。一个图的点连通度的定...
  • f_zyj
  • f_zyj
  • 2016年06月13日 23:31
  • 1624

Tarjan算法求至少要添加几条边才能使无向连通图变为边双连通图。

本博客转载自http://blog.csdn.net/lyy289065406/article/details/6762370 首先建立模型: 给定一个连通的无向图G,至少要添加几条边,才能使其...
  • zcmartin2014214283
  • zcmartin2014214283
  • 2016年05月07日 20:32
  • 941

light oj 1005 不知道是个什么玩意

A rook is a piece used in the game of chess which is played on a board of square grids. A rook can o...
  • NineFailure
  • NineFailure
  • 2016年09月06日 20:19
  • 158

【Redundant Paths】【无向图】【双连通分量】【缩点】

Redundant Paths Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java...
  • u013200703
  • u013200703
  • 2015年09月02日 09:17
  • 265

图的割点,桥,双连通分支

点连通度与边连通度: 在一个无向连通图中,如果有一个顶点集合,删除这个顶点集合,以及这个集合中所有顶点相关联的边以后,原图变成多个连通块,就称这个点集为割点集合。一个图的点连通度的定义为,最小割...
  • u013081425
  • u013081425
  • 2013年12月22日 19:31
  • 801
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Light OJ 1291 - Real Life Traffic (构造双连通图)
举报原因:
原因补充:

(最多只允许输入30个字)