1067 - Tunnels

Curses! A handsome spy has somehow escaped from your elaborate deathtrap, overpowered your guards, and stolen your secret world domination plans. Now he is running loose in your volcano base, risking your entire evil operation. He must be stopped before he escapes!

Fortunately, you are watching the spy's progress from your secret control room, and you have planned for just such an eventuality. Your base consists of a complicated network of rooms connected by non-intersecting tunnels. Every room has a closed-circuit camera in it (allowing you to track the spy wherever he goes), and every tunnel has a small explosive charge in it, powerful enough to permanently collapse it. The spy is too quick to be caught in a collapse, so you'll have to strategically collapse tunnels to prevent him from traveling from his initial room to the outside of your base.

Damage to your base will be expensive to repair, so you'd like to ruin as few tunnels as possible. Find a strategy that minimizes the number of tunnels you'll need to collapse, no matter how clever the spy is. To be safe, you'll have to assume that the spy knows all about your tunnel system. Your main advantage is the fact that you can collapse tunnels whenever you like, based on your observations as the spy moves through the tunnels.

Input 

The input consists of several test cases. Each test case begins with a line containing integers R (1R50) and T (1T1000) , which are the number of rooms and tunnels in your base respectively. Rooms are numbered from 1 to R . T lines follow, each with two integers x , y (0x, yR) , which are the room numbers on either end of a tunnel; a 0 indicates that the tunnel connects to the outside. More than one tunnel may connect a pair of rooms.

The spy always starts out in room 1. Input is terminated by a line containing two zeros.

Output 

For each test case, print a line containing the test case number (beginning with 1) followed by the minimum number of tunnels that must be collapsed, in the worst case. Use the sample output format and print a blank line after each test case.

Sample Input 

4 6 
1 2 
1 3 
2 4 
3 4 
4 0 
4 0 
4 6 
1 2 
1 3 
1 4 
2 0 
3 0 
4 0 
0 0

Sample Output 

Case 1: 2 

Case 2: 2

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn=105;
int cap[maxn][maxn],flow[maxn][maxn];
int n,m;
int x,y;
bool vis[maxn];
int M[maxn];
bool useful[maxn];

bool init()
{
	int i,x,y;
	scanf("%d %d",&n,&m);
	if(n==0&&m==0)
		return false;
	memset(cap,0,sizeof(cap));
	for(i=0;i<m;i++)
	{
		scanf("%d %d",&x,&y);
		cap[x][y]++;
		cap[y][x]++;
	}
	return true;
}

bool dfs(int x)
{
	if(x==0)
		return true;
	if(vis[x])
		return false;
	vis[x]=true;
	for(int i=0;i<=n;i++)
		if(cap[x][i]>flow[x][i]&&dfs(i))
		{
			flow[x][i]++;
			flow[i][x]--;
			return true;
		}
	return false;
}

int maxflow(int sink)
{
	int res=0;
	memset(flow,0,sizeof(flow));
	memset(vis,0,sizeof(vis));
	while(dfs(sink))
	{
		memset(vis,0,sizeof(vis));
		res++;
	}
	return res;
}

void del(int x)
{
	for(int i=0;i<=n;i++)
		cap[i][x]=cap[x][i]=0;
}

int main()
{
	int test=0;
	while(init())
	{
		for(int i=1;i<=n;i++)
			M[i]=maxflow(i);
		memset(useful,0,sizeof(useful));
		for(int i=1;i<=n;i++)
		{
			int m=2147483647;
			for(int j=1;j<=n;j++)
				if(useful[j]==0 && M[j]<m)
					m=M[j];
			for(int j=1;j<=n;j++)
				if(m==M[j])
				{
					useful[j]=true;
					del(j);
				}
				for(int j=1;j<=n;j++)
					if(useful[j]==0)
					{
						M[j]=min(M[j],m+maxflow(j));
					}
		}
		printf("Case %d: %d\n\n",++test,M[1]);
	}
	return 0;
}