边双连通 练习
点双连通：
Poj 3177
题意：给一个无向连通图求最少加几条边 变为一个边双联通的图(两个农场之间奶牛可以选择不止一条路)
用tarjan将原来的边双连通块缩点，然后找到叶子节点ans ，
加的边数= (ans+1)/2 ;
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;
const int MAXN = 200010;//点数
const int MAXM = 2000010;//边数，因为是无向图，所以这个值要*2
struct Edge
{
int to,next;
bool cut;//是否是桥标记
bool cong;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];// Belong数组表示边属于哪一个连通块
int Index,top;
bool Instack[MAXN];
//bool cut[MAXN]; //自然用来存割点
//int add_block[MAXN]; // 删除一个点后增加的连通块数
int bridge;//桥的数目
int block; //边双连通块数量
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;
// int son=0; // 统计某个点在搜索树中的儿子个数
for(int i = head[u];i != -1;i = edge[i].next)
{
v = edge[i].to;
if(v == pre )continue;
if( !DFN[v] )
{
// son++;
Tarjan(v,u);
if( Low[u] > Low[v] ) Low[u] = Low[v];
//一条边 (u,v)是桥，当且仅当(u,v)为树枝边(u,v都在栈里面),且满足DFN(u)<Low(v)
if(Low[v] > DFN[u])
{
bridge++;
edge[i].cut = true;
edge[i^1].cut = true; //因为是无向图，自然增加了两条边
}
//割点
//一个顶点u是割点，当且仅当满足（1）或者(2); （1）u为树根,且u有多于一个子树。
//（2）u不为树根，且满足存在(u,v)为树枝边（u为v在搜索树中的父亲），使DFS(u)<=Low(v)
// if(u!=pre && Low[v] >= DFN[u]){
// cut[u] =true;
// add_block[u]++;
// }
}
else if( Instack[v] && Low[u] > DFN[v] )
Low[u] = DFN[v];
}
//数根，分支数>1
// if(u== pre && son>1 ) cut[u]=true;
// if(u== pre) add_block[u]=son-1;
// 进行边双连通操作
if(Low[u]==DFN[u]){
block++;
do
{
v= Stack[--top];
Instack[v]=false;
Belong[v]=block;
}
while(v!=u);
}
}
void init()
{
tot = 0;
memset(head,-1,sizeof(head));
}
int du[MAXN]; //缩点后形成的树，每个点的度数
void solve(int n){
memset(DFN,0,sizeof(DFN));
memset(Instack,false,sizeof(Instack));
// memset(add_block,0,sizeof(add_block) );
// memset(cut,false,sizeof(cut) );
Index=top=block=bridge=0;
for(int i=1;i<=n;i++)
if(!DFN[i])
Tarjan(i,0);
int ans=0;
memset(du,0,sizeof(du));
for(int i=1;i<=n;i++)
for(int j=head[i];j!=-1;j=edge[j].next){
if(edge[j].cut){
du[Belong[i]]++;
}
}
for(int i=1;i<=block;i++)
if(du[i]==1){ //子树中有一 条桥，所以为叶子节点
ans++;
// printf("edge= %d\n",i);
}
//找出叶子节点的个数ans，构造边双连通图 最少需要加边 （ans+1）/2
//不会证明，可能是因为智商不够
printf("%d\n",(ans+1)/2); //
}
int main(){
int n,m;
//freopen("1.txt","r",stdin);
while(~scanf("%d %d",&n,&m)){
init();
int u,v;
for(int i=0;i<m;i++){
scanf("%d %d",&u,&v);
addedge(u,v);
addedge(v,u);
}
solve(n);
}
return 0;
}Hdu 4612
题意: 求添加一条边之后，可以获得的最小的桥的数量
原文：Note that there could be more than one channel between two planets.
题目需要找到：找树的最长路（直径），因为我们只能添加一条边肯定只能形成一个环，所以要除掉最多的桥，边双联通缩点之后的树的直径 首位添加一条边，必然就能去掉最多的桥！
！！！！如何找树的直径:
树的直径（最长路） 的详细证明
主要是利用了反证法：
假设 s-t这条路径为树的直径，或者称为树上的最长路
方法1
现有结论，从任意一点u出发搜到的最远的点一定是s、t中的一点，然后在从这个最远点开始搜，就可以搜到另一个最长路的端点，即用两遍广搜就可以找出树的最长路
则dis(u,T)+dis(s,X)+dis(u,X)>dis(s,X)+dis(X,t)=dis(s,t)最长路不是s-t矛盾
方法2
树的直径的长度一定会是某个点的最长距离f[i]与次长距离g[i]之和。最后求出max{f[i]+g[i]}就可以了
这个题最麻烦的是这个重边的解决！！！ 我用双重map 居然会超内存是最骚的。
但看不懂那个并且&&:
因为
首先，如果是|| ，那么这个图会跑不了tarjan，因为这个桥这里会断掉
输进去的图只有重边是false，其他都是true，而在判断桥的时候，若产生重边，则 还是不太懂？
/* 可以将所有的边双连通分支找出来; 每一个连通分支里面的点（即将边双连通分支缩点） 最后找出 变为边双连通图最少加几条边 这个模板题目原型的 图 是联通的，我感觉并不适用于不连通图！ 如果原图不连通还需要在思考 */
#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;
const int MAXN = 200005;//点数
const int MAXM = 2000005;//边数，因为是无向图，所以这个值要*2
struct Edge
{
int to,next;
bool cut;//是否是桥标记
bool chong;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN];
int Index,top;
bool Instack[MAXN];
int bridge;//桥的数目
int block; //边双连通块数量
void addedge(int u,int v,bool aa)
{
edge[tot].to = v;edge[tot].next = head[u];edge[tot].cut=false;edge[tot].chong=aa;
head[u] = tot++;
}
void Tarjan(int u,int pre)
{
int v;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
// int son=0; // 统计某个点在搜索树中的儿子个数
for(int i = head[u];i != -1;i = edge[i].next)
{
v = edge[i].to;
if(v == pre && edge[i].chong==0) continue; //?为什么是&&？
if( !DFN[v] )
{
// son++;
Tarjan(v,u);
if( Low[u] > Low[v] ) Low[u] = Low[v];
//一条边 (u,v)是桥，当且仅当(u,v)为树枝边(u,v都在栈里面),且满足DFN(u)<Low(v)
if(Low[v] > DFN[u] ) //且不能为重边
{
bridge++;
edge[i].cut = true;
edge[i^1].cut = true; //因为是无向图，自然增加了两条边
}
//割点
//一个顶点u是割点，当且仅当满足（1）或者(2); （1）u为树根,且u有多于一个子树。
//（2）u不为树根，且满足存在(u,v)为树枝边（u为v在搜索树中的父亲），使DFS(u)<=Low(v)
// if(u!=pre && Low[v] >= DFN[u]){
// cut[u] =true;
// add_block[u]++;
// }
}
else if( Instack[v] && Low[u] > DFN[v] )
Low[u] = DFN[v];
}
//数根，分支数>1
// if(u== pre && son>1 ) cut[u]=true;
// if(u== pre) add_block[u]=son-1;
// 进行边双连通操作
if(Low[u]==DFN[u]){
block++;
do
{
v= Stack[--top];
Instack[v]=false;
}
while(v!=u);
}
}
void init()
{
tot = 0;
memset(head,-1,sizeof(head));
}
int dis[MAXN];
int vis[MAXN];
void bfs(int u){
vis[u]=1;
for(int i = head[u];i != -1;i = edge[i].next){
int v=edge[i].to;
if(vis[v]) continue;
if(edge[i].cut){
dis[v]=dis[u]+1;
bfs(v);
}
else{ //讲道理这里应该处理一下
dis[v]=dis[u];
bfs(v);
}
}
}
void solve(int n){
memset(DFN,0,sizeof(DFN));
memset(Instack,false,sizeof(Instack));
memset(dis,0,sizeof(dis));
memset(vis,0,sizeof(vis));
// memset(add_block,0,sizeof(add_block) );
// memset(cut,false,sizeof(cut) );
Index=top=block=bridge=0;
for(int i=1;i<=n;i++)
if(!DFN[i])
Tarjan(i,0);
bfs(1);
int sta;
// printf("bri=%d \n",bridge);
int maxn=dis[1];
for(int i=1;i<=n;i++){
// printf("%d ",dis[i]);
if(dis[i]>maxn){
sta=i;
maxn=dis[i];
}
}
memset(dis,0,sizeof(dis));
memset(vis,0,sizeof(vis));
bfs(sta);
maxn=dis[1];
for(int i=1;i<=n;i++){
if(dis[i]>maxn){
maxn=dis[i];
}
}
printf("%d\n",bridge-maxn);
}
struct Node
{
int u,v;
}node[MAXM];
bool cmp(Node a,Node b)
{
if(a.u != b.u)return a.u<b.u;
else return a.v<b.v;
}
int main(){
int n,m;
//freopen("1.txt","r",stdin);
while(~scanf("%d %d",&n,&m) &&(n||m) ){
init();
int u,v;
for(int i=0;i<m;i++){
scanf("%d %d",&u,&v);
if(v<u) swap(u,v);
node[i].u=u;
node[i].v=v;
}
sort(node,node+m,cmp);
for(int i = 0;i < m;i++){
if(i == 0 || (node[i].u!=node[i-1].u || node[i].v != node[i-1].v)) {
if(i < m-1 && (node[i].u==node[i+1].u && node[i].v == node[i+1].v)){
addedge(node[i].u,node[i].v,true);
addedge(node[i].v,node[i].u,true);
}
else{
addedge(node[i].u,node[i].v,false);
addedge(node[i].v,node[i].u,false);
}
}
}
solve(n);
}
return 0;
}