【tarjan割桥】HDU 4738 Caocao‘s Bridges

本文探讨了一种算法解决方案,通过Tarjan算法寻找关键桥梁,以帮助周瑜在三国时期的军事冲突中制定策略。该算法确定了切断曹操军队部署的最佳方案。

Problem Description

Caocao was defeated by Zhuge Liang and Zhou Yu in the battle of Chibi. But he wouldn't give up. Caocao's army still was not good at water battles, so he came up with another idea. He built many islands in the Changjiang river, and based on those islands, Caocao's army could easily attack Zhou Yu's troop. Caocao also built bridges connecting islands. If all islands were connected by bridges, Caocao's army could be deployed very conveniently among those islands. Zhou Yu couldn't stand with that, so he wanted to destroy some Caocao's bridges so one or more islands would be seperated from other islands. But Zhou Yu had only one bomb which was left by Zhuge Liang, so he could only destroy one bridge. Zhou Yu must send someone carrying the bomb to destroy the bridge. There might be guards on bridges. The soldier number of the bombing team couldn't be less than the guard number of a bridge, or the mission would fail. Please figure out as least how many soldiers Zhou Yu have to sent to complete the island seperating mission.

 

 

Input

There are no more than 12 test cases.

In each test case:

The first line contains two integers, N and M, meaning that there are N islands and M bridges. All the islands are numbered from 1 to N. ( 2 <= N <= 1000, 0 < M <= N2 )

Next M lines describes M bridges. Each line contains three integers U,V and W, meaning that there is a bridge connecting island U and island V, and there are W guards on that bridge. ( U ≠ V and 0 <= W <= 10,000 )

The input ends with N = 0 and M = 0.

 

 

Output

For each test case, print the minimum soldier number Zhou Yu had to send to complete the mission. If Zhou Yu couldn't succeed any way, print -1 instead.

 

 

Sample Input

 

3 3 1 2 7 2 3 4 3 1 4 3 2 1 2 7 2 3 4 0 0

 

 

Sample Output

 

-1 4

 

 

Source

2013 ACM/ICPC Asia Regional Hangzhou Online

 

tarjan求割桥,然后算每次的最小值

注意:1.如果初始就是不联通,输出0

2.如果最小代价为0,也要改成1,因为要派一个人去

 

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn=1005;
const int inf=0x3f3f3f3f;
const int maxm=10000005;
int n,m,cnt,times,minn,f[maxn],head[maxn];
int low[maxn],dfn[maxn];
struct edge
{
	int to,nxt,v;
}e[maxm<<1];
void add(int x,int y,int z)
{
	e[++cnt].to=y;
	e[cnt].nxt=head[x];
	e[cnt].v=z;
	head[x]=cnt;
}
void tarjan(int u,int fa)
{
	low[u]=dfn[u]=++times;
	f[u]=fa; int flag=0;
	for(int i=head[u];i;i=e[i].nxt)
	{
		int to=e[i].to;
		if(!flag && to==fa)
		{
			flag=1;
			continue;
		}
		if(!dfn[to])
		{
			tarjan(to,u);
			low[u]=min(low[u],low[to]);
			if(low[to]>dfn[u])
				minn=min(minn,e[i].v);
		}
		else low[u]=min(low[u],dfn[to]);
	}
}
int main()
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	int x,y,z;
	while(scanf("%d%d",&n,&m)==2 && (n || m))
	{
		memset(head,0,sizeof(head)); cnt=0; times=0; minn=inf;
		memset(dfn,0,sizeof(dfn));
		memset(f,0,sizeof(f));
		memset(low,0,sizeof(low));
		for(int i=1;i<=m;i++)
			scanf("%d%d%d",&x,&y,&z),add(x,y,z),add(y,x,z);
		int cc=0;
		for(int i=1;i<=n;i++)
			if(!dfn[i])
			{
				cc++;
				tarjan(i,-1);
			}
		if(cc>1)
		{
			printf("0\n");
			continue;
		}
		if(minn==inf) minn=-1;
		if(!minn) minn=1;
		printf("%d\n",minn);
	}
	return 0;
}

 

### 使用Tarjan算法求解图中的边 在无向连通图中,边是指那些一旦被移除就会使图分裂成多个连通分量的边。为了高效地找出这些边,Robert Tarjan提出的基于深度优先搜索(DFS)的方法提供了一个解决方案[^2]。 #### DFS遍历与时间戳标记 该方法首先对整个图执行一次深度优先遍历,在此过程中给每一个顶点分配一个发现时间(dfnum),表示访问顺序;同时也记录下每个节点能够到达最早的时间(lowlink)[^1]。 #### 判断条件 对于每条边(u,v)(其中u是v的父亲结点), 如果`low[v]>dfn[u]`,则表明从v出发无法找到更早访问过的节点,因此这条边就是边[^4]。 下面给出一段Python代码来展示如何具体实现这一过程: ```python def tarjan_cut_edges(graph): index_counter = [0] stack = [] low, dfn, iscut_edge = {}, {}, [] def dfs(at, parent=None): low[at], dfn[at] = index_counter[0], index_counter[0] index_counter[0] += 1 for to in graph.get(at, []): if to == parent: continue if to not in dfn: stack.append((at,to)) dfs(to, at) low[at] = min(low[at], low[to]) if low[to] > dfn[at]: iscut_edge.append(stack.pop()) else: while stack and (stack[-1][1]!=to or stack[-1][0]!=at): _ , edge_to = stack.pop() low[edge_to]=min(low[edge_to],low[at]) elif to in dfn: low[at] = min(low[at], dfn[to]) if ((parent,at)!=(to,-1)): stack.append((at,to)) for node in list(graph.keys()): if node not in dfn: dfs(node) return iscut_edge ``` 这段程序接收一个邻接表形式表示的无向图作为输入参数,并返回所有识别出来的边列表。注意这里使用了栈结构辅助判断是否存在其他路径连接父子节点之外的部分,从而确保正确处理复杂情况下的环路问题[^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值