每日OJ题_牛客_DP18滑雪_记忆化搜索_C++

读取输入，初始化矩阵存储滑雪场的高度信息，初始化 dp 数组用于存储从每个位置出发的最长滑道长度。初始化 dx 和 dy 数组表示四个可能的移动方向。
定义 dfs(x, y) 函数，该函数返回从位置 (x, y) 开始的最长滑道长度。
如果 dp[x][y] 不为0，说明已经计算过，直接返回。否则，初始化 dp[x][y] 为1（即当前位置至少构成长度为1的滑道）。
尝试向四个方向移动，如果新位置 (nx, ny) 的高度低于当前位置，则递归调用 dfs(nx, ny) 并更新 dp[x][y]。
遍历所有位置，调用 dfs 函数并更新答案 ret。最后输出答案ret。

C++代码1DFS

#include <iostream>
#include <vector>
using namespace std;
int n = 0, m = 0, len = 1, resLen = 0;
vector<int> path;
bool vis[101][101];
int dx[4] = {0, 0, -1, 1};
int dy[4] = {1, -1, 0, 0};

void dfs(vector<vector<int>>& arr, int sr, int sc)
{
    resLen = max(len, resLen);
    for(int i = 0; i < 4; ++i)
    {
        int x = sr + dx[i], y = sc + dy[i];
        if(x >= 0 && x < n && y >= 0 && y < m
            && !vis[x][y] && arr[x][y] > arr[sr][sc])
        {
            path.push_back(arr[x][y]);
            ++len;
            dfs(arr, x, y);
            path.pop_back();
            --len;
        }
    }
}

int main()
{
    cin >> n >> m;
    vector<vector<int>> arr(n, vector<int>(m));
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j)
        {
            cin >> arr[i][j];
        }
    }
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j)
        {
            dfs(arr, i, j);
        }
    }
    cout << resLen << endl;
    return 0;
}

C++代码2记忆化搜索

#include <iostream>
#include <vector>
using namespace std;
int n = 0, m = 0;
bool vis[101][101];
int memo[101][101];
int dx[4] = {0, 0, -1, 1};
int dy[4] = {1, -1, 0, 0};

int dfs(vector<vector<int>>& arr, int sr, int sc)
{
    if(memo[sr][sc] != 0) // 记忆化搜索
        return memo[sr][sc];

    int len = 1;
    for(int i = 0; i < 4; ++i)
    {
        int x = sr + dx[i], y = sc + dy[i];
        if(x >= 0 && x < n && y >= 0 && y < m
            && !vis[x][y] && arr[x][y] > arr[sr][sc])
        {
            len = max(len, 1 + dfs(arr, x, y));
        }
    }
    memo[sr][sc] = len;
    return len;
}

// int n = 0, m = 0, len = 1, resLen = 0;
// vector<int> path;
// bool vis[101][101];
// void dfs(vector<vector<int>>& arr, int sr, int sc)
// {
//     resLen = max(len, resLen);
//     for(int i = 0; i < 4; ++i)
//     {
//         int x = sr + dx[i], y = sc + dy[i];
//         if(x >= 0 && x < n && y >= 0 && y < m
//             && !vis[x][y] && arr[x][y] > arr[sr][sc])
//         {
//             path.push_back(arr[x][y]);
//             ++len;
//             dfs(arr, x, y);
//             path.pop_back();
//             --len;
//         }
//     }
// }

int main()
{
    cin >> n >> m;
    vector<vector<int>> arr(n, vector<int>(m));
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j)
        {
            cin >> arr[i][j];
        }
    }
    int resLen = 0;
    for(int i = 0; i < n; ++i)
    {
        for(int j = 0; j < m; ++j)
        {
            resLen = max(resLen, dfs(arr, i, j));
        }
    }
    cout << resLen << endl;
    return 0;
}

Java代码记忆化搜索

import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main
{
    public static int N = 110;
    public static int n, m;
    public static int[][] arr = new int[N][N];
    public static int[][] dp = new int[N][N];
    public static int[] dx = {0, 0, 1, -1};
    public static int[] dy = {1, -1, 0, 0};
    public static int dfs(int i, int j)
    {
        if(dp[i][j] != 0) return dp[i][j];
        int len = 1;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < n && y >= 0 && y < m && arr[x][y] < arr[i][j])
            {
                len = Math.max(len, 1 + dfs(x, y));
            }
        }
        dp[i][j] = len;
        return len;
    }
    public static void main(String[] args) 
    {
        Scanner in = new Scanner(System.in);
        n = in.nextInt(); m = in.nextInt();
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                arr[i][j] = in.nextInt();
            }
        }
        int ret = 0;
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                ret = Math.max(ret, dfs(i, j));
            }
        }
        System.out.println(ret);
    }
}