10349 数字滑雪

为了解决这个问题，我们可以采用动态规划加深度优先搜索（DFS）的方法。这里的关键是使用一个辅助矩阵`dp`来存储从每个点开始的最长滑行距离。我们从每个点出发，尝试向四个方向滑行，只有当目标点的高度低于当前点的高度时，才可以滑行到那个点。通过递归的方式，我们可以找到从当前点出发的最长滑行距离，并将其存储在`dp`矩阵中，以避免重复计算。

### 伪代码
1. **初始化**：读入行数R和列数C，以及高度矩阵`heights`。创建一个同样大小的矩阵`dp`，初始化为-1，表示每个点的最长滑行距离尚未计算。
2. **定义DFS函数**：函数`dfs(x, y)`计算并返回从点`(x, y)`开始的最长滑行距离。
   - 如果`dp[x][y]`不为-1，直接返回`dp[x][y]`，表示这个点的最长滑行距离已经计算过。
   - 否则，对于`(x, y)`的四个方向的每个邻居`(nx, ny)`：
     - 如果`(nx, ny)`在矩阵范围内，且`heights[nx][ny] < heights[x][y]`，则递归调用`dfs(nx, ny)`。
     - 更新`dp[x][y]`为四个方向中的最大值加1。
   - 返回`dp[x][y]`。
3. **计算最长滑行距离**：对于矩阵中的每个点`(i, j)`，调用`dfs(i, j)`，并更新最长滑行距离的最大值。
4. **输出最长滑行距离**。

### C++代码实现

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

int R, C;
vector<vector<int>> heights;
vector<vector<int>> dp;

int dfs(int x, int y) {
    if (dp[x][y] != -1) return dp[x][y];
    dp[x][y] = 1; // 初始化为1，表示至少包含自己
    int dirs[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    for (auto &dir : dirs) {
        int nx = x + dir[0], ny = y + dir[1];
        if (nx >= 0 && nx < R && ny >= 0 && ny < C && heights[nx][ny] < heights[x][y]) {
            dp[x][y] = max(dp[x][y], dfs(nx, ny) + 1);
        }
    }
    return dp[x][y];
}

int main() {
    cin >> R >> C;
    heights.resize(R, vector<int>(C));
    dp.resize(R, vector<int>(C, -1));
    for (int i = 0; i < R; ++i) {
        for (int j = 0; j < C; ++j) {
            cin >> heights[i][j];
        }
    }

    int longest = 0;
    for (int i = 0; i < R; ++i) {
        for (int j = 0; j < C; ++j) {
            longest = max(longest, dfs(i, j));
        }
    }

    cout << longest << endl;
    return 0;
}

这段代码首先读入高度矩阵，然后对每个点使用DFS加动态规划的方法计算从该点出发的最长滑行距离，并更新全局的最长滑行距离。最后输出这个最长距离。