解题思路

这是一个求矩阵中最长递减路径的问题，可以通过记忆化搜索来解决：

  1. 对于矩阵中的每个点，都可以作为起点
  2. 从每个点出发，可以向上下左右四个方向移动，但要求移动到的点的高度严格小于当前点
  3. 使用记忆化数组来存储每个点作为起点的最长路径长度，避免重复计算
  4. 最终答案是所有点作为起点的最长路径中的最大值

代码

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

int dx[4] = {-1, 1, 0, 0};  // 方向数组：上下左右
int dy[4] = {0, 0, -1, 1};
int n, m;

int dfs(vector<vector<int>>& matrix, vector<vector<int>>& dp, int x, int y) {
    if (dp[x][y] != -1) return dp[x][y];
    
    dp[x][y] = 1;  // 初始长度为1
    
    // 遍历四个方向
    for (int i = 0; i < 4; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        
        // 检查边界和高度条件
        if (nx >= 0 && nx < n && ny >= 0 && ny < m && matrix[nx][ny] < matrix[x][y]) {
            dp[x][y] = max(dp[x][y], dfs(matrix, dp, nx, ny) + 1);
        }
    }
    
    return dp[x][y];
}

int main() {
    cin >> n >> m;
    vector<vector<int>> matrix(n, vector<int>(m));
    vector<vector<int>> dp(n, vector<int>(m, -1));
    
    // 输入矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> matrix[i][j];
        }
    }
    
    // 遍历每个点作为起点
    int result = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            result = max(result, dfs(matrix, dp, i, j));
        }
    }
    
    cout << result << endl;
    return 0;
}

import java.util.*;

public class Main {
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};
    static int n, m;
    
    public static int dfs(int[][] matrix, int[][] dp, int x, int y) {
        if (dp[x][y] != -1) return dp[x][y];
        
        dp[x][y] = 1;
        
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && matrix[nx][ny] < matrix[x][y]) {
                dp[x][y] = Math.max(dp[x][y], dfs(matrix, dp, nx, ny) + 1);
            }
        }
        
        return dp[x][y];
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        
        int[][] matrix = new int[n][m];
        int[][] dp = new int[n][m];
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                matrix[i][j] = sc.nextInt();
                dp[i][j] = -1;
            }
        }
        
        int result = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                result = Math.max(result, dfs(matrix, dp, i, j));
            }
        }
        
        System.out.println(result);
    }
}

def dfs(matrix, dp, x, y):
    if dp[x][y] != -1:
        return dp[x][y]
    
    dp[x][y] = 1
    dx = [-1, 1, 0, 0]
    dy = [0, 0, -1, 1]
    
    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]
        
        if (0 <= nx < n and 0 <= ny < m and matrix[nx][ny] < matrix[x][y]):
            dp[x][y] = max(dp[x][y], dfs(matrix, dp, nx, ny) + 1)
    
    return dp[x][y]

n, m = map(int, input().split())
matrix = []
for _ in range(n):
    matrix.append(list(map(int, input().split())))

dp = [[-1] * m for _ in range(n)]
result = 0

for i in range(n):
    for j in range(m):
        result = max(result, dfs(matrix, dp, i, j))

print(result)

算法及复杂度

  • 算法：深度优先搜索（DFS）+ 记忆化搜索
  • 时间复杂度： - 每个点最多被访问一次
  • 空间复杂度： - 需要一个二维 数组存储记忆化的结果

这道题的关键在于使用记忆化搜索来优化DFS。对于每个点，我们只需要计算一次从该点出发能达到的最长路径长度，并将结果存储在dp数组中。这样可以避免重复计算，大大提高效率。

方向数组的使用使得代码更加简洁，通过循环即可遍历四个方向。对于每个方向，我们需要检查：

  1. 新位置是否在矩阵范围内
  2. 新位置的高度是否严格小于当前位置

最终答案是所有起点中能获得的最长路径的最大值。