最多两个朋友可以吃的糖果

给定六个整数X 、 Y 、 cnt1 、 cnt2 、 C1和C2 ，其中：

• X和Y代表两个朋友可以消耗的最大卡路里，
• cnt1和cnt2是两种糖果的编号，
• C1和C2是两种可用糖果中每种糖果中的卡路里。

任务是找到两个朋友可以吃的最大糖果数量。

例子：

Input: X = 25, Y = 36, cnt1 = 10, cnt2 = 6, C1 = 5, C2 = 4
Output: 13
Explanation: Candies will be eaten in the following manner.
Friend 1 can eat 5 candies of type 1: 5*5 = 25 <= 25
Friend 2 can eat all 6 candies of type 2 and 2 candies of type 1: 6*4 + 2*5 = 34 <= 36
Thus, total candies = 5 + 6 + 2 = 13.

Input: X = 452, Y = 225, cnt1 = 50, cnt2 = 125, C1 = 20, C2 = 30
Output: 33

方法：这个问题是基于观察的，可以通过使用贪心方法并尝试两个朋友可以从给定的cnt1和cnt2糖果中消耗的糖果的所有可能组合并尝试首先完成卡路里值较低的糖果来解决。

请按照以下步骤解决给定的问题。

• 如果糖果1的卡路里值大于糖果2的卡路里值，则交换两种糖果的卡路里值和计数，以确保首先消耗卡路里较少的糖果。
• 用0初始化一个变量maxCandies ，存储两个朋友可以吃的最大糖果数量。
• 运行从i = 0 到i = cnt1 （类型 1 的糖果数量）的循环以检查所有可能的组合：
  • 检查朋友 1 消耗的卡路里（ i*C1 ）是否大于他的最大卡路里容量（ X ）。如果是这种情况，则不执行进一步的语句，
  • 计算朋友 2 ( candy1_frnd2 ) 消耗的类型 1 糖果的数量。它由以下给出：
  • 计算朋友 1 和朋友 2 仍然可以消耗的卡路里容量（比如left_frnd1和left_frnd2 ）。它可以通过以下方式给出：
  • 分别计算朋友 1 和朋友 2 消耗的类型 2 糖果的数量（比如candy2_frnd1和candy2_frnd2 ）。它可以通过以下方式给出：
  • 更新两个朋友可以消耗的最大糖果数量：
• 返回存储在maxCandies中的最终值

下面是上述方法的实现：

C++

// C++ code to implement the approach
 
#include 
using namespace std;
 
// Function to find the maximum count
int maxCount(int X, int Y, int cnt1,
             int cnt2, int C1, int C2)
{
    // If C1 > C2, swap them
    if (C1 > C2) {
        swap(C1, C2);
        swap(cnt1, cnt2);
    }
 
    int ans = 0;
 
    // Loop to find the
    // maximum count of candies
    for (int i = 0; i <= cnt1; i++) {
        if (i * C1 > X) {
            continue;
        }
        int ss = min(Y / C1, cnt1 - i);
        int left_wtf = X - i * C1;
        int left_wts = Y - ss * C1;
 
        int af = min(left_wtf / C2, cnt2);
        int as = min(left_wts / C2,
                     cnt2 - af);
 
        ans = max(ans, i + ss + af + as);
    }
    return ans;
}
 
// Driver code
int main()
{
    int X = 25, Y = 36, cnt1 = 10, cnt2 = 6;
    int C1 = 5, C2 = 4;
 
    // Function call
    int ans = maxCount(X, Y, cnt1,
                       cnt2, C1, C2);
    cout << ans << endl;
    return 0;
}

Java

// JAVA code to implement the approach
import java.util.*;
class GFG {
  public static void swap(int m, int n)
  {
    int temp = m;
    m = n;
    n = temp;
  }
 
  // Function to find the maximum count
  public static int maxCount(int X, int Y, int cnt1,
                             int cnt2, int C1, int C2)
  {
 
    // If C1 > C2, swap them
    if (C1 > C2) {
      swap(C1, C2);
      swap(cnt1, cnt2);
    }
 
    int ans = 0;
 
    // Loop to find the
    // maximum count of candies
    for (int i = 0; i <= cnt1; i++) {
      if (i * C1 > X) {
        continue;
      }
      int ss = Math.min(Y / C1, cnt1 - i);
      int left_wtf = X - i * C1;
      int left_wts = Y - ss * C1;
 
      int af = Math.min(left_wtf / C2, cnt2);
      int as = Math.min(left_wts / C2, cnt2 - af);
 
      ans = Math.max(ans, i + ss + af + as);
    }
    return ans;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int X = 25, Y = 36, cnt1 = 10, cnt2 = 6;
    int C1 = 5, C2 = 4;
 
    // Function call
    int ans = maxCount(X, Y, cnt1, cnt2, C1, C2);
    System.out.println(ans);
  }
}
 
// This code is contributed by Taranpreet

Python

# Python code to implement the approach
 
# Function to find the maximum count
def maxCount(X, Y, cnt1, cnt2, C1, C2):
 
    # If C1 > C2, swap them
    if (C1 > C2):
        C1, C2 = C2, C1
        cnt1, cnt2 = cnt2, cnt1
 
    ans = 0
 
    # Loop to find the
    # maximum count of candies
    for i in range(0, cnt1 + 1):
        if (i * C1 > X):
            continue
 
        ss = min(Y // C1, cnt1 - i)
        left_wtf = X - i * C1
        left_wts = Y - ss * C1
 
        af = min(left_wtf // C2, cnt2)
        as_ = min(left_wts // C2, cnt2 - af)
 
        ans = max(ans, i + ss + af + as_)
 
    return ans
 
# Driver code
X = 25
Y = 36
cnt1 = 10
cnt2 = 6
C1 = 5
C2 = 4
 
# Function call
ans = maxCount(X, Y, cnt1, cnt2, C1, C2)
print(ans)
 
# This code is contributed by Samim Hossain Mondal.

C#

// C# code to implement the approach
using System;
class GFG {
  static void swap(int m, int n)
  {
    int temp = m;
    m = n;
    n = temp;
  }
 
  // Function to find the maximum count
  static int maxCount(int X, int Y, int cnt1, int cnt2,
                      int C1, int C2)
  {
 
    // If C1 > C2, swap them
    if (C1 > C2) {
      swap(C1, C2);
      swap(cnt1, cnt2);
    }
 
    int ans = 0;
 
    // Loop to find the
    // maximum count of candies
    for (int i = 0; i <= cnt1; i++) {
      if (i * C1 > X) {
        continue;
      }
      int ss = Math.Min(Y / C1, cnt1 - i);
      int left_wtf = X - i * C1;
      int left_wts = Y - ss * C1;
 
      int af = Math.Min(left_wtf / C2, cnt2);
      int as_ = Math.Min(left_wts / C2, cnt2 - af);
 
      ans = Math.Max(ans, i + ss + af + as_);
    }
    return ans;
  }
 
  // Driver code
  public static void Main()
  {
    int X = 25, Y = 36, cnt1 = 10, cnt2 = 6;
    int C1 = 5, C2 = 4;
 
    // Function call
    int ans = maxCount(X, Y, cnt1, cnt2, C1, C2);
    Console.WriteLine(ans);
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

    // JavaScript code to implement the approach
 
 
    // Function to find the maximum count
    const maxCount = (X, Y, cnt1, cnt2, C1, C2) => {
        // If C1 > C2, swap them
        if (C1 > C2) {
 
            let temp1 = C1;
            C1 = C2;
            C2 = temp1;
 
            let temp2 = cnt1;
            cnt1 = cnt2;
            cnt2 = temp2;
 
        }
 
        let ans = 0;
 
        // Loop to find the
        // maximum count of candies
        for (let i = 0; i <= cnt1; i++) {
            if (i * C1 > X) {
                continue;
            }
            let ss = Math.min(parseInt(Y / C1), cnt1 - i);
            let left_wtf = X - i * C1;
            let left_wts = Y - ss * C1;
 
            let af = Math.min(parseInt(left_wtf / C2), cnt2);
            let as = Math.min(parseInt(left_wts / C2),
                cnt2 - af);
 
            ans = Math.max(ans, i + ss + af + as);
        }
        return ans;
    }
 
    // Driver code
 
    let X = 25, Y = 36, cnt1 = 10, cnt2 = 6;
    let C1 = 5, C2 = 4;
 
    // Function call
    let ans = maxCount(X, Y, cnt1,
        cnt2, C1, C2);
    document.write(ans);
 
// This code is contributed by rakeshsahni
 

输出

13

时间复杂度： O(N)，其中 N 代表热量值较低的糖果类型。
辅助空间： O(1)