校招算法笔面试 | 校招笔面试真题-抽牌-优快云博客

本文链接：https://blog.youkuaiyun.com/wc529065/article/details/148708778

题目

题目链接

解题思路

这是一个动态规划问题，需要计算期望值。游戏规则如下：

$n$ 张牌从上到下编号 $1$ 到 $n$ ，每张牌上有一个数字 $a_i$
两人轮流取牌，每次只能取最上面或最下面的牌
小明先手，以概率 $p$ 取上面的牌，概率 $1 - p$ 取下面的牌
小方后手，以概率 $q$ 取上面的牌，概率 $1 - q$ 取下面的牌
求小明获得的数字之和的期望值

解决方案：

使用区间DP， $d p [i] [j]$ 表示区间 $[i, j]$ 的期望值
初始化单张牌和相邻两张牌的情况
按照区间长度递推，考虑所有可能的取牌情况

代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, P, Q;
    scanf("%d%d%d", &n, &P, &Q);
    
    // 读入牌面值
    int a[n];
    for(int i = 0; i < n; i++)
        scanf("%d", &a[i]);
    
    // 转换概率值
    double p = P/100.0, q = Q/100.0;
    double dp[n][n];
    memset(dp, 0, sizeof(dp));
    
    // 初始化单张牌和相邻两张牌的情况
    for(int i = 0; i < n; i++) {
        dp[i][i] = a[i];
        if(i < n-1)
            dp[i][i+1] = p*a[i] + (1-p)*a[i+1];
    }
    
    // 区间DP
    for(int k = 2; k < n; k++) {
        for(int i = 0; i < n-k; i++) {
            int j = i + k;
            // 小明取上面的牌时的期望
            double px = a[i] + q*dp[i+2][j] + (1-q)*dp[i+1][j-1];
            // 小明取下面的牌时的期望
            double py = a[j] + q*dp[i+1][j-1] + (1-q)*dp[i][j-2];
            // 综合两种情况
            dp[i][j] = p*px + (1-p)*py;
        }
    }
    
    printf("%.3f\n", dp[0][n-1]);
    return 0;
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int P = sc.nextInt();
        int Q = sc.nextInt();
        
        // 读入牌面值
        int[] a = new int[n];
        for(int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        
        // 转换概率值
        double p = P/100.0, q = Q/100.0;
        double[][] dp = new double[n][n];
        
        // 初始化单张牌和相邻两张牌的情况
        for(int i = 0; i < n; i++) {
            dp[i][i] = a[i];
            if(i < n-1)
                dp[i][i+1] = p*a[i] + (1-p)*a[i+1];
        }
        
        // 区间DP
        for(int k = 2; k < n; k++) {
            for(int i = 0; i < n-k; i++) {
                int j = i + k;
                // 小明取上面的牌时的期望
                double px = a[i] + q*dp[i+2][j] + (1-q)*dp[i+1][j-1];
                // 小明取下面的牌时的期望
                double py = a[j] + q*dp[i+1][j-1] + (1-q)*dp[i][j-2];
                // 综合两种情况
                dp[i][j] = p*px + (1-p)*py;
            }
        }
        
        System.out.printf("%.3f\n", dp[0][n-1]);
    }
}

def solve():
    n, P, Q = map(int, input().split())
    a = list(map(int, input().split()))
    
    # 转换概率值
    p, q = P/100.0, Q/100.0
    
    # 初始化DP数组
    dp = [[0.0] * n for _ in range(n)]
    
    # 初始化单张牌和相邻两张牌的情况
    for i in range(n):
        dp[i][i] = a[i]
        if i < n-1:
            dp[i][i+1] = p*a[i] + (1-p)*a[i+1]
    
    # 区间DP
    for k in range(2, n):
        for i in range(n-k):
            j = i + k
            # 小明取上面的牌时的期望
            px = a[i] + q*dp[i+2][j] + (1-q)*dp[i+1][j-1]
            # 小明取下面的牌时的期望
            py = a[j] + q*dp[i+1][j-1] + (1-q)*dp[i][j-2]
            # 综合两种情况
            dp[i][j] = p*px + (1-p)*py
    
    print(f"{dp[0][n-1]:.3f}")

solve()