6029 射箭比赛中的最大得分（dfs、零一背包问题求解具体方案）

1. 问题描述：

Alice 和 Bob 是一场射箭比赛中的对手。比赛规则如下：
Alice 先射 numArrows 支箭，然后 Bob 也射 numArrows 支箭。
分数按下述规则计算：
箭靶有若干整数计分区域，范围从 0 到 11 （含 0 和 11）。
箭靶上每个区域都对应一个得分 k（范围是 0 到 11），Alice 和 Bob 分别在得分 k 区域射中 ak 和 bk 支箭。如果 ak >= bk ，那么 Alice 得 k 分。如果 ak < bk ，则 Bob 得 k 分
如果 ak == bk == 0 ，那么无人得到 k 分。
例如，Alice 和 Bob 都向计分为 11 的区域射 2 支箭，那么 Alice 得 11 分。如果 Alice 向计分为 11 的区域射 0 支箭，但 Bob 向同一个区域射 2 支箭，那么 Bob 得 11 分。给你整数 numArrows 和一个长度为 12 的整数数组 aliceArrows ，该数组表示 Alice 射中 0 到 11 每个计分区域的箭数量。现在，Bob 想要尽可能 最大化 他所能获得的总分。
返回数组 bobArrows ，该数组表示 Bob 射中 0 到 11 每个 计分区域的箭数量。且 bobArrows 的总和应当等于 numArrows 。如果存在多种方法都可以使 Bob 获得最大总分，返回其中任意一种即可。

示例 1：

输入：numArrows = 9, aliceArrows = [1，1，0，1，0，0，2，1，0，1，2，0]
输出：[0，0，0，0，1，1，0，0，1，2，3，1]
解释：上表显示了比赛得分情况。
Bob 获得总分 4 + 5 + 8 + 9 + 10 + 11 = 47 。
可以证明 Bob 无法获得比 47 更高的分数。

示例 2：

输入：numArrows = 3, aliceArrows = [0，0，1，0，0，0，0，0，0，0，0，2]
输出：[0，0，0，0，0，0，0，0，1，1，1，0]
解释：上表显示了比赛得分情况。
Bob 获得总分 8 + 9 + 10 = 27 。
可以证明 Bob 无法获得比 27 更高的分数。
 
提示：

1 <= numArrows <= 10 ^ 5
aliceArrows.length == bobArrows.length == 12
0 <= aliceArrows[i], bobArrows[i] <= numArrows
sum(aliceArrows[i]) == numArrows

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-points-in-an-archery-competition/

2. 思路分析：

① 首先需要读懂题目的意思，分析题目可以知道Alice在哪一个区域射的箭的数量是唯一确定的，因为需要使得Bob的得分是最多的，而且只有Bob在当前某个回合射的箭的数量比Alice多的时候才可以胜出，也即每一个回合Bob赢的时候需要最少的箭的数量也是确定的，所以最容易想到的是枚举所有的回合，每一个回合有两种选择，总共有12个回合所以总的计算量为2 ^ 12 = 4096的计算量，因为当前回合Bob可以赢也可以不赢那么就可以使用dfs来搜索，分别对应两个平行的分支，第一个分支表示Bob赢，第二个分支表示Bob输，在写dfs方法的时候我们需要多少个参数才在dfs方法中声明，不够用了再加，可以发现我们需要维护当前递归的位置u，当前状态下所需要的最少的箭的数量，当前状态下的得分s，记录当前对应的方案的数组或者列表rec，记录当前最大得分对应的方案res；根据dfs属于哪一个分值更新这些变量的值，只有需要最少的箭小于等于numArrows的并且当前状态下的得分大于等于之前的最大得分则更新答案与最大得分，由于最终可能还剩下箭而此时Bob已经获得了最大得分将剩余的箭加到任何一个位置都可以构成合法方案，因为计算量在几千所以dfs也是可以通过的。

② 通过①中的分析其实这道题目是一个限制性的选择问题，每一个回合可以选择赢也可以选择不赢，所以属于经典的零一背包问题，因为需要求解具体的方案而不是最值所以需要使用二维数组来记录对应的状态（零一背包问题求解具体方案），我们可以将numArrows看成是背包容量，aliceArrows看成是每一个物品对应的体积，注意体积应该是aliceArrows[i] + 1，求解在不超过背包容量的前提下使得背包的价值最大，其中价值为最大得分；dp[i][j]表示前i个物品体积为j能够获得的最大价值，最终dp[n][m]就是最终的最大得分，二维数组来记录dp状态值的一个好处是能够使用逆推的方式求解具体的方案，我们可以从后往前枚举每一个物品，判断当前物品选还是不选满足当前的条件，如果满足则说明当前的物品要选那么就记录下对应的方案。

3. 代码如下：

dfs：

from typing import List


class Solution:
    # 使用全局变量maxs记录最大得分
    maxs = None

    # m表示总共有m枝箭, u表示当前递归的位置, count为Bob赢当前需要箭的数量, s为当前状态下的最大得分, rec记录当前状态下的的方案
    def dfs(self, m: int, u: int, count: int, s: int, a: List[int], rec: List[int], res: List[int]):
        # 大于当前有的箭的数量
        if count > m: return
        if u == len(a):
            if self.maxs <= s:
                self.maxs = s
                # 记录对应的方案, 注意需要[:]才能够修改res, res = rec[:]不可以修改, 或者声明一个全局变量来记录也可以
                res[:] = rec[:]
                # 剩余的箭加到第一个位置上
                res[0] += m - count        
            return
        # 当前回合是Bob赢所以至少需要a[u] + 1枝箭, 每一个回合赢的箭的最少数量是确定的
        t = rec[u]
        rec[u] = a[u] + 1
        # s + u表示得分加上当前回合对应的分值
        self.dfs(m, u + 1, count + a[u] + 1, s + u, a, rec, res)
        # 回溯, 当前这个回合不是Bob赢所以将其恢复到未修改的状态
        rec[u] = t
        self.dfs(m, u + 1, count, s, a, rec, res)

    def maximumBobPoints(self, m: int, a: List[int]) -> List[int]:
        n = len(a)
        rec, res = [0] * n, list()
        # maxs记录最大得分
        self.maxs = 0
        self.dfs(m, 0, 0, 0, a, rec, res)
        return res

二维零一背包求解具体方案：因为需要求解具体的方案所以需要使用二维数组来记录dp值，然后逆序递推即可，不过python提交上去超时了：

from typing import List


class Solution:
    def maximumBobPoints(self, m: int, v: List[int]) -> List[int]:
        n = len(v)
        dp = [[0] * (m + 10) for i in range(n + 10)]
        for i in range(1, n + 1):
            for j in range(m + 1):
                dp[i][j] = dp[i - 1][j]
                if j >= v[i - 1] + 1:
                    dp[i][j] = max(dp[i][j], dp[i - 1][j - (v[i - 1] + 1)] + i - 1)
        res = [0] * n
        j, count = m, 0
        for i in range(n, 0, -1):
            if j >= v[i - 1] + 1 and dp[i][j] == dp[i - 1][j - v[i - 1] - 1] + i - 1:
                j -= v[i - 1] + 1
                res[i - 1] = v[i - 1] + 1
                count += v[i - 1] + 1
        res[0] += m - count
        return res

class Solution {
    // java代码可以通过, 时间复杂度为10 ** 6
    public int[] maximumBobPoints(int m, int[] v) {
        int n = v.length;
        int [][]dp = new int[n + 10][m + 10];
        for (int i = 1; i <= n; ++i){
            for (int j = 0; j <= m; ++j){
                dp[i][j] = dp[i - 1][j];
                if (j >= v[i - 1] + 1){
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - v[i - 1] - 1] + i - 1);
                }
            }
        }
        int j = m, count = 0;
        int []res = new int[n];
        for (int i = n; i >= 1; --i){
            if (j >= v[i - 1] + 1 && dp[i][j] == dp[i - 1][j - v[i - 1] - 1] + i - 1){
                j -= v[i - 1] + 1;
                res[i - 1] = v[i - 1] + 1;
                count += v[i - 1] + 1;
            }
        }
        res[0] += m - count;
        return res;
    }
}