LeetCode329. Longest Increasing Path in a Matrix

最新推荐文章于 2020-09-30 12:50:50 发布

Lonvon_

最新推荐文章于 2020-09-30 12:50:50 发布

阅读量386

点赞数

分类专栏： LeetCode 文章标签： leetcode

本文链接：https://blog.csdn.net/Lonvon_/article/details/53066024

版权

LeetCode 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

题目：

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].

分析：

这道题一个很直接的想法是用DFS来遍历所有的可能性，找到最长的路径。但用如此暴力的方法是无法通过的。

进一步想，如果把矩阵转化为一个有向图：在矩阵M中，每个元素Mij是图中的一个顶点；如果Mkh在Mij的上下左右四个方向上且Mij大于Mkh，则存在Mij到Mkh的有向边。完成转化后，题目的问题就相当于在有向图中找一条最长的路径（此图是按照大小关系连接起来的，不会形成圈，当然也不会有多重边和自环。这个有向图不是树，因为可能不是连通的。）。找有向图中的最长路径问题，把有向图的顶点进行拓扑排序，再用动态规划进行一次遍历即可。

在用上面的思路写完提交后，依然超时了。想了想，发现问题在拓扑排序上。最开始拓扑排序是用O(n^2)的两重循环来实现。在这种矩阵转化成的有向图中，有很多时候把一个顶点从图中去掉之后，这个图的后继顶点很有可能变为入度为0的顶点。所以用DFS来进行拓扑排序。从Leetcode上的耗时来看，这样子也是险些通过。

代码如下：

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

class Solution {
public:
    int row, col, index;
    vector<vector<int> > next;
    vector<int> pre, d;
    vector<bool> flag;
    map<int, int> mymp, rmymp;
    
    void dfs(int i, int j) {
        int t = i * col + j;
        if (pre[t] != 0) return;
        flag[t] = true;
        mymp[t] = index;
        rmymp[index++] = t;
        for (int k = 0; k < next[t].size(); k++) {
            pre[next[t][k]]--;
        }
        int nx[4] = {0, 1, -1, 0};
        int ny[4] = {1, 0, 0, -1};
        for (int k = 0; k < 4; k++) {
            int ni = i + nx[k];
            int nj = j + ny[k];
            if (ni >= 0 && ni < row && nj >= 0 && nj < col && !flag[ni * col + nj]) {
                dfs(ni, nj);
            }
        }
    }

    int longestIncreasingPath(vector<vector<int> >& matrix) {
        row = matrix.size();
        if (row == 0) return 0;
        col = matrix[0].size();
        int ele = row * col;
        pre.clear();
        d.clear();
        flag.clear();
        next.clear();
        mymp.clear();
        rmymp.clear();
        for (int i = 0; i < ele; i++) {
            pre.push_back(0);
            d.push_back(1);
            flag.push_back(false);
            next.push_back(vector<int>());
        }
        int nx[4] = {0, 1};
        int ny[4] = {1, 0};
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                for (int k = 0; k < 2; k++) {
                    int ni = i + nx[k];
                    int nj = j + ny[k];
                    if (ni >= 0 && ni < row && nj >= 0 && nj < col) {
                        if (matrix[ni][nj] > matrix[i][j]) {
                            next[i * col + j].push_back(ni * col + nj);
                            pre[ni * col + nj]++;
                        } else if (matrix[ni][nj] < matrix[i][j]) {
                            next[ni * col + nj].push_back(i * col + j);
                            pre[i * col + j]++;
                        }
                    }
                }
            }
        }

        index = 0;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (!flag[i * col + j]) {
                    dfs(i, j);
                }
            }
        }
        int res = d[0];
        for (int i = 0; i < ele; i++) {
            for (int k = 0; k < next[rmymp[i]].size(); k++) {
                int j = mymp[next[rmymp[i]][k]];
                d[j] = max(d[i] + 1, d[j]);
                res = max(res, d[j]);
            }
        }
        return res;
    }
};

>.< 好久没写博客系列