LeetCode LCP 01 | 传递信息

问题描述
小朋友 A 在和 ta 的小伙伴们玩传信息游戏，游戏规则如下：

有 n 名玩家，所有玩家编号分别为 0 ～ n-1，其中小朋友 A 的编号为 0
每个玩家都有固定的若干个可传信息的其他玩家（也可能没有）。传信息的关系是单向的（比如 A 可以向 B 传信息，但 B 不能向 A 传信息）。
每轮信息必须需要传递给另一个人，且信息可重复经过同一个人
给定总玩家数 n，以及按 [玩家编号,对应可传递玩家编号] 关系组成的二维数组 relation。返回信息从小 A (编号 0 ) 经过 k 轮传递到编号为 n-1 的小伙伴处的方案数；若不能到达，返回 0。

示例 1：

输入：n = 5, relation = [[0,2],[2,1],[3,4],[2,3],[1,4],[2,0],[0,4]], k = 3

输出：3

解释：信息从小 A 编号 0 处开始，经 3 轮传递，到达编号 4。共有 3 种方案，分别是 0->2->0->4， 0->2->1->4， 0->2->3->4。

示例 2：

输入：n = 3, relation = [[0,2],[2,1]], k = 2

输出：0

解释：信息不能从小 A 处经过 2 轮传递到编号 2

限制：

2 <= n <= 10
1 <= k <= 5
1 <= relation.length <= 90, 且 relation[i].length == 2
0 <= relation[i][0],relation[i][1] < n 且 relation[i][0] != relation[i][1]

问题分析：
DFS：将孩子们的传递的关系图画出来，可知只是一个关于图的问题，问题转换为从图中的节点0经过k个节点到达节点n-1。因此也就是一个搜索问题，因此使用DFS进行搜索。再次转换，也就是在一棵树中进行搜索，深度不大于k且此时的节点应该为n-1.

动态规划：计数型DP
1.确定状态：
最后一步：在到达n-1之前，前一步一定在0…n-2之间
子问题：走k-1步能够到达0…n-2中任意一个的方法数,他们的和就是总数量
定义状态dp[k][n]为走k-1步到达n-1的方法数量
2.定义状态转移方程
dp[k][n]=sum(dp[k-1][0]+dp[k-1][1]+…+dp[k-1][n-2]+dp[k-1][n-1])
3.初始值和边界条件
初始值：dp[0][0]=1，走0步到达0节点的方法为1
边界条件：k,n
4.优化

伪代码：
int DFS()
{
递归结束条件：
1.0==k 且 now == n-1 ,方法数+1
2. k<= 0, 深度超过了或者达到了k层，但是now不是n-1,直接返回

处理当前层：
1.建立当前层的选择列表，即now可以将信息传递给那几位

进入下一层：对建立的选择列表进行遍历

重置到当前状态：无需重置

详细代码：

int ans=0;
int DFS(int** relation,int relationSize,int n,int k,int now){
	if(0==k&&now==n-1)	return ++ans;
	if(k<=0)	return 0;
	
	int *dst=(int*)malloc(sizeof(int)*n),count=0;
	for(int i=0;i<relationSize;++i){
		if(relation[i][0]==now)
			dst[count++]=relation[i][1];
	}
	for(int i=0;i<count;++i)
		DFS(relation,relationSize,n,k-1,dst[i]);
	return ans;
}

int numWays(int n,int **relation,int relationSize,int *relationColSize,int k){
	return DFS(relation,relationSize,n,k,0);
}

//DP
int numways(int n,int **relation,int relationSize,int *relationColSize,int k){
	const int row=k+1;
	const int col=n;
	
	int dp[row][col];
	memset(dp,0,sizeof(dp));
	dp[0][0]=1;
	
	for(int i=1;i<row;++i)
		for(int j=0;j<relationSize;++j)
			dp[i][relation[j][1]]+=dp[i-1][relation[j][0]];
	
	return dp[k][n-1];
}