poj1300 Door Man(欧拉回路判定)

题意：给你N个房间以及房间之间的门,且给你初始的房间号M,问你从初始房间走,可不可以经过每个门仅1次,最后到达0号房间.且所有的门都被你走过1次?

思路：将房间当成顶点，门作为边，转化为判断无向图是否存在欧拉回路或者通路。

所有门都被走一遍,所以任何有门的房间都必须是在同一连通分量:即degree不为0的节点所属并查集唯一.(因为允许存在孤立的一点,房间)

第二,如果所有点的degree都为偶数,那么该图的连通部分存在欧拉回路.(最终要求在0点结束)所以此时要求M也为0,否则不可能在0结束.

第三,如果所有点中有2个点的degree为奇数,要求这两个点一个为0,一个为M.否则不存在欧拉通路.

至于当存在欧拉路时,从M需要走多少条边到0房间呢?肯定是走过所有的边了,所有边数==总度数/2.

#include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <set>
#include <ctime>
#include <cmath>
#include <cctype>
using namespace std;
#define maxn 100
#define LL long long
int cas=1,T;
int n,m;
int sum;
int degree[maxn];
int pre[maxn];
int Find(int x)
{
return pre[x]==-1?x:pre[x]=Find(pre[x]);
}

int main()
{
char str[200];
while (scanf("%s",str) && str[0]=='S')
{
sum=0;
memset(pre,-1,sizeof(pre));
memset(degree,0,sizeof(degree));

scanf("%d%d",&m,&n);
getchar();
for (int i = 0;i<n;i++)
{
gets(str);
int len = strlen(str);
if (len==0)
continue;
int num = 0;
for (int j = 0;j<=len;j++)
{
if (str[j]==' ' || str[j]==0)
{
degree[num]++;
degree[i]++;
sum+=2;
if (Find(i)!=Find(num))
{
pre[Find(i)]=Find(num);
}
num=0;
}
else
num=num*10+str[j]-'0';
}
}
gets(str);
if (Find(0)!=Find(m))
{
printf("NO\n");
continue;
}
int cnt = 0;
for (int i = 0;i<n;i++)
if (degree[i])
cnt+=Find(i)==i?1:0;
if (cnt>1)
{
printf("NO\n");
continue;
}
cnt=0;
for (int i = 0;i<n;i++)
cnt+=degree[i]%2==1 ? 1:0;
if (cnt==0 && m==0)
printf("YES %d\n",sum/2);
else if (cnt==2 && m!=0 && degree[0]%2==1 && degree[m]%2==1)
printf("YES %d\n",sum/2);
else
printf("NO\n");
}

//freopen("in","r",stdin);
//scanf("%d",&T);
//printf("time=%.3lf",(double)clock()/CLOCKS_PER_SEC);
return 0;
}

Description

You are a butler in a large mansion. This mansion has so many rooms that they are merely referred to by number (room 0, 1, 2, 3, etc...). Your master is a particularly absent-minded lout and continually leaves doors open throughout a particular floor of the
house. Over the years, you have mastered the art of traveling in a single path through the sloppy rooms and closing the doors behind you. Your biggest problem is determining whether it is possible to find a path through the sloppy rooms where you:

Always shut open doors behind you immediately after passing through

Never open a closed door

End up in your chambers (room 0) with all doors closed

In this problem, you are given a list of rooms and open doors between them (along with a starting room). It is not needed to determine a route, only if one is possible.

Input

Input to this problem will consist of a (non-empty) series of up to 100 data sets. Each data set will be formatted according to the following description, and there will be no blank lines separating data sets.

A single data set has 3 components:

Start line - A single line, "START M N", where M indicates the butler's starting room, and N indicates the number of rooms in the house (1 <= N <= 20).

Room list - A series of N lines. Each line lists, for a single room, every open door that leads to a room of higher number. For example, if room 3 had open doors to rooms 1, 5, and 7, the line for room 3 would read "5 7". The first line in the list represents
room 0. The second line represents room 1, and so on until the last line, which represents room (N - 1). It is possible for lines to be empty (in particular, the last line will always be empty since it is the highest numbered room). On each line, the adjacent
rooms are always listed in ascending order. It is possible for rooms to be connected by multiple doors!

End line - A single line, "END"

Following the final data set will be a single line, "ENDOFINPUT".

Note that there will be no more than 100 doors in any single data set.

Output

For each data set, there will be exactly one line of output. If it is possible for the butler (by following the rules in the introduction) to walk into his chambers and close the final open door behind him, print a line "YES X", where X is the number of doors
he closed. Otherwise, print "NO".

Sample Input

START 1 2
1

END
START 0 5
1 2 2 3 3 4 4

END
START 0 10
1 9
2
3
4
5
6
7
8
9

END
ENDOFINPUT

Sample Output

YES 1
NO
YES 10