HDU 4612(缩点+求桥+求树的直径)

原创 2013年12月04日 18:40:49

额,这个题目已经改了好几天了,实在不想改了,具体思路还是有的,额,先说说题目要求,就是给一个图,问加一条边之后,怎样能使桥数最少?


乍一看没有思路,但是仔细一想便可以发现,其实要求最少桥数的话,可以加边之后缩点重构图,形成一颗树,然后求出这个树的直径,答案就是原来的桥数-树的直径。可以自己找个样例在纸上画下。

这题考查的知识点挺多,但是不难,关键是编码能力,发现自己好弱。两三天都没过,也懒得检查(这是我的缺点),下面贴上九野巨巨的AC代码和我的挫代码:(PS:我的现在还没过。。。我艹)

九野的AC code:

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<vector>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<iostream>
#include<queue>
using namespace std;
#define inf 233333333
#define N 200010
#define M 2000010
struct Edge{
	int from, to, nex;
	bool cut;
}edge[M];
int head[N], edgenum;
int bridgetop;
void addedge(int u, int v){
	Edge E={u,v,head[u],false};
	edge[ edgenum ] = E;
	head[u] = edgenum++;
}
int n, m;
int dfn[N], low[N], tarjan_time, tar, Stack[N], top;
int Belong[N];
bool iscut[N];
void tarjan(int u, int fa){
	dfn[u] = low[u] = ++tarjan_time;
	Stack[++top] = u;
	int child = 0, flag = 1;

	for(int i = head[u]; ~i; i = edge[i].nex)
	{
		int v = edge[i].to;
		if(flag && v==fa){flag = 0; continue;}
		if(!dfn[v])
		{
			child++;
			tarjan(v, u);
			low[u] = min(low[u], low[v]);
			if(low[v] >= dfn[u])
			{
				iscut[u] = true;

				if(low[v]>dfn[u])
					edge[i].cut = edge[i^1].cut = true;
			}
		}
		else low[u] = min(low[u], dfn[v]);
	}
	if(child == 1 && fa<0)iscut[u] = false;
	if(low[u] == dfn[u])
	{
		tar++;
		do
		{
			Belong[ Stack[top] ] = tar;
		}while(Stack[top--] != u);
	}
}
vector<int>G[N];
int dis[N];
int BFS(int u){
	for(int i = 0;i<=n;i++)dis[i] = inf;
	dis[u] = 0;
	queue<int>q;
	q.push(u);
	int pos = u, d = 0;
	while(!q.empty()){
		u = q.front(); q.pop();
		for(int i=0;i<G[u].size();i++)
		{
			int v = G[u][i];
			if(dis[v] > dis[u]+1)
			{
				dis[v] = dis[u]+1;
				q.push(v);
				if(dis[v] > d)d=dis[v] , pos = v;
			}
		}
	}
	return pos;
}
void init(){
	memset(head, -1, sizeof(head)), edgenum = 0;
	memset(dfn, 0, sizeof(dfn));
	memset(iscut, 0, sizeof(iscut));
	memset(Belong, -1, sizeof(Belong));
	bridgetop = 0;
	tarjan_time = 0;
	top = 0;
	tar = 0;
}
int main(){ 
	int i, j, u, v; 
	while(scanf("%d%d",&n,&m), m+n){
		init();
		while(m--){
			scanf("%d %d",&u,&v);
			addedge(u, v); addedge(v, u);
		}
		for(i = 1; i <= n; i++)if(!dfn[i])
			tarjan(i, -1);

		for(i = 0; i <= tar; i++)G[i].clear();
		int bri_cut = 0;
		for(i = 0; i < edgenum; i+=2 )
		{
				u = Belong[edge[i].from], v = Belong[edge[i].to];
				if(u != v)
					G[u].push_back(v), G[v].push_back(u);
				bri_cut += edge[i].cut;
		}
		u = BFS(1);
		v = BFS(u);
		printf("%d\n",bri_cut - dis[v]);
	}
	return 0;
}


我的挫代码:

/****************************************************
* author:crazy_石头
* Pro:HDU4612
* algorithm:缩点+树的直径
* Time:32ms
* Judge Status:Accepted
*******************************************************/
#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <vector>
#include <algorithm>

using namespace std;

#define rep(i,h,n) for(int i=(h);i<=(n);i++)
#define ms(a,b) memset((a),(b),sizeof(a))
#define eps 1e-6
#define INF 1<<29
#define LL __int64
const int maxn=200000+5;
const int maxm=1000000+10;

struct Edge
{
    int to,next;
    bool cut;//是否是桥;
}edge[maxm<<1];

int head[maxn],dfn[maxn],low[maxn],stack[maxn];
int instack[maxn],belong[maxn];

int cnt,top,Bcnt,bridge,index;

int Head[maxn],cnt1;
struct E
{
    int to,next;//缩点变成树之后重新构图;
}e[maxm<<1];

int n,m;
inline void Readdedge(int u,int v)
{
    e[cnt1].to=v;
    e[cnt1].next=head[u];
    head[u]=cnt1++;
}

inline void ReAdd(int u,int v)
{
    Readdedge(u,v);
    Readdedge(v,u);
}

inline int max(int a,int b)
{
    return a>b?a:b;
}

inline int min(int a,int b)
{
    return a<b?a:b;
}

inline void addedge(int u,int v)
{
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    edge[cnt].cut=false;
    head[u]=cnt++;
}

inline void Add(int u,int v)
{
    addedge(u,v);
    addedge(v,u);
}

inline void tarjan(int u)
{
    dfn[u]=low[u]=++index;
    stack[++top]=u;
    instack[u]=1;

    int v;
    for(int i=head[u];~i;i=edge[i].next)
    {
        v=edge[i].to;
        if(edge[i].cut)continue;
        edge[i].cut=edge[i^1].cut=1;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);//树边;
            //桥
            //一条无向边(u,v)是桥,当且仅当(u,v)为树枝边,且满足DFS(u)<Low(v)。
            if(low[v]>dfn[u])
            {
                bridge++;
                edge[i].cut=edge[i^1].cut=true;
            }
        }
            //割点
            //一个顶点u是割点,当且仅当满足(1)或(2) (1) u为树根,且u有多于一个子树。
            //(2) u不为树根,且满足存在(u,v)为树枝边(或称父子边,
            //即u为v在搜索树中的父亲),使得DFS(u)<=Low(v)
        else if(instack[v])
            low[u]=min(low[u],dfn[v]);//后向边;
    }
    if(dfn[u]==low[u])
    {
        Bcnt++;
        do
        {
            v=stack[top--];//弹出栈顶元素;
            belong[v]=Bcnt;//标记强连通分量;
            instack[v]=false;
        }while(u!=v);
    }
}

int vis[maxn],d[maxn];
inline int BFS(int s)
{
    int tmp;
    queue<int> q;
    ms(d,INF);
    ms(vis,0);
    while(!q.empty())
     q.pop();
    q.push(s);
    vis[s]=1;
    d[s]=0;

    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=1;

        for(int i=head[u];~i;i=edge[i].next)
        {
            int v=edge[i].to;
            if(d[v]>d[u]+1)
            {
                d[v]=d[u]+1;
                tmp=v;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return tmp;
}

inline void init()
{
    ms(head,-1),ms(dfn,0),ms(instack,0);
    index=cnt=top=Bcnt=bridge=0;
}

inline  void solve()
{
    init();
    ms(Head,-1),cnt1=0;
    tarjan(1);
    for(int u=1;u<=n;u++)
    {
        for(int i=head[u];~i;i=edge[i].next)
        {
            int v=edge[i].to;
            if(belong[u]!=belong[v])
            {
                ReAdd(belong[u],belong[v]);//缩点后建图;
            }
        }
    }
    int tmp=BFS(1);//找到最长的那个端点,从那个端点在BFS;
    tmp=BFS(tmp);
    printf("%d\n",bridge-d[tmp]);
}

int main()
{
    while(~scanf("%d%d",&n,&m),n,m)
    {
        init();
        while(m--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            Add(u,v);
        }
        solve();
    }
    return 0;
}

得好好练下基础了,这样可不行啊,T_T

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

HDU 4612 and 4607 (tarjan求桥+树形dp求树的直径)

HDU 4612 题意:给你一个无向图,里面有桥,问你连给它加一条边,桥变为多少 题解:很明显是先求出桥的数量,然后缩点成一棵树,然后求树的直径,答案就是桥-直径 但是这题有20W点100W边,而且有...

Hdu 4612 Warm up (双连通缩点+树的直径)

题意:有N 个点,M条边,加一条边,求割边最少。(有重边) 思路:先求双连通分量,缩点形成一个生成树,然后求这个的直径,割边-直径即是答案

hdu4612 Warm up(边双连通缩点+树的直径)

给定一张无向图,问现在添加一条边后可以使得图中还存在最少的桥边是多少。 思路:因为图是连通的,我们只需要把图缩点后形成一棵树(这里的边是原图中的桥)。然后求出这棵树的直径(经典问题),最后就是ans ...

HDU-4612-Warm up(无向图缩点+直径)

Warm up Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total...

Warm up HDU - 4612 Tarjan,树的直径

N planets are connected by M bidirectional channels that allow instant transportation. It's always p...

HDU 4612 Warm up(边双连通分量+树的直径)

题意:给出一个无向图,可能包含重边和自环,现在可以在这个图上加上一条边,问加完这条边后图上最少有多少桥边。 思路:首先求出所有边双连通分量,然后缩点,缩点以后形成了一棵树,那么只要我们将树上最长的一...

HDU 4612 Warm up (边双联通,树的直径)

http://acm.hdu.edu.cn/showproblem.php?pid=4612 Warm up Time Limit: 10000/5000 MS (Java/Others)...

HDU 4612 Warm up(边双连通、树的直径)

题意: N≤2×105个点,M≤106条边的无向图,有重边N\le 2\times 10^5个点, M\le10^6条边的无向图, 有重边 现在要添加一条边,问添加后剩余最小的桥数是多少现在...
  • lwt36
  • lwt36
  • 2016-03-01 01:41
  • 238

hdu 4612 warm up 无向图求割边缩点,边连通图

无向图求割边缩点,边连通图 题意:给你一个无向连通图,问加上一条边后得到的图的最少的割边数。 先求无向图的割边,然后把边连通图缩点,得到的所有缩点连成一棵树,最后就是求树的最大的直径。 #pr...

多校联赛2 Problem2 Warm up 求桥的数目+缩点后的树的直径 当时被不知道原因的爆栈爆到无语了。。

Warm up Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total S...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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