1122 Hamiltonian Cycle（25 分）

1122 Hamiltonian Cycle（25 分）

The "Hamilton cycle problem" is to find a simple cycle that contains every vertex in a graph. Such a cycle is called a "Hamiltonian cycle".

In this problem, you are supposed to tell if a given cycle is a Hamiltonian cycle.

Input Specification:

Each input file contains one test case. For each case, the first line contains 2 positive integers N (2<N≤200), the number of vertices, and M, the number of edges in an undirected graph. Then M lines follow, each describes an edge in the format Vertex1 Vertex2, where the vertices are numbered from 1 to N. The next line gives a positive integer K which is the number of queries, followed by K lines of queries, each in the format:

n V​1​​ V​2​​ ... V​n​​

where n is the number of vertices in the list, and V​i​​'s are the vertices on a path.

Output Specification:

For each query, print in a line YES if the path does form a Hamiltonian cycle, or NO if not.

Sample Input:

6 10
6 2
3 4
1 5
2 5
3 1
4 1
1 6
6 3
1 2
4 5
6
7 5 1 4 3 6 2 5
6 5 1 4 3 6 2
9 6 2 1 6 3 4 5 2 6
4 1 2 5 1
7 6 1 3 4 5 2 6
7 6 1 2 5 4 3 1

Sample Output:

YES
NO
NO
NO
YES
NO

欧拉:

欧拉通路: 通过图中每条边且只通过一次，并且经过每一顶点的通路。
欧拉回路: 通过图中每条边且只通过一次，并且经过每一顶点的回路。

无向图是否具有欧拉通路或回路的判定:
欧拉通路:图连通；图中只有0个或2个度为奇数的节点
欧拉回路:图连通；图中所有节点度均为偶数

有向图是否具有欧拉通路或回路的判定:
欧拉通路:图连通；除2个端点外 其余节点入度=出度；
1个端点入度比出度大1； 一个端点入度比出度小1 或 所有节点入度等于出度；
欧拉回路:图连通；所有节点入度等于出度

 

哈密顿

哈密顿图是一个无向图

哈密顿通路: 通过图中每个点且只通过一次，并且经过每一顶点的通路。
哈密顿回路: 通过图中每个点且只通过一次，并且经过每一顶点的回路。
包含个顶点的图, 如果任意两个顶点的度数之和都不小于n-1（即大于等于n-1）, 则存在哈密尔顿通路。
包含个顶点的图, 如果任意两个顶点的度数之和都不小于n（即大于等于n）, 则存在哈密尔顿回路。

 

1.要n+1个顶点 因为每个点都要经过并且回到自己

2.要首尾相同

3.每个元素都要有 所以是n个

4.相邻的元素必须！是有边的//就是这里我wa了十几发 //不过我不是很懂上面那个条件我写不出来

这一题我真不知道怎么写了wa了10+发难受最后还有一个测试点 就是第二个 判断相邻的顶点是否连通我没懂它们怎么过的

啊啊啊终于过了！！！！

代码:copy

#include<bits/stdc++.h>
using namespace std;

const int maxn = 210;
int n, m, k;
vector<int> G[maxn];
bool connect(int u, int v){
    for(int i = 0; i < G[u].size(); ++i){
        if(G[u][i] == v) return true;
    }
    return false;
}

bool judge(vector<int> path,set<int> st){
    int len = path.size();

    if(len != n + 1) return false; //经历每一个顶点并且回到原点一共要n+1个
    if(path[0] != path[len - 1]) return false; //首尾要相同
    if(st.size() != n)	return false; //因为每个点都要经过 所以点数要等于n
    
    for(int i = 0; i < path.size() - 1; ++i){
        int u = path[i], v = path[i + 1];
        if(!connect(u, v)) 
	    return false; //说的每个点都要连接！
    }

    return true;
}


int main()
{
    cin >> n >> m;
    int u, v;
    for(int i = 0; i < m; ++i){
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }

    cin >> k;
    while(k--){
        int t; cin >> t;
        vector<int> path;
        path.resize(t);
        set<int>st;
        for(int j = 0; j < t; ++j){
            cin >> path[j];
            st.insert(path[j]);
        }
        if(judge(path,st)) cout << "YES" << endl;
        else cout << "NO" << endl;
    }

    return 0;
}

 

代码自己的:终于啊

#include<bits/stdc++.h>
using namespace std;
set<int>st;
vector<int>vec;
int maze[205][205],n,m,num;
int size[205];
bool check()
{
	if(st.size() != n)   //每个点都要经过 
		return false;
	if(num != n+1) 		 //只有有n+1个点 
		return false;
	if(vec[0] != vec[n]) //首尾相同 
		return false; 
	for(int i = 1;i <= n;i++)
	{
		for(int j = 1 ;j <= n;j++)
		{
			if(maze[i][j])
				size[i]++;
		}
		if(size[i] == 0)  //判断通路 
			return false; 
	}	
	for(int i = 1;i <= n;i++)
	{
		for(int j = 1 ; j <= n;j++)
		{
			if(maze[i][j])
			{
				if(size[i] + size[j] < n)
					return false;
			}
		}
	}
	for(int i = 0; i < num-1; i++)
	{
		if(maze[vec[i]][vec[i+1]] == 0)
			return false;
	} 
	return true;
}
int main()
{
	int x,y;
	scanf("%d%d",&n,&m);
	pair<int,int> p;
	for(int i =1 ;i<=m;i++)
	{
		scanf("%d %d",&x,&y);
		maze[x][y] = maze[y][x] = 1;
	}
	int k,data;
	scanf("%d",&k);
	while(k--)
	{
		vec.clear();
		st.clear();
		scanf("%d",&num);
		for(int i = 1; i <= num; i++) 
		{
			scanf("%d",&data);
			vec.push_back(data);
			st.insert(data);
		}
		bool flag = check();
		if(flag)
			printf("YES\n"); 
		else 
			printf("NO\n");
	}
	return 0;
}