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

Example 2:

nums = [
  [3,4,5],
  [3,2,6],
  [2,2,1]
]

Return 4
The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.

题目要求找到矩阵中一条最长的递增的路径，可以用对每一个点使用广度优先搜索，找到能到达的最远的点，该路径就是最短路径．用二维数组ｄｉｓｔ［ｎ］［ｎ］存储到达该点的路径长度（当有更长的路径到达该点时，更新为该路径长度．）即如果ｄｉｓｔ［ｘ］［ｙ］是ｄｉｓｔ［ｉ］［ｊ］递增路径上的下一个点，当ｄｉｓｔ［ｉ］［ｊ］＜ｄｉｓｔ［ｘ］［ｙ］时，就无需更新ｄｉｓｔ［ｘ］［ｙ］，否则将ｄｉｓｔ［ｘ］［ｙ］更新为ｄｉｓｔ［ｉ］［ｊ］＋１．这样，我们可以降低广搜的次数．

#include <iostream>
#include <vector>
#include <queue>
#include <cmath>
using namespace std;
class Solution {
public:
	vector<vector<int>> dist;
    int longestIncreasingPath(vector<vector<int>>& matrix) {
    	dist=matrix;
    	for (auto &a:dist)
    		for (auto &b:a)
    			b=-1;

    	int length=0;
        for (int i = 0; i < matrix.size(); ++i)
        	for (int j = 0; j < matrix[i].size(); ++j) {
        		if (dist[i][j]!=-1) {
        			continue;
        		}
        		int tem= bfs(matrix,i,j);
        		if (tem > length)
        			length=tem;
        	}
        return length;
    }

    int bfs(vector<vector<int>>& matrix,int i, int j) {
    	dist[i][j]=0;
    	queue<pair<int,int> > q;
    	q.push(make_pair(i, j));
    	while (!q.empty()) {
    		auto a=q.front();
    		q.pop();
    		int x= a.first,y=a.second;
    		if (x-1 >= 0 &&matrix[x-1][y] > matrix[x][y]&&dist[x][y]+1>dist[x-1][y]) {
    			q.push(make_pair(x-1,y));
    			dist[x-1][y]=dist[x][y]+1;
    		}
    		if (x+1 < matrix.size()&& matrix[x+1][y] > matrix[x][y]&&dist[x][y]+1>dist[x+1][y]) {
    			q.push(make_pair(x+1,y));
    			dist[x+1][y]=dist[x][y]+1;
    		}
    		if (y-1 >= 0 && matrix[x][y-1] > matrix[x][y]&&dist[x][y]+1>dist[x][y-1]) {
    			q.push(make_pair(x,y-1));
    			dist[x][y-1]=dist[x][y]+1;
    		}
    		if (y+1 < matrix[0].size()&& matrix[x][y+1] > matrix[x][y]&&dist[x][y]+1>dist[x][y+1]) {
    			q.push(make_pair(x,y+1));
    			dist[x][y+1]=dist[x][y]+1;
    		}
    		if (q.empty()) {
    			return dist[x][y]+1;
    		}
    	}
    }
};