Find the longest route with the smallest starting point

前提：對於一個給定的二維整數矩陣，若是一個元素i的某個4-相鄰位置上的另外一個元素j正好值爲i-1則i到j能夠造成一條通路。

輸入：M個N*N整數矩陣；

輸出：對於每一個輸入的矩陣，輸出 矩陣中可造成的最長通路長度 及 在該最長通路長度的狀況下最小的起始點值。

 e.g.

input:

4 5 6 1 2 3 7 0 5 8 2 1 6 7 3 4

 

 

output:

4 0

 

idea:

遍歷輸入矩陣中每一個位置，compute()計算以該位置爲起點的最長route長度->找出 最長route長度 及 該長度下最小的起點值。

compute(r,c)

 

traverse 4個方向上的相鄰位置：
       if 當前位置到該相鄰位置(nr,nc)能夠造成通路（input[r][c]==input[nr][nc]-1)
             neighbor_route_length:=compute(nr,nc)
       end    
end
 if traverse 完4個方向上都沒造成任何通路，返回0    
 else 有找到通路，返回 neighbor_route_length的最大值+1

 

 

-----------------------------------分割線

 

能夠引入緩存矩陣buffer[N][N]做爲hash table存儲先前計算過的compute(r,c)值

i.e. 對於某個肯定能夠造成通路的相鄰位置(nr,nc)，若是buffer中有緩存已經計算過的route_length值，則再也不調用compute，直接提取buffer[nr][nc]。

compute2(r,c)

traverse 4個方向上的相鄰位置：
       if 當前位置到該相鄰位置(nr,nc)能夠造成通路（input[r][c]==input[nr][nc]-1)
            if  buffer[nr][nc]已有記錄
                neighbor_route_length:=buffer[nr][nc]
            else //沒有記錄
                neighbor_route_length:=compute(nr,nc)
            end
       end    
end
 if traverse 完4個方向上都沒造成任何通路，返回0    
 else 有找到通路，返回 neighbor_route_length的最大值+1

 

 

code：

class Solution {
  public:
    pair<int,int> getAnswer(vector<vector<int>> input) {
        int N=input.size();
        vector<vector<int>> buffer(N,vector<int>(N,-1));
        int longest_length=-1, starting_point=-1;
        for (int r=0;r<N;r++) {
            for (int c=0;c<N;c++) {
                int current_length=compute_route(N,input,buffer,r,c);
                if (current_length>longest_length||
                    (current_length==longest_length&&starting_point>input[r][c])) {
                    longest_length=current_length;
                    starting_point=input[r][c];
                }
            }
        }
        return pair<int,int>(longest_length, starting_point);
    }
 //雖然忽然想起好像原始題目是每一個位置的全部4個方向中只有最多一條通路
 //可是由於比較無聊就加大一點難度：每一個位置有可能有多條通路 要找出最長的一條 罷了 //what if there might be more than 1 route from a starting point
    int compute_route(int N, vector<vector<int>>& input, vector<vector<int>>& buffer, int r, int c) {
        int neighbors[4][2]={{r-1,c},{r,c-1},{r,c+1},{r+1,c}};
        int neighbor_route_length=-1, answer;
        for (int i=0;i<4;i++) {
            int neighbor_r=neighbors[i][0], neighbor_c=neighbors[i][1];
            if (neighbor_r>=0&&neighbor_r<N&&neighbor_c>=0&&neighbor_c<N) {
                if (input[neighbor_r][neighbor_c]==input[r][c]+1) {
                    if (buffer[neighbor_r][neighbor_c]!=-1) {
                        neighbor_route_length=max(neighbor_route_length, buffer[neighbor_r][neighbor_c]);
                    } else {
                        neighbor_route_length=max(neighbor_route_length,compute_route(N, input, buffer, neighbor_r, neighbor_c));
                    }
                }
            }
        }
        if (neighbor_route_length==-1) //no route found
            answer=0;
        else
            answer=neighbor_route_length+1;
        buffer[r][c]=answer;
        return answer;
    }
};