ZOJ 2588 Burning Bridges(判断割边)

题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2588

题意:

Ferry王国是一个漂亮的岛国,一共有N个岛国、M座桥,通过这些桥可以从每个小岛都能

到达任何一个小岛。很不幸的是,最近Ferry王国被Jordan征服了。Jordan决定烧毁所有的桥。

这是个残酷的决定,但是Jordan的谋士建议他不要这样做,因为如果烧毁所有的桥梁,他自己的

军队也不能从一个岛到达另一个岛。因此Jordan决定烧尽可能多的桥,只要能保证他的军队能从

任何一个小岛都能到达每个小岛就可以了。

现在Ferry王国的人民很想知道哪些桥梁将被烧毁。当然,他们无法得知这些信息,因为哪

些桥将被烧毁是Jordan的军事机密。然而,你可以告知Ferry王国的人民哪些桥肯定不会被烧毁。

输入描述:

输入文件中包含多个测试数据。输入文件中第1行为一个整数T,1≤T≤20,表示测试数据

的数目。接下来有T个测试数据,测试数据之间用空行隔开。

每个测试数据的第1行为两个整数N和M,分别表示岛的数目和桥的数目,2≤N≤10000,

1≤M≤100000;接下来有M行,每行为两个不同的整数,为一座桥所连接的小岛的编号。注意,

两个岛之间可能有多座桥。

图论算法理论、实现及应用

- 402 -

输出描述:

对每个测试数据,首先在第1行输出一个整数K,表示K座桥不会被烧毁;第2行输出K个

整数,为这些桥的序号。桥的序号从1开始计起,按输入的顺序进行编号。

两个测试数据的输出之间有一个空行。

// tarjan 求割边的个数 

两个岛还可能存在多个桥的情况

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
const int N = 210;
const int maxn = 10100;
const int maxm = 221010;
const int inf = 1e8;
#define MIN INT_MIN
#define MAX 1e6
#define LL long long
#define init(a) memset(a,0,sizeof(a))
#define FOR(i,a,b) for(int i = a;i<b;i++)
#define max(a,b) (a>b)?(a):(b)
#define min(a,b) (a>b)?(b):(a)
using namespace std;
struct node
{
    int next,v,flag,id;
}edge[maxm];
int DFN[maxn],low[maxn],bnum,bianhao;
int ans[maxn],ge;
int head[maxn];
int st[maxn],en[maxn];
int cmp(const void *a,const void *b)
{
    return *(int *)a - *(int *)b;
}
void initt()
{
    memset(head,0,sizeof(head));
    bnum = 1;
    bianhao = 1;
    init(DFN);init(low);init(ans);
    ge = 0;
    init(st);init(en);
}
void add(int u,int v,int id)
{
    int i;
    for(i = head[u];i!=0;i=edge[i].next)
    {
        if(edge[i].v == v)
            break;
    }
    if(i)
    {
        edge[i].flag = 1;
        return ;
    }
    edge[bnum].v = v;

    edge[bnum].id = id;
    edge[bnum].flag = 0;
    edge[bnum].next = head[u];
    head[u] = bnum++;
}
void tarjan(int s,int father)
{
    DFN[s] = low[s] = bianhao++;
    for(int i = head[s];i!=0;i = edge[i].next)
    {
        if(DFN[edge[i].v]==0)
        {
            tarjan(edge[i].v,s);

                low[s] = min(low[s],low[edge[i].v]);
                if(DFN[s] < low[edge[i].v] && edge[i].flag==0)
                {
                    ans[ge++] = edge[i].id;
                    st[ge-1] = s;
                    en[ge-1] = edge[i].v;
                }
        }
        else if(edge[i].v != father)
        {
            low[s] = min(low[s],DFN[edge[i].v]);
        }
    }
}
int main()
{
    int t,m,n,a,b;
    scanf("%d",&t);
    while(t-- && scanf("%d%d",&n,&m))
    {
        initt();
        FOR(i,1,m+1)
        {
            scanf("%d%d",&a,&b);
            add(a,b,i);
            add(b,a,i);
        }
        tarjan(1,-1);

        printf("%d\n",ge);
        if(ge!=0)
        {
        qsort(ans,ge,sizeof(int),cmp);

        FOR(i,0,ge-1)
        {
            printf("%d ",ans[i]);
        }
            printf("%d\n",ans[ge-1]);
         /*   puts("割边是");
          FOR(i,0,ge)
           {
            printf("%d->%d\n",st[i],en[i]);
           }*/
        }
        if(t)
            cout<<endl;
    }
    return 0;
}

时间: 2024-10-19 03:28:13

ZOJ 2588 Burning Bridges(判断割边)的相关文章

ZOJ 2588 Burning Bridges(无向图求割边)

ZOJ 2588 Burning Bridges 链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2588 题意:给定一个无向图连通图,(其中可能有重边),要求去掉一条边之后,使得整个图不再连通.输出这些符合条件的边的序号. 思路:这就是一个简单的无向图求割边,需要注意的是这个无向图有重边,重边一定不是割边. 代码: /*========================================= 无向图求割点

ZOJ 2588 Burning Bridges 求无向图桥 边双连通裸题

题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1588 binshen的板子: #include <stdio.h> #include <string.h> #include <iostream> #include <algorithm> #include <vector> #include <queue> #include <set> #i

ZOJ 2588 Burning Bridges(无向连通图求割边)

题目地址:ZOJ 2588 由于数组开小了而TLE了..这题就是一个求无向连通图最小割边.仅仅要推断dfn[u]是否<low[v],由于low指的当前所能回到的祖先的最小标号,增加low[v]大于dfn[u]时,说明v无法通过其它边回到u之前的点.也就是说v假设想要回到u的祖先点.必需要经过u点,那这条边非常明显就是一条割边.这题还要去重边,假如有重边的话.说明怎么销毁哪条边总能通过还有一条边,所以仅仅要有重边.说明这两点之间没有割边. 代码例如以下: #include <iostream&g

ZOJ 2588 Burning Bridges(强连通分量)

题目地址:ZOJ 2588 因为数组开小了而TLE了..这题就是一个求无向连通图最小割边.只要判断dfn[u]是否<low[v],因为low指的当前所能回到的祖先的最小标号,加入low[v]大于dfn[u]时,说明v无法通过其他边回到u之前的点,也就是说v如果想要回到u的祖先点,必须要经过u点,那这条边很明显就是一条割边.这题还要去重边,假如有重边的话,说明怎么销毁哪条边总能通过另一条边,所以只要有重边,说明这两点之间没有割边. 代码如下: #include <iostream> #in

zoj 2588 Burning Bridges【双连通分量求桥输出桥的编号】

Burning Bridges Time Limit: 5 Seconds      Memory Limit: 32768 KB Ferry Kingdom is a nice little country located on N islands that are connected by M bridges. All bridges are very beautiful and are loved by everyone in the kingdom. Of course, the sys

【求无向图的桥,有重边】ZOJ - 2588 Burning Bridges

模板题——求割点与桥 题意,要使一个无向图不连通,输出必定要删掉的边的数量及其编号.求桥的裸题,可拿来练手. 套模板的时候注意本题两节点之间可能有多条边,而模板是不判重边的,所以直接套模板的话,会将重边也当做桥输出,因此要在判断桥的时候加一个判断,即当且仅当两点之间仅有一条边,且满足dfn[cur] < low[i],(cur, i)才是桥. 另外本题节点数为105,用邻接矩阵的话会内存超限,所以我用了了一个multiset存储边及其编号. 代码如下: 1 #include<cstdio>

ZOJ 2588 Burning Bridges 割边的求解

题目链接: ZOJ2588 题意: 给出一个无向的连通图,问去掉图中的哪些边,都会使图将不连通 题解思路: 割边的求解: 1.需要用到Tarjan算法的框架,首先求出dfn low 两个数组 当递归返回时  判断dfn[u]和low[v]的关系 只有当dfn[u]  < low[v]  的情况下u-v是一条割边(u是关节点 ,且u-v不含重边,即dfn[u] != low[v]) 2.题目中还有出现重边的情况  重边是不可能成为割边的  我们需要对重边进行标记 代码: #include<ios

ZOJ 1588 Burning Bridges (tarjan求割边)

题目链接 题意 : N个点M条边,允许有重边,让你求出割边的数目以及每条割边的编号(编号是输入顺序从1到M). 思路 :tarjan求割边,对于除重边以为中生成树的边(u,v),若满足dfn[u] < low[v],则边(u,v)是割边. 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <algorithm> 5 6 using namespace st

zoj2588 Burning Bridges --- 求割边

#include <iostream> #include <cstring> #include <string> #include <cstdio> #include <cmath> #include <algorithm> #include <vector> #include <queue> #include <map> #define inf 0x3f3f3f3f #define eps 1e-