hiho_1087_哈密顿环

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<unordered_map>
#include<list>
#include<string>
#include<string.h>
#include<set>
using namespace std;
int dp[8200][13]; 
//dp[status][node] 表示从node出发,最终到达点0，遍历的点的状态形成 status 时可以走的路径数目
bool connected[13][13];
struct Edge{
	int to;
	int next;
};
Edge gEdges[220];
int gEdgeIndex;
int gHead[13];
bool gVisited[13];
void InsertEdge(int u, int v){
	if (connected[u][v]) //如果两个节点A和B之间有多条边直接从A连接到B，则只记录一次
		return;
	connected[u][v] = true;
	int e = gEdgeIndex++;
	gEdges[e].to = v;
	gEdges[e].next = gHead[u];
	gHead[u] = e;
}

void Init(){
	gEdgeIndex = 0;
	memset(gEdges, -1, sizeof(gEdges));
	memset(gHead, -1, sizeof(gHead));
	memset(dp, -1, sizeof(dp));
	memset(connected, false, sizeof(connected));
	memset(gVisited, false, sizeof(gVisited));
}

//用记忆化搜索实现 动态规划
//从node开始，经过的各个节点的位图为 status_to_visit，status_to_visit 中的各个节点经过
//且只经过一次，最终到达节点0. 所有可能的路径总数
int Dfs(int status_to_visit, int node){
	if (dp[status_to_visit][node] != -1) 
		return dp[status_to_visit][node];
	
	//当前节点之前被访问过一次
	if ((status_to_visit & (1 << node)) == 0)
		return dp[status_to_visit][node] = 0;
		
	int result = 0;
	for (int e = gHead[node]; e != -1; e = gEdges[e].next){
		int v = gEdges[e].to;		
		int new_status = status_to_visit & (~(1 << node));
		result += Dfs(new_status, v);
	}
	return dp[status_to_visit][node] = result;
}

int main(){
	int n, m, u, v;
	Init();
	scanf("%d %d", &n, &m);
	for (int i = 0; i < m; i++){
		scanf("%d %d", &u, &v);
		InsertEdge(u - 1, v - 1);
	}
	//初始状态，从0节点开始，最终到达节点0. status_to_visit = 0 是应为要从0开始到达0，
	//在开始的时候，位图为 111111，递归到下一层时为 111110.到最后再到达0时候的status_to_visit 为 000000
	dp[0][0] = 1;
	int result = Dfs((1 << n) - 1, 0);
	printf("%d\n", result);
	return 0;
}