在矩阵中找到最长的递增路径

Question

这是在线评委， https://leetcode.com/problems/longest-increasing-path-in-a-matrix/

为什么我无法使用 DFS 获得结果？

正如您从每个单元格中知道的那样，您可以向四个方向移动：左、右、上或下。

存储最长递增路径的长度。

/*

for each elem, neighbours dfs

*/
class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        int row = matrix.size();
        int col = matrix[0].size();
        int x[] = {0,1,0,-1};// l-r       -1,1    
        int y[] = {1,0,-1,0};// up-down   +1,-1
        int maxlen = 0;

        for(int i = 0; i < row; i++){
            for(int j = 0; j< col; j++){
                // each node in the matrix[i][j], neighbours
                int len = 0;
                dfs(maxlen, len, i, j, x, y, matrix);
            }
        }
        return maxlen;
    }

private:
    bool isIn(int x, int y, int row, int col){
        if(x>=0&&x<=col && y>=0&&y<=row) return true;
        else return false;
    }

    void dfs(int& maxlen, int len, int i, int j,int* x, int* y, vector<vector<int>> matrix){
        int row = matrix.size();
        int col = matrix[0].size();

        for(int k = 0; k < 4; k++){
            int i_t = i+x[k];//the current position
            int j_t = j+y[k];
            if(isIn(i_t,j_t,row,col)&& (matrix[i_t][j_t]>matrix[i][j]) ){ // if inside the matrix, within the boundary&& the value of (i_t,j_t)> 
                len+=1;
                maxlen = max(len,maxlen);
                dfs(maxlen, len, i_t, j_t, x, y, matrix);
            }
        }
    }
};

Answer 1

此代码存在多个问题。

1. if(x>=0&&x<=col && y>=0&&y<=row) 应改为if(x>=0&&x<col && y>=0&&y<row)

2. 您将源自一个元素的所有路径添加到一起，这会导致错误答案。 这部分代码

   len+=1;
   maxlen = max(len,maxlen);
   dfs(maxlen, len, i_t, j_t, x, y, matrix);
   

   应该改为：

   //len+=1;
   maxlen = max(len+1,maxlen);
   dfs(maxlen, len+1, i_t, j_t, x, y, matrix);
   

   这样您就不会将不同方向的所有路径添加在一起。

   1. 您正在解决许多重叠的问题。调用dfs(r,c) 后，您可以保存其结果，并将该值用于将来的引用（动态编程）。

这就是我的实现方式：

#include <vector>
#include <iostream>
#include <map>
using namespace std;

map< pair<int,int>, int > dp;
pair<int,int> moves[] = {{0,1},{0,-1},{1,0},{-1,0}};
vector<vector<int> > matrix = { {3,4,5},
                                {3,2,6},
                                {2,2,1}};

int dfs(int r, int c, int n_rows, int n_cols){
    pair<int,int> p = make_pair(r,c);
    if ( dp.count(p) ){
        return dp[p];
    }
    int mx = 0;
    for ( int i=0; i<4; ++i ){
        int next_r = r+moves[i].first;
        int next_c = c+moves[i].second;
        if ( 0<=next_r && next_r < n_rows && 0<=next_c && next_c < n_cols ){
            if ( matrix[next_r][next_c] > matrix[r][c] )
                mx = max(mx, dfs(next_r, next_c, n_rows, n_cols));
        }
    }
    mx++;
    dp[p] = mx;
    return mx;
}

int main(){
    int rows = matrix.size();
    int cols = matrix[0].size();
    int result = 0;
    for ( int i=0; i<rows; ++i ){
        for ( int j=0; j<cols; ++j ){
            result = max(result, dfs(i,j,rows,cols));
        }
    }
    cout << result << endl;                                    
}

Answer 2

这是我使用 DFS + 记忆的解决方案

class Solution {
    int r;
    int c;
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        r = matrix.size();
        if(r == 0) return 0;
        c= matrix[0].size();
        int maxlength = 0;
        vector<vector<int>> dfs(r, vector<int>(c, 0));
        for(int i = 0; i < r; ++i) {
            for(int j = 0 ; j < c; ++j) {
                int curr = recursive(i,j, dfs, matrix);
                maxlength = max(maxlength, curr); 
            }
        }
        return maxlength;
    }

    int recursive(int i, int j, vector<vector<int>>& dfs, vector<vector<int>>& matrix) {
        if(dfs[i][j] != 0) return dfs[i][j];
        else {
            int maxi = 1;

            // b.c 1
            if (i-1 >= 0 && (matrix[i-1][j]>matrix[i][j])) {
                maxi = max(maxi,1+ recursive(i-1, j, dfs, matrix));
            }

            // b.c 2
            if (j -1 >=0 && (matrix[i][j-1]>matrix[i][j])) {
                maxi = max(maxi,1+ recursive(i, j-1, dfs, matrix));
            }

            // b.c 3

            if (i+1 < r && (matrix[i+1][j]>matrix[i][j])) {
                maxi = max(maxi,1+ recursive(i+1, j, dfs, matrix));
            }

            // b.c. 4
            if(j+1 < c && (matrix[i][j+1]>matrix[i][j])) {
                    maxi = max(maxi,1+ recursive(i, j+1, dfs, matrix));
            }            
         dfs[i][j] = maxi;
        return maxi;
        }

    }
};