LeetCode 329. Longest Increasing Path in a Matrix

DFS

题目描述：

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.

解题思路：
找出以每个数作为起点所能走的最长路径，再输出其中最大的路径长度。考虑使用DFS，若当前某个数的四周有比其更大的数，则进入这个更大的数继续搜索。
为了简化过程，用一个另外的矩阵储存遍历图中的数所能到达的最大长度，若再次遍历到则不用重新计算。

代码如下：

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if (matrix.size() == 0 || matrix[0].size() == 0) return 0;
        this->matrix = matrix;
        path.clear();

        vector<int> inits;
        for (int i = 0; i < matrix[0].size(); i++) {
            inits.push_back(0);
        }
        for (int i = 0; i < matrix.size(); i++) {
            path.push_back(inits);
        }

        int max = 1;

        for (int i = 0; i < path.size(); i++) {
            for (int j = 0; j < path[0].size(); j++) {
                if (path[i][j] == 0) findPath(i, j);
                if (path[i][j] > max)
                    max = path[i][j];
            }
        }

        return max;
    }

private:

    void findPath(int x, int y) {
        int tmpLength;


        if (x < path.size()-1 && matrix[x][y] < matrix[x+1][y]) {
            tmpLength = getLongest(x+1, y);
            if (tmpLength > path[x][y]) path[x][y] = tmpLength;
        }

        if (x > 0 && matrix[x][y] < matrix[x-1][y]) {
            tmpLength = getLongest(x-1, y);
            if (tmpLength > path[x][y]) path[x][y] = tmpLength;
        }

        if (y < path[0].size()-1 && matrix[x][y] < matrix[x][y+1]) {
            tmpLength = getLongest(x, y+1);
            if (tmpLength > path[x][y]) path[x][y] = tmpLength;
        }

        if (y > 0 && matrix[x][y] < matrix[x][y-1]) {
            tmpLength = getLongest(x, y-1);
            if (tmpLength > path[x][y]) path[x][y] = tmpLength;
        }

        path[x][y]++;


    }

    int getLongest(int x, int y) {
        if (path[x][y] == 0)
            findPath(x, y);
        return path[x][y];
    }

    vector<vector<int> > path;
    vector<vector<int> > matrix;

};

提交结果为：
137 / 137 test cases passed.
Status: Accepted
Runtime: 33 ms
Your runtime beats 75.21 % of cpp submissions.