[Leetcode] 329. Longest Increasing Path in a Matrix 解题报告

题目：

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.

思路：

1、BFS：由于越小的数字其递减链越长，所以我们先对数据元素进行排序，然后依次从大的数据元素开始处理：对于每个元素，一旦发现周围有比它小的元素，并且其目前的路径长度小于当前元素的最长路径（已经是最终值了，将来不会再更新，请思考为什么？）加1，则更新。最终返回所有路径中的最大值即可。

2、DFS：DFS的好处是不需要对数据元素进行有序处理，但是朴素的DFS也存在重复计算的问题：例如对于图中所给出的测试用例，在其最长路径9,6,2,1上，我们计算9的过程中就已经把6,2和1的路径都计算过了，但是在碰到6的时候还需要再重复计算一次。一个有效的解决方法就是采用DFS+记忆。一旦计算出来了某个数据元素的最长路径，则将其保存下来，这样在后面的计算中，如果发现该位置上的元素已经被计算出来了，则直接利用所保存的结果。DFS的代码写出来比BFS要简洁一些。

代码：

1、BFS：

class Solution {public:    int longestIncreasingPath(vector<vector<int>>& matrix) {        if(matrix.size() == 0 || matrix[0].size() == 0) {            return 0;        }        int row_num = matrix.size(), col_num = matrix[0].size();        multimap<int, pair<int, int>> value_maps;        for(int i = 0; i < row_num; ++i) {            for(int j = 0; j < col_num; ++j) {                value_maps.insert(make_pair(matrix[i][j], make_pair(i, j)));            }        }        vector<vector<int>> paths(row_num, vector<int>(col_num, 1));        int max_path = 1;        for(auto it = value_maps.rbegin(); it != value_maps.rend(); ++it) {            int value = it->first;            int row = it->second.first, col = it->second.second;            if(row > 0 && matrix[row-1][col] < value) {                paths[row-1][col] = max(paths[row-1][col], paths[row][col] + 1);                max_path = max(max_path, paths[row-1][col]);            }            if(row < row_num - 1 && matrix[row+1][col] < value) {                paths[row+1][col] = max(paths[row+1][col], paths[row][col] + 1);                max_path = max(max_path, paths[row+1][col]);            }            if(col > 0 && matrix[row][col-1] < value) {                paths[row][col-1] = max(paths[row][col-1], paths[row][col] + 1);                max_path = max(max_path, paths[row][col-1]);            }            if(col < col_num - 1 && matrix[row][col+1] < value) {                paths[row][col+1] = max(paths[row][col+1], paths[row][col] + 1);                max_path = max(max_path, paths[row][col+1]);            }        }        return max_path;    }};

2、DFS：

class Solution {public:    int longestIncreasingPath(vector<vector<int>>& matrix) {                if(matrix.size() == 0 || matrix[0].size() == 0) {            return 0;        }        int row = matrix.size(), col = matrix[0].size();        int ret = 0;        for(int i = 0; i < row; ++i){            for(int j = 0; j < col; ++j) {                ret = max(ret, dfs(matrix, i, j, LONG_MIN));            }        }        return ret;    }private:    int dfs(vector<vector<int>>& matrix, int x, int y, long val) {        int row = matrix.size(), col = matrix[0].size();        if(x < 0 || x >= row || y < 0 || y >= col || matrix[x][y] <= val) {     // out of boundary or no-larger values            return 0;        }        if(hash.count(x * col + y)) {                                           // has already been calculated            return hash[x * col + y];        }        int len1 = dfs(matrix, x + 1, y, matrix[x][y]);        int len2 = dfs(matrix, x - 1, y, matrix[x][y]);        int len3 = dfs(matrix, x, y + 1, matrix[x][y]);        int len4 = dfs(matrix, x, y - 1, matrix[x][y]);        int max_len = max(max(len1, len2), max(len3, len4)) + 1;        hash[x * col + y] = max_len;        return max_len;    }    unordered_map<int, int> hash;};