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;
}
};

>.< 好久没写博客系列