额,这个题目已经改了好几天了,实在不想改了,具体思路还是有的,额,先说说题目要求,就是给一个图,问加一条边之后,怎样能使桥数最少?
乍一看没有思路,但是仔细一想便可以发现,其实要求最少桥数的话,可以加边之后缩点重构图,形成一颗树,然后求出这个树的直径,答案就是原来的桥数-树的直径。可以自己找个样例在纸上画下。
这题考查的知识点挺多,但是不难,关键是编码能力,发现自己好弱。两三天都没过,也懒得检查(这是我的缺点),下面贴上九野巨巨的AC代码和我的挫代码:(PS:我的现在还没过。。。我艹)
#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