【888题竞赛篇】第二题，2014ICPC北京-狼

Dashcoding编程设

已于 2024-08-18 10:35:11 修改

阅读量874

点赞数 11

文章标签：算法数据结构 c++ 动态规划 java python 求职招聘

于 2024-08-17 20:33:17 首次发布

本文链接：https://blog.csdn.net/Dashcoding213/article/details/141286166

版权

这里写自定义目录标题

更多精彩内容
- 256题算法特训课，帮你斩获大厂60W年薪offer
原题
- 2014-ICPC区域赛真题-狼
- B站动画详解
问题分析
思路分析
算法实现
代码详解
- 标准代码程序
复杂度分析
- 时间复杂度
- 空间复杂度
总结

原题

2014-ICPC区域赛真题-狼

B站动画详解

问题分析

题目要求我们杀死排成一排的狼，并且每头狼都有两个属性：攻击力和加成值。狼的实际攻击力等于自身攻击力加上相邻狼的加成值。被杀死的狼的加成值会取消，同时，原先与被杀死的狼相邻的两头狼会成为直接相邻的狼。我们的目标是找到一种杀死顺序，使得最终杀死所有狼的总伤害值最小。

这个问题的关键在于每次杀死一头狼后，其余狼的状态会发生动态变化。使用区间动态规划（DP）可以很好地解决这个问题。我们可以通过划分区间并依次解决子问题，最终获得整个区间的最优解。

思路分析

设 $f [l] [r]$ 表示从位置 $l$ 到 $r$ 的所有狼被杀死所受到的最小伤害值。我们需要枚举中间位置 $k$ ，考虑将 $k$ 留到最后杀死，此时的伤害值为杀死 $k$ 的代价加上区间 $[l, k - 1]$ 和 $[k + 1, r]$ 的最优子解。公式如下：

$\min_{l \leq k \leq r} \left(f[l][k-1] + f[k+1][r] + a[k] + b[l-1] + b[r+1]\right)$

这里的 $a [k]$ 是狼 $k$ 的攻击力，而 $b [l - 1]$ 和 $b [r + 1]$ 是左右两端相邻狼的加成值。特别地，当 $k$ 恰好是区间的左端点或右端点时，只需要考虑一侧的加成值。
DP的转移过程如下：

初始化状态，单个位置 $f [i] [i]$ 的初始值为该位置狼的攻击力加左右相邻狼的加成值。
对于长度为 $2$ 到 $n$ 的区间逐步计算，依次枚举区间内的每一个位置作为最后被杀死的狼。
通过状态转移方程逐步求解整个区间的最优解。

算法实现

代码实现基于上述思路。我们使用二维数组 f 来存储区间的最优解，通过多次递归计算子区间的值，最终求解完整区间。

代码详解

标准代码程序

C++代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 205;
ll f[N][N], a[N], b[N];

void solve(int id) {
    int n;
    cin >> n;
    memset(f, 0x3f, sizeof(f)); // 初始化为无穷大
    memset(a, 0, sizeof(a));
    memset(b, 0, sizeof(b));
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= n; i++) cin >> b[i];
    
    for (int i = 1; i <= n; i++) 
        f[i][i] = a[i] + b[i-1] + b[i+1];
    
    for (int len = 2; len <= n; len++) {
        for (int l = 1; l <= n; l++) {
            int r = l + len - 1;
            if (r > n) break;
            for (int k = l; k <= r; k++) {
                if (k == l) 
                    f[l][r] = min(f[l][r], f[k+1][r] + a[k] + b[l-1] + b[r+1]);
                else if (k == r) 
                    f[l][r] = min(f[l][r], f[l][k-1] + a[k] + b[l-1] + b[r+1]);
                else 
                    f[l][r] = min(f[l][r], f[l][k-1] + f[k+1][r] + a[k] + b[l-1] + b[r+1]);
            }
        }
    }
    cout << "Case #" << id << ": " << f[1][n] << "\n";
}

int main() {
    int T;
    cin >> T;
    for (int i = 1; i <= T; i++) solve(i);
}

Java代码

import java.util.Scanner;

public class WolfHunt {
    static final int N = 205;
    static long[][] f = new long[N][N];
    static long[] a = new long[N], b = new long[N];

    public static void solve(int id) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        // 初始化DP数组为无穷大
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                f[i][j] = Long.MAX_VALUE;
            }
        }
        for (int i = 1; i <= n; i++) a[i] = sc.nextLong();
        for (int i = 1; i <= n; i++) b[i] = sc.nextLong();

        // 初始化单个狼的伤害值
        for (int i = 1; i <= n; i++) {
            f[i][i] = a[i] + b[i - 1] + b[i + 1];
        }

        // 动态规划求解
        for (int len = 2; len <= n; len++) {
            for (int l = 1; l <= n; l++) {
                int r = l + len - 1;
                if (r > n) break;
                for (int k = l; k <= r; k++) {
                    if (k == l) {
                        f[l][r] = Math.min(f[l][r], f[k + 1][r] + a[k] + b[l - 1] + b[r + 1]);
                    } else if (k == r) {
                        f[l][r] = Math.min(f[l][r], f[l][k - 1] + a[k] + b[l - 1] + b[r + 1]);
                    } else {
                        f[l][r] = Math.min(f[l][r], f[l][k - 1] + f[k + 1][r] + a[k] + b[l - 1] + b[r + 1]);
                    }
                }
            }
        }
        System.out.println("Case #" + id + ": " + f[1][n]);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        for (int i = 1; i <= T; i++) {
            solve(i);
        }
        sc.close();
    }
}

Python代码

def solve(id):
    n = int(input())
    a = [0] + list(map(int, input().split())) + [0]
    b = [0] + list(map(int, input().split())) + [0]
    f = [[float('inf')] * (n + 2) for _ in range(n + 2)]
    
    for i in range(1, n + 1):
        f[i][i] = a[i] + b[i-1] + b[i+1]
    
    for length in range(2, n + 1):
        for l in range(1, n - length + 2):
            r = l + length - 1
            for k in range(l, r + 1):
                if k == l:
                    f[l][r] = min(f[l][r], f[k+1][r] + a[k] + b[l-1] + b[r+1])
                elif k == r:
                    f[l][r] = min(f[l][r], f[l][k-1] + a[k] + b[l-1] + b[r+1])
                else:
                    f[l][r] = min(f[l][r], f[l][k-1] + f[k+1][r] + a[k] + b[l-1] + b[r+1])
    
    print(f"Case #{id}: {f[1][n]}")

T = int(input())
for i in range(1, T + 1):
    solve(i)

Javascript代码

function solve(id) {
    const n = parseInt(prompt());
    const a = [0].concat(prompt().split(" ").map(Number)).concat([0]);
    const b = [0].concat(prompt().split(" ").map(Number)).concat([0]);
    const f = Array.from({ length: n + 2 }, () => Array(n + 2).fill(Infinity));
    
    for (let i = 1; i <= n; i++) {
        f[i][i] = a[i] + b[i-1] + b[i+1];
    }

    for (let length = 2; length <= n; length++) {
        for (let l = 1; l <= n - length + 1; l++) {
            const r = l + length - 1;
            for (let k = l; k <= r; k++) {
                if (k === l) {
                    f[l][r] = Math.min(f[l][r], f[k+1][r] + a[k] + b[l-1] + b[r+1]);
                } else if (k === r) {
                    f[l][r] = Math.min(f[l][r], f[l][k-1] + a[k] + b[l-1] + b[r+1]);
                } else {
                    f[l][r] = Math.min(f[l][r], f[l][k-1] + f[k+1][r] + a[k] + b[l-1] + b[r+1]);
                }
            }
        }
    }

    console.log(`Case #${id}: ${f[1][n]}`);
}

const T = parseInt(prompt());
for (let i = 1; i <= T; i++) {
    solve(i);
}