Python 最大提示计算器-原始解决方案

我正在研究一个GeekForgeks练习题。我提出了一个简单的递归解决方案来解决“最大小费计算器”问题

问题的定义是：

这家餐馆接受N份订单。如果Rahul接受第i个命令，则获得 $A[i]。如果Ankit接受这一订单，小费将是$B[i]一份订单 每人。Rahul接受最多X个订单。Ankit接受max Y的订单。 X+Y>=N。找出小费总额的最大可能金额 处理完所有订单后

输入：

第一行包含一个整数，即测试用例数。第二 行包含三个整数N，X，Y。第三行包含N 整数。第i个整数表示Ai。第四行包含N 整数。第i个整数表示Bi

输出：打印一个整数，表示他们支付的最高小费金额 会收到

我的代码和工作示例：

def max_tip(N, A, B, X, Y, n= 0):

    if n == len(A) or N == 0:
        return 0

    if X == 0 and Y > 0: # rahul cannot take more orders
        return max(B[n] + max_tip(N - 1, A, B, X, Y - 1, n + 1), # ankit takes the order
                    max_tip(N, A, B, X, Y, n + 1))  # ankit does not take order
    elif Y == 0 and X > 0: # ankit cannot take more orders
        return max(A[n] + max_tip(N - 1, A, B, X - 1, Y, n + 1), # rahul takes the order
                    max_tip(N, A, B, X, Y, n + 1)) # rahul does not take order
    elif Y == 0 and X == 0: # neither can take orders
        return 0
    else:
        return max(A[n] + max_tip(N - 1, A, B, X - 1, Y, n + 1), # rahul takes the order
                B[n] + max_tip(N - 1, A, B, X, Y - 1, n + 1), #ankit takes the order
                max_tip(N, A, B, X, Y, n + 1)) # nobody takes the order

T = int(input())

for i in range(T):
    nxy = [int(n) for n in input().strip().split(" ")]
    N = nxy[0]
    X = nxy[1]
    Y = nxy[2]

    A = [int(n) for n in input().strip().split(" ")]
    B = [int(n) for n in input().strip().split(" ")]

    print(max_tip(N, A, B, X, Y))

我已经注释了我的递归调用决策。本质上，我将0-1背包的原始解决方案扩展到另一个维度，两个服务员，一个接受，另一个接受，或者两者都不接受订单，这取决于订单的左约束

解决方案检查器正在抱怨以下测试用例：

Input:
7 3 3
8 7 15 19 16 16 18
1 7 15 11 12 31 9

Its Correct output is:
110

And Your Code's Output is:
106

这让我感到困惑，因为最佳解决方案似乎是我的代码得到的（19+16+18）+（7+15+31）。眼前的问题似乎是X+Y

---

发生了什么事？

我想，这就是你的问题来源：

以下是我用Python编写的解决方案，通过了所有案例：

说明： 压缩提示的相应元素并创建新数组。 根据Rahul和Ankit的差值对新数组进行排序，

---

然后我们可以安全地考虑数组的2个末端的元素，这些元素会带来更多的利润，增加数值来计算。

你考虑的是这个例子，那里没有人取小费。但这种情况并不存在，因为X+Y>=n。这个java代码对我来说很有用，看看吧

private static int getMaxTip(int x, int y, int n, int[] A, int[] B) {
     int[][] dp = new int[x + 1][y + 1];

     dp[0][0] = 0;
     for (int i = 1;i <= x;i++) {
         dp[i][0] = (i <= n) ? dp[i - 1][0] + A[i - 1] : dp[i - 1][0];
     }

     for (int i = 1;i <= y;i++) {
         dp[0][i] = (i <= n) ? dp[0][i - 1] + B[i - 1] : dp[0][i - 1];
     }

     for (int i = 1;i <= x;i++) {
         for (int j = 1;j <= y;j++) {
             if (i + j <= n) {
                 dp[i][j] = Math.max(dp[i - 1][j] + A[i + j - 1], dp[i][j - 1] + B[i + j - 1]);
             }
         }
     }

     int ans = Integer.MIN_VALUE;
     for (int i = 0;i <= x;i++) {
         for (int j = 0;j <= y;j++) {
             if (i + j == n) {
                 ans = Math.max(ans, dp[i][j]);
             }
         }
     }
     return ans;
 }

private static int getMaxTip（int x，int y，int n，int[]A，int[]B）{
int[][]dp=新的int[x+1][y+1]；
dp[0][0]=0；
对于（int i=1；i您正在考虑一种情况，即没有人接受不应考虑的订单，因为问题中提到x+y>=n总是这样。删除该条件将起作用。
好吧，有4种方法可以达到110（它们都需要填写7份订单）和
7 3 3
显然与
X+Y>=N
的说法相矛盾。所以我要说有人搞错了。实践问题清楚地说明了
X+Y>=N
的约束条件，但你的情况不符合。在这一点上，我不希望结果是可以接受的。此外，你的问题似乎是“为什么他们的代码得到的结果与我的不同"，在这种情况下，很难说他们的程序是如何编码来解释这种差异的。此外，网站上的许多评论似乎都在抱怨测试用例，所以我会假设那里有一些不正确的地方。鉴于提供的测试用例，问题定义似乎是不正确的。考虑到pr，我会假设我的代码是最佳的解决方案操作工testcases@Idlehands这不是“为什么他们的代码得到的结果与我的不同”，而是“考虑到问题的约束和我的解决方案，为什么这会失败？”从我可以看出，我已经给出了问题的最佳（幼稚）解决方案。有有效的O（n）top/down-bottom/up-DP解决方案，但我认为对于一般的简单递归解决方案，我一针见血。测试用例是由问题的作者提供的，因此我只能假设他/她有疏忽。主要问题是不变的X+Y>=N必须保持不变。如果代码是围绕这个约束设计的，它将无法通过创建者的测试当X=3，Y=3，N=7，so3+3<7时，问题的前提是错误的，因此解决问题的任何解决方案也是错误的。