【Leetcode】329. 矩阵中的最长递增路径

题目：矩阵中的最长递增路径

给定一个整数矩阵，找出最长递增路径的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。

解法一：可以看作一种拓扑排序过程，通过计算拓扑序列的长度计算最长长度，即剥洋葱算法

class Solution {
public:
	int dir[4][2] = { {0, 1}, {0, -1}, {1, 0}, {-1, 0} };    //方向数组：记录四个方向

	int longestIncreasingPath(vector<vector<int>>& matrix) {
		int ans = 0;
		vector<int> leave;
		if (matrix.size() == 0) return 0;    //判断所给矩阵是否为空
		int m = matrix.size();
		int n = matrix[0].size();

		vector<vector<int>> outdegree( m, vector<int>(n, 0) );   //记录顶点的出度

		//记录每个顶点的出度
		for(int i = 0; i < m; i++)
			for (int j = 0; j < n; j++) {
				for (int k = 0; k < 4; k++) {
					if (i + dir[k][0] >= 0 && i + dir[k][0] < m && j + dir[k][1] >= 0 && j + dir[k][1] < n && matrix[i][j] < matrix[i + dir[k][0]][j + dir[k][1]])
						outdegree[i][j]++;
				}
			}

		//拓扑排序的逆过程
		for (int i = 0; i < m; i++)
			for (int j = 0; j < n; j++)
				if (outdegree[i][j] == 0)
					leave.push_back(i*n + j);

		//" 剥洋葱过程 "
		while (!leave.empty()) {
			ans++;
			vector<int> newLeave;
			for (int i = 0; i < leave.size(); i++) {
				int x = leave[i] / n;
				int y = leave[i] % n;
				for (int k = 0; k < 4; k++) {
					if (x + dir[k][0] >= 0 && x + dir[k][0] < m && y + dir[k][1] >= 0 && y + dir[k][1] < n && matrix[x][y] > matrix[x + dir[k][0]][y + dir[k][1]])
						if (--outdegree[x + dir[k][0]][y + dir[k][1]] == 0)
							newLeave.push_back((x + dir[k][0])*n + y + dir[k][1]);
				}
			}
			leave = newLeave;
		}
		return ans;
	}
};

解法二：DFS+记忆化
记忆化定义：在计算中，记忆化是一种优化技术，它通过存储“昂贵”的函数调用的结果，在相同的输入再次出现时返回缓存的结果，以此加快程序的速度。

class Solution {
public:
	int dir[4][2] = { {0, 1}, {0, -1}, {1, 0}, {-1, 0} };    //方向数组：记录四个方向
	int m;
	int n;

	int longestIncreasingPath(vector<vector<int>>& matrix) {
		int ans = 0;
		vector<int> leave;
		if (matrix.size() == 0) return 0;    //判断所给矩阵是否为空
		m = matrix.size();
		n = matrix[0].size();

		vector<vector<int>> cache(m, vector<int>(n, 0));   //记录顶点的出度

		for (int i = 0; i < m; i++)
			for (int j = 0; j < n; j++)
				ans = max(ans, dfs(matrix, i, j, cache));
		
		return ans;
	}

	int dfs(vector<vector<int>>& matrix, int x, int y, vector<vector<int>>& cache) {
		if (cache[x][y] != 0)return cache[x][y];
		for (int i = 0; i < 4; i++)
			if (x + dir[i][0] >= 0 && x + dir[i][0] < m && y + dir[i][1] >= 0 && y + dir[i][1] < n && matrix[x][y] < matrix[x + dir[i][0]][y + dir[i][1]])
				cache[x][y] = max(cache[x][y], dfs(matrix, x + dir[i][0], y + dir[i][1], cache));

				//cache[x][y] = max(cache[x][y], dfs(matrix, x + dir[i][0], y + dir[i][1], cache) + 1);  //错误：注意不能在此处加1，否则返回结果出错，因为最大的结点没有计算在内
		return ++cache[x][y];
	}
};