luogu P2196

知识点总结：P2196 问题解析和解法

问题描述：在这个问题中，给定一个 r × l 的矩阵，矩阵中的每个元素表示一个高度。一个滑雪者可以从较高的点滑向较低的相邻点（上下左右四个方向）。求滑雪者可以滑行的最长路径。

这个问题可以用**深度优先搜索（DFS）与动态规划（记忆化搜索）**结合的方式解决。

1. 动态规划状态说明（DP状态说明）

• 状态定义：定义 dp[x][y] 为从位置 (x, y) 出发所能滑行的最长路径。
• 初始状态：dp[x][y] 的初始值为 1，因为每个位置至少可以作为起点滑行一次。

2. 递推公式

对于每个位置 (x, y)，可以向相邻的四个方向移动，如果相邻位置 (nx, ny) 的高度比当前位置低，即 maps[nx][ny] < maps[x][y]，则可以从 (x, y) 移动到 (nx, ny)。递推公式如下：
[
dp[x][y] = \max(dp[x][y], dp[nx][ny] + 1)
]

• 使用 DFS 和记忆化搜索来更新 dp[x][y] 的最大值。

3. 代码实现

根据上述思路，代码如下：

#include <bits/stdc++.h>

using namespace std;

const int N = 105;
int maps[N][N];       // 地图高度
int dp[N][N];         // dp数组存储从每个点出发的最长路径
int dis[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; // 四个方向

// 深度优先搜索（DFS）函数，带有记忆化搜索
int dfs(int x, int y, int r, int l)
{
   if (dp[x][y]) // 若该点已计算过，则直接返回
      return dp[x][y];

   dp[x][y] = 1; // 初始化当前点的路径长度为 1
   for (int i = 0; i < 4; i++) // 遍历四个方向
   {
      int nx = x + dis[i][0];
      int ny = y + dis[i][1];
      
      // 检查边界并确保邻接点比当前点小
      if (nx >= 1 && nx <= r && ny >= 1 && ny <= l && maps[nx][ny] < maps[x][y])
      {
         dp[x][y] = max(dfs(nx, ny, r, l) + 1, dp[x][y]); // 递归计算最长路径
      }
   }
   return dp[x][y];
}

int main()
{
   int r, l;
   cin >> r >> l;

   // 输入地图的高度值
   for (int i = 1; i <= r; i++)
   {
      for (int j = 1; j <= l; j++)
      {
         cin >> maps[i][j];
      }
   }

   int max_value = 0; // 初始化为 0，以便找到正确的最大值
   // 遍历所有点，计算每个点的最长路径，并记录全局最大值
   for (int i = 1; i <= r; i++)
   {
      for (int j = 1; j <= l; j++)
      {
         max_value = max(max_value, dfs(i, j, r, l));
      }
   }

   cout << max_value;

   return 0;
}

解释

• DFS + 记忆化搜索：使用 DFS 递归搜索每个位置 (x, y) 的最长路径。为了避免重复计算，在访问过的点上使用 dp[x][y] 记录结果，如果 dp[x][y] 已经计算过，则直接返回。
• 四个方向移动：使用 dis 数组表示上下左右四个方向的移动偏移。
• 更新最大值：在 main 函数中遍历每个位置 (i, j)，调用 dfs 计算从该点出发的最长路径，更新全局最大值 max_value。

总结

这个问题的核心是使用 DFS 与记忆化搜索相结合，以避免重复计算并优化效率。这种方法在搜索问题中尤其适合带有重叠子问题的场景。