leetcode之329矩阵中的最长递增路径Golang

j解决这道题我采用的思路是深度优先遍历的方法

类似于题目给出的样例的数组

9	9	4
6	6	8
2	1	1

然后对二维数组中的每个元素进行遍历，一次将他们作为序列的开头，找出这其中的最长的序列的长度就是本题的解了。

由于序列必须递增，并且可以从上下左右任意的方向都行，我们再创建一个对应的二维数组，用来保存以对应位置作为开头的最长序列的长度

1	1	2
2	2	1
3	4	2

值得注意的是这个二维数组并不是我们算法的输出数组，这个数组只是用来理解这个算法的。

上面这个二维数组怎么得来的呢，就是通过深度优先遍历的方法。例如对于位置(0,0)的元素9，那么找他上下左右的比他数字大的，发现没有，因此暂时将他的值保存为1（因为这个序列就只有他自己9这一个数字）

例如对于位于位置(2,1)的1来说，他的上面和左边的数都更大，所以我们需要继续增加序列的长度，比如从左边开始，左边是2，此时如果将2加到当前这个序列里面，那么2就位于这个序列的第二个位置，但是有一种特殊情况，如果2已经位于其他序列了，并且是位于更靠后的位置，那么我们此时就不能将2加入到我们当前的序列，因为2位于那一个序列的位置更加靠后，同理，如果2位于那个序列的位置更靠前，比如位于那个序列的位置1，那么我们就将2重新加入当前序列，并将位置改为2，然后2处理完以后再处理2周围的4个数字，以相同的方法处理。再之后就处理1周围的数字6.

这个过程结束以后，我们就能够得到一个最长的序列，并且再结果二维数组中展示出来，结果数组中最大的那个数就是最长序列的长度了。

代码如下：

func longestIncreasingPath(matrix [][]int) int {
	m := len(matrix)
	if m == 0 {
		return 0
	}
	n := len(matrix[0])

	res := make([][]int, m)
	for k := 0; k < m; k++ {
		res[k] = make([]int, n)
	}

	longest := 1
	for i := 0; i < m; i++ {
		for j := 0; j < n; j++ {

			if res[i][j] == 0 {
				res[i][j] = 1
				que := make([][]int, 0)
				tmpNode := []int{matrix[i][j], i, j}
				que = append(que, tmpNode)
				for len(que) != 0 {
					tmp := que[0]
					que = que[1:]
					// 上
					if tmp[1]-1 >= 0 {
						if tmp[0] < matrix[tmp[1]-1][tmp[2]] && res[tmp[1]][tmp[2]]+1 > res[tmp[1]-1][tmp[2]] {
							res[tmp[1]-1][tmp[2]] = res[tmp[1]][tmp[2]] + 1
							// if res[tmp[1]-1][tmp[2]] > longest {
							// 	longest = res[tmp[1]-1][tmp[2]]
							// }
							curNode := []int{matrix[tmp[1]-1][tmp[2]], tmp[1] - 1, tmp[2]}
							que = append(que, curNode)
						}
					}
					// 下
					if tmp[1]+1 < m {
						if tmp[0] < matrix[tmp[1]+1][tmp[2]] && res[tmp[1]][tmp[2]]+1 > res[tmp[1]+1][tmp[2]] {
							res[tmp[1]+1][tmp[2]] = res[tmp[1]][tmp[2]] + 1
							// if res[tmp[1]+1][tmp[2]] > longest {
							// 	longest = res[tmp[1]+1][tmp[2]]
							// }
							curNode := []int{matrix[tmp[1]+1][tmp[2]], tmp[1] + 1, tmp[2]}
							que = append(que, curNode)
						}
					}
					// 左
					if tmp[2]-1 >= 0 {
						if tmp[0] < matrix[tmp[1]][tmp[2]-1] && res[tmp[1]][tmp[2]]+1 > res[tmp[1]][tmp[2]-1] {
							res[tmp[1]][tmp[2]-1] = res[tmp[1]][tmp[2]] + 1
							// if res[tmp[1]][tmp[2]-1] > longest {
							// 	longest = res[tmp[1]][tmp[2]-1]
							// }
							curNode := []int{matrix[tmp[1]][tmp[2]-1], tmp[1], tmp[2] - 1}
							que = append(que, curNode)
						}
					}
					// 右
					if tmp[2]+1 < n {
						if tmp[0] < matrix[tmp[1]][tmp[2]+1] && res[tmp[1]][tmp[2]]+1 > res[tmp[1]][tmp[2]+1] {
							res[tmp[1]][tmp[2]+1] = res[tmp[1]][tmp[2]] + 1
							// if res[tmp[1]][tmp[2]+1] > longest {
							// 	longest = res[tmp[1]][tmp[2]+1]
							// }
							curNode := []int{matrix[tmp[1]][tmp[2]+1], tmp[1], tmp[2] + 1}
							que = append(que, curNode)
						}
					}
				}
			} else {
				continue
			}
		}
	}
	for i := 0; i < m; i++ {
		for j := 0; j < n; j++ {
			if res[i][j] > longest {
				longest = res[i][j]
			}
		}
	}
	return longest
}