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

分析：

这道题一个很直接的想法是用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;    }};

>.< 好久没写博客系列