leetcode 解题记录 Longest Increasing Path in a Matrix

自己的解法：思路：找出可能的最长上升序列 的起点， 然后层序遍历以该节点为根节点的 上升树，得到树的层数

缺点：效率太低； 当树层数高时，如果多个节点都有 约2个 子节点，则n层的节点数 是指数 增加的；运行 超时  

class Solution {

public:
    int levelTravel(vector<vector<int> > matrix, int index)
    {
        int totalRow = matrix.size();
        int totalCol = matrix[0].size();
    
        queue<int> q;
        q.push(index);
    
        int frontIndex = 0;
        int level = 1;
        int popNum = 0; // 当前层 pop数
    
        vector<int> total_level(3, 0);
        total_level[1] = 1;
    
        int col = 0;
        int row = 0;
    
        while(!q.empty()){
            
            frontIndex = q.front();
            q.pop();
            popNum++;
            
            // 出队列 元素坐标
            row = floor(frontIndex / totalCol);
            col = frontIndex % totalCol;
            
            if (row > 0 && matrix[row - 1][col] > matrix[row][col]){
                q.push((row - 1)* totalCol + col);
                total_level[level + 1]++;
            }
            
            if (row < totalRow - 1 && matrix[row + 1][col] > matrix[row][col])
            {
                q.push((row + 1)* totalCol + col);
                total_level[level + 1]++;
            }
            
            if (col > 0 && matrix[row][col - 1] > matrix[row][col])
            {
                q.push(row * totalCol + col - 1);
                total_level[level + 1]++;
            }
            
            if (col < totalCol - 1 && matrix[row][col + 1] > matrix[row][col])
            {
                q.push(row * totalCol + col + 1);
                total_level[level + 1]++;
            }
            
            if (popNum >= total_level[level]) //当前层全部 遍历
            {
                level++;
                popNum = 0;
                total_level.push_back(0);
            }
        }
    
        return level - 1;
    }
    
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if (matrix.empty())
            return 0;
        //    起点队列
        vector<int> startIndex;
    
        int row = matrix.size();
        int col = matrix[0].size();
        
        for (int i = 0; i != row; i++)
        {
            for (int j = 0; j!= col; j++)
            {
                if (i > 0 && matrix[i - 1][j] < matrix[i][j])
                {
                    continue;
                }
                if (i < row - 1 && matrix[i + 1][j] < matrix[i][j])
                {
                    continue;
                }
                if (j > 0 && matrix[i][j - 1] < matrix[i][j])
                {
                    continue;
                }
                if (j < col - 1 && matrix[i][j + 1] < matrix[i][j])
                {
                    continue;
                }
                startIndex.push_back(i * col + j);
            }
        }
    
        vector<int>::iterator i;
        int maxLevel = 1;
        for (i = startIndex.begin(); i != startIndex.end(); i++)
        {
            int level = levelTravel(matrix, *i);
            if (level > maxLevel)
                maxLevel = level;
            // cout << "row：" << floor(*i / col) << " col:" << (*i % col)  << " level:" << level << endl;
        }
    
         return maxLevel;  
    }

};

解法二：

class Solution {
public:

//  注意vector<vector<int> >& matrix 一定要写成直接 引用 否则会不通过（空间？）
    int dfs(int x, int y, int m, int n, vector<vector<int> >& matrix, vector<vector<int> >& dis)
    {

// 记忆
        if (dis[x][y] != 0)
        {
            // cout << "已算出 " << x << " " << y << endl;
            return dis[x][y];
        }
        
        if (x > 0 && matrix[x - 1][y] < matrix[x][y])
            dis[x][y] = max(dis[x][y], dfs(x - 1, y, m, n, matrix, dis));
        if (x < m - 1 && matrix[x + 1][y] < matrix[x][y])
            dis[x][y] = max(dis[x][y], dfs(x + 1, y, m, n, matrix, dis));
        if (y > 0 && matrix[x][y - 1] < matrix[x][y])
            dis[x][y] = max(dis[x][y], dfs(x, y - 1, m, n, matrix, dis));
        if (y < n - 1 && matrix[x][y + 1] < matrix[x][y])
            dis[x][y] = max(dis[x][y], dfs(x, y + 1, m, n, matrix, dis));
            
        dis[x][y] ++;
        return dis[x][y];
    }
    
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if (matrix.empty())
            return 0;
        int m = matrix.size();
        int n = matrix[0].size();
        vector<vector<int> > dis(m, vector<int> (n, 0));
        
        int maxDis = 0;
        
        for (int i = 0; i <= m - 1; i++)
        {
            for (int j = 0; j <= n - 1; j++)
            {
                maxDis = max(maxDis, dfs(i, j, m, n, matrix, dis));
            }
        }
        return maxDis;
    }
};

算法思想：分治算法，记忆化

本博客若无特殊说明则由 hrwhisper 原创发布

转载请点名出处：细语呢喃 > leetcode Longest Increasing Path in a Matrix
本文地址：https://www.hrwhisper.me/leetcode-longest-increasing-path-matrix/