leecode 解题总结：329. Longest Increasing Path in a Matrix

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <unordered_map>
using namespace std;
/*
问题:
Given an integer matrix, find the length of the longest increasing path.

From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).

Example 1:

nums = [
  [9,9,4],
  [6,6,8],
  [2,1,1]
]
Return 4
The longest increasing path is [1, 2, 6, 9].

Example 2:

nums = [
  [3,4,5],
  [3,2,6],
  [2,2,1]
]
Return 4
The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.

分析:题目给定一个矩阵，需要寻找到矩阵中的最长递增序列。
之前寻找最长递增序列，是从后向前，设dp[i]表示A[i...n]中的最长递增序列长度
dp[i] = max( A[i] < A[j] ? dp[j] + 1 : dp[i]),其中j属于i+1到n-1
现在寻找最长递增子序列从一维数组变成矩阵了。
没有所谓的结束点了，从后向前遍历只能是罗列所有结束点，寻找路径，这样太麻烦。
而且方向不确定。

如果采用深度优先搜索，沿着某个初始结点，不断向四个方向中比自己大的方向移动，
然后统计4个方向里面的最长路径加上1作为以该起点的最长路径。
然后把所有结点遍历一遍，遍历一个结点所有方向路径时间复杂度为O(n^2)，
总的时间复杂度为O(n^3)。
大致的样子应该是
int len1 = dfs(matrix , row - 1 , col);
int len2 = dfs(matrix , row + 1 , col);
int len3 = dfs(matrix , row , col - 1);
int len4 = dfs(matrix , row , col + 1);
int maxLen = maxNum(len1 , len2 , len3 , len4) + 1;
return maxLen;
注意：如何避免已经访问的结点再次访问，需要设置访问数组。
注意该访问数组，计算后要回溯，因为别的路径仍然会用到这个点

输入:
3(行数) 3(列数) 
9 9 4
6 6 8
2 1 1

3 3
3 4 5
3 2 6
2 2 1

输出:
4
4

果然超时:可否改成动态规划
设dp[i][j]表示以结点Matrix[i][j]作为起点的最大递增子序列长度
初始的时候，任意dp元素都为1
//4个方向的最大值
int dpLeft , dpRight , dpUp , dpDown;
dpLeft = dpRight = dpUp = dpDown = 0;
if(dp[i][j] != 1)
{
	return dp[i][j];
}
if(i-1 >=0 && 1 == dp[i-1][j])
{
	dp[i-1][j] = dfs();
	dpLeft = dp[i-1][j];
}
if(i+1 < row && 1 == dp[i+1][j])
{
	dp[i+1][j] = dfs();
	dpRight = dp[i+1][j]; 
}
if(j-1 >= 0 && 1 == dp[i][j-1])
{
	dp[i][j-1] = dfs();
	dpDown = dp[i][j-1];
}
if(j+1 < col && 1 == dp[i][j+1])
{
	dp[i][j+1] = dfs();
	dpUp = dp[i][j+1];
}
dp[i][j] = max( dpLeft , dpRight , dpDown , dpUp ) + 1;


关键:
1 采用回溯 + 记忆化搜索，否则超时
如果采用深度优先搜索，沿着某个初始结点，不断向四个方向中比自己大的方向移动，
然后统计4个方向里面的最长路径加上1作为以该起点的最长路径。
*/

class Solution {
public:
	int maxNum(int a, int b , int c , int d)
	{
		return max( max(a , b) , max(c, d) );
	}

	int dfs(vector<vector<int>>& matrix , int curRow , int curCol, int len , 
		unordered_map<string , bool>& visited , vector< vector<int> >& dp)
	{
		if(matrix.empty())
		{
			return 0;
		}
		//递归基，验证参数是否有效
		int row = matrix.size();
		int col = matrix.at(0).size();
		//参数超过范围，返回原来长度
		if(curRow < 0 || curRow >= row || curCol < 0 || curCol >= col)
		{
			return len;
		}
		//如果当前结点已经访问过，直接返回现有长度
		string key = to_string(curRow) + "#" + to_string(curCol);
		if(visited.find(key) != visited.end())
		{
			return len;
		}

		//如果已经计算过值，直接返回
		if(dp.at(curRow).at(curCol) != 1)
		{
			return dp.at(curRow).at(curCol);
		}

		//设置当前结点已经访问过
		visited[key] = true;
		int len1 , len2, len3 , len4;
		len1 = len2 = len3 = len4 = 0;
		//如果当前位置有效，就递归访问4个方向，注意设置访问标记
		//判定该方向是否需要访问，即当前位置元素是否小于待遍历方向上的元素
		if(0 <= curRow - 1 && curRow - 1 < row && matrix.at(curRow).at(curCol) < matrix.at(curRow-1).at(curCol))
		{
			len1 = dfs(matrix , curRow - 1 , curCol , len + 1 , visited, dp);
		}
		if(0 <= curRow + 1 && curRow + 1 < row && matrix.at(curRow).at(curCol) < matrix.at(curRow+1).at(curCol))
		{
			len2 = dfs(matrix , curRow + 1 , curCol , len + 1 , visited , dp);
		}
		if(0 <= curCol - 1 && curCol - 1 < col && matrix.at(curRow).at(curCol) < matrix.at(curRow).at(curCol - 1))
		{
			len3 = dfs(matrix , curRow , curCol - 1 , len + 1 , visited ,dp);
		}
		if(0 <= curCol + 1 && curCol + 1 < col && matrix.at(curRow).at(curCol) < matrix.at(curRow).at(curCol + 1))
		{
			len4 = dfs(matrix , curRow , curCol + 1 , len + 1 , visited ,dp);
		}
		//回溯，清空访问标记
		visited.erase(key);
		int maxLen = maxNum(len1 , len2 , len3 , len4) + 1;//这里需要加上当前的长度
		//将结果存储起来
		dp.at(curRow).at(curCol) = maxLen;
		return maxLen;
	}

    int longestIncreasingPath(vector<vector<int>>& matrix) {
		if(matrix.empty())
		{
			return 0;
		}
		//递归基，验证参数是否有效
		int row = matrix.size();
		int col = matrix.at(0).size();
		int result;
		int maxLen = INT_MIN;
		unordered_map<string , bool> visited;
		vector<vector<int> > dp( row , vector<int>(col , 1) );
 		for(int i = 0 ; i < row ; i++)
		{
			for(int j = 0 ; j < col ; j++)
			{
				visited.clear();
				//默认传入的初始长度为1，至少有一个元素
				result = dfs(matrix , i , j , 1 , visited , dp);
				maxLen = max(maxLen , result);
			}
		}
		return maxLen;
    }
};


void process()
{
	 vector< vector<int> > matrix;
	 int value;
	 int row;
	 int col;
	 Solution solution;
	 int result;
	 while(cin >> row >> col )
	 {
		 matrix.clear();
		 for(int i = 0 ; i < row ; i++)
		 {
			 vector<int> nums;
			 for(int j = 0 ; j < col ; j++)
			 {
				 cin >> value;
				 nums.push_back(value);
			 }
			 matrix.push_back(nums);
		 }
		 result = solution.longestIncreasingPath(matrix);
		 cout << result << endl;
	 }

}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}

/*
	int maxNum(int a, int b , int c , int d)
	{
		return max( max(a , b) , max(c, d) );
	}

	int dfs(vector<vector<int>>& matrix , int curRow , int curCol, int len , unordered_map<string , bool>& visited)
	{
		if(matrix.empty())
		{
			return 0;
		}
		//递归基，验证参数是否有效
		int row = matrix.size();
		int col = matrix.at(0).size();
		//参数超过范围，返回原来长度
		if(curRow < 0 || curRow >= row || curCol < 0 || curCol >= col)
		{
			return len;
		}
		//如果当前结点已经访问过，直接返回现有长度
		string key = to_string(curRow) + "#" + to_string(curCol);
		if(visited.find(key) != visited.end())
		{
			return len;
		}
		//设置当前结点已经访问过
		visited[key] = true;
		int len1 , len2, len3 , len4;
		len1 = len2 = len3 = len4 = 0;
		//如果当前位置有效，就递归访问4个方向，注意设置访问标记
		//判定该方向是否需要访问，即当前位置元素是否小于待遍历方向上的元素
		if(0 <= curRow - 1 && curRow - 1 < row && matrix.at(curRow).at(curCol) < matrix.at(curRow-1).at(curCol))
		{
			len1 = dfs(matrix , curRow - 1 , curCol , len + 1 , visited);
		}
		if(0 <= curRow + 1 && curRow + 1 < row && matrix.at(curRow).at(curCol) < matrix.at(curRow+1).at(curCol))
		{
			len2 = dfs(matrix , curRow + 1 , curCol , len + 1 , visited);
		}
		if(0 <= curCol - 1 && curCol - 1 < col && matrix.at(curRow).at(curCol) < matrix.at(curRow).at(curCol - 1))
		{
			len3 = dfs(matrix , curRow , curCol - 1 , len + 1 , visited);
		}
		if(0 <= curCol + 1 && curCol + 1 < col && matrix.at(curRow).at(curCol) < matrix.at(curRow).at(curCol + 1))
		{
			len4 = dfs(matrix , curRow , curCol + 1 , len + 1 , visited);
		}
		//回溯，清空访问标记
		visited.erase(key);
		int maxLen = maxNum(len1 , len2 , len3 , len4) + 1;//这里需要加上当前的长度
		return maxLen;
	}

    int longestIncreasingPath(vector<vector<int>>& matrix) {
		if(matrix.empty())
		{
			return 0;
		}
		//递归基，验证参数是否有效
		int row = matrix.size();
		int col = matrix.at(0).size();
		int result;
		int maxLen = INT_MIN;
		unordered_map<string , bool> visited;
		for(int i = 0 ; i < row ; i++)
		{
			for(int j = 0 ; j < col ; j++)
			{
				visited.clear();
				//默认传入的初始长度为1，至少有一个元素
				result = dfs(matrix , i , j , 1 , visited);
				maxLen = max(maxLen , result);
			}
		}
		return maxLen;
    }
*/