Light OJ 1300 - Odd Personality (Tarjian求边双连通+二分图染色法判定奇圈)

原创 2015年07月09日 18:04:13

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

题目大意:给定无向图,求有多少个点可以使得从改点出发,不走重复边回到起点并且经过的点的个数为n且n为奇数。

解题思路:从某个点开始,不走重复边回到起点,等价于一个连通子图是一个简单环(无重复路径),且所有边都不是桥,就是原图的一个边双连通分量。通过Tarjian求出全部的边双连通分量后,对每个双连通分量进行染色法是否存在奇圈,染色失败则说明存在奇圈,答案里就应该包含该双连通分量里的点数,染色法与二分图判断的染色方法类似,注意属于同一个双连通块里就可以了,每个双连通分量里的点数可通过统计计数把每个双连通分量里的顶点数求出,累加进答案即可。

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 color[MAXN];
    bool bipartite(int u,int b)
    {
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(Belong[v]!=b)
            {
                continue;
            }
            if(color[v]==color[u])
            {
                return false;
            }
            if(!color[v])
            {
                color[v]=3-color[u];
                if(!bipartite(v,b))
                {
                    return false;
                }
            }
        }
        return true;
    }
    int solve()
    {
        memset(color,0,sizeof(color));
        memset(degree,0,sizeof(degree));
        bool vis[MAXN];
        memset(vis,0,sizeof(vis));
        for(int i=0;i<n;i++)
        {
            degree[Belong[i]]++;
        }
        int ans=0;
        for(int i=0;i<n;i++)
        {
            if(degree[Belong[i]]>=3)
            {
                if(!vis[Belong[i]])
                {
                    color[i]=1;
                    vis[Belong[i]]=1;
                    bool flag=bipartite(i,Belong[i]);
//                    printf("block=%d flag=%d\n",Belong[i],flag);
//                    for(int j=0;j<n;j++)
//                    {
//                        if(Belong[j]==Belong[i])
//                        {
//                            printf("color[%d]=%d\n",j,color[j]);
//                        }
//                    }
                    if(!flag)
                    {
                        ans+=degree[Belong[i]];
                    }
                }
            }
        }
        return ans;
    }
    void debug()
    {
        for(int i=0; i<n; i++)
        {
            printf("Belong[%d]=%d\n",i,Belong[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;
}

相关文章推荐

poj2942[补图+点双连通分量+交叉染色法判定二分图(奇圈判定)]

Knights of the Round Table Time Limit: 7000MS   Memory Limit: 65536K Total Submissio...

【poj2942】圆桌骑士Knights of the Round Table【双连通分量】【二分图】【奇圈】

传送门:http://poj.org/problem?id=2942 尽管我承认这题我几乎是对着书抄的代码(因为我还不熟- -),但是我还是WA了三次- -数组又没清零。 基本思想就是: 首先把...

UVA 1364 - Knights of the Round Table (找双连通分量 + 二分图染色法判断)

亚瑟王要在圆桌上召开骑士会议,为了不引发骑士之间的冲突, 并且能够让会议的议题有令人满意的结果,每次开会前都必须对出席会议的骑士有如下要求: 1、 相互憎恨的两个骑士不能坐在直接相邻的2个位置; 2...

C++:二分图染色法---双栈排序

题目如下: sicily 1002. 双栈排序 Description Tom最近在研究一个有趣的排序问题。如图所示,通过2个栈S1和S2,Tom希望借助以下4种操作实现将输入序列升序排序。操作...
  • linwh8
  • linwh8
  • 2016年09月21日 14:06
  • 2568

Codeforces Round #360 (Div. 2) -- C. NP-Hard Problem (DFS二分图染色法)

C. NP-Hard Problem time limit per test 2 seconds memory limit per test 256 megabytes input standa...

HDU 5285 wyh2000 and pupil(二分图,染色法)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5285 “if two pupils are in the same group,then t...

hdu 5285(染色法判断二分图)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5285 解题思路:很明显的是二分图的判定,用染色法即可。 不过这题有一个坑,当n #include...

HDU 5285 wyh2000 and pupil(染色法判断二分图)

wyh2000 and pupil Time Limit: 3000/1500 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Other...
  • Fungyow
  • Fungyow
  • 2015年07月20日 17:43
  • 356

南阳理工1015 (染色法判断二分图)

【二分图简介】 二分图:简单来说,如果图中点可以被分为两组,并且使得所有边都跨越组的边界,则这就是一个二分图。 准确地说:把一个图的顶点划分为两个不相交集 X 和 Y ,使得每一条边都分别连接X ...

判断二分图——染色法

怎么判定一个图是否为二分图 从其中一个定点开始,将跟它邻接的点染成与其不同的颜色,最后如果邻接的点有相同颜色,则说明不是二分图,每次用bfs遍历即可。 代码: #include #includ...
  • FeBr2
  • FeBr2
  • 2016年07月17日 15:41
  • 1637
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Light OJ 1300 - Odd Personality (Tarjian求边双连通+二分图染色法判定奇圈)
举报原因:
原因补充:

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