通过将分子和分母 K 次加 1 来最大化 N 个给定分数的比率之和

给定一个正整数K和一个由N个分数组成的{numerator, denominator}组成的数组arr[] ，任务是在将分子和分母分别增加1 , K 次后找到给定分数的比率之和。

例子：

Input: arr[][] = {{1, 2}, {3, 5}, {2, 2}}, K = 2
Output: 0.78333
Explanation:
The most optimal choice is to increment the first fraction K(= 2) number of times. Therefore, the sum of ratio is (3/4 + 3/5 + 2/2) / 3 = 0.78333, which is maximum possible.

Input: arr[][] = {{1, 1}, {4, 5}}, K = 5
Output: 0.95

方法：给定问题可以通过使用贪心方法来解决，其想法是在给定分数中增加该分数，其增量使分数的比率之和最大化。这个想法可以使用优先级队列来实现。请按照以下步骤解决问题：

• 使用优先级队列初始化一个最大堆，例如PQ ，如果对范围[0, N)中的所有i值的第 i^个索引执行操作，该优先级队列存储的值将在总平均比率中递增。
• 在优先级队列PQ中插入数组arr[]中分数的所有索引，分数的递增值。
• 迭代范围[0, K – 1]并执行以下步骤：
  • 弹出PQ的顶部元素。
  • 增加当前弹出索引的分数。
  • 将数组arr[]中的所有当前分数插入优先级队列PQ中，分数的递增值。
• 完成上述步骤后，打印priority_queue PQ中存储的所有分数的比率总和。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to increment the K fractions
// from the given array to maximize the
// sum of ratios of the given fractions
double maxAverageRatio(
    vector >& arr, int K)
{
    // Size of the array
    int N = arr.size();
 
    // Max priority queue
    priority_queue > q;
 
    // Iterate through the array
    for (int i = 0; i < N; i++) {
 
        // Insert the incremented value
        // if an operation is performed
        // on the ith index
        double extra
            = (((double)arr[i][0] + 1)
               / ((double)arr[i][1] + 1))
              - ((double)arr[i][0]
                 / (double)arr[i][1]);
        q.push(make_pair(extra, i));
    }
 
    // Loop to perform K operations
    while (K--) {
        int i = q.top().second;
        q.pop();
 
        // Increment the numerator and
        // denominator of ith fraction
        arr[i][0] += 1;
        arr[i][1] += 1;
 
        // Add the incremented value
        double extra
            = (((double)arr[i][0] + 1)
               / ((double)arr[i][1] + 1))
              - ((double)arr[i][0]
                 / (double)arr[i][1]);
 
        q.push(make_pair(extra, i));
    }
 
    // Stores the average ratio
    double ans = 0;
    for (int i = 0; i < N; i++) {
        ans += ((double)arr[i][0]
                / (double)arr[i][1]);
    }
 
    // Return the ratio
    return ans / N;
}
 
// Driver Code
int main()
{
    vector > arr
        = { { 1, 2 }, { 3, 5 }, { 2, 2 } };
    int K = 2;
 
    cout << maxAverageRatio(arr, K);
 
    return 0;
}

Javascript

 
// Javascript program for the above approach
 
// Function to increment the K fractions
// from the given array to maximize the
// sum of ratios of the given fractions
function maxAverageRatio(arr, K)
{
 
    // Size of the array
    var N = arr.length;
 
    // Max priority queue
    var q = [];
 
    // Iterate through the array
    for (var i = 0; i < N; i++) {
 
        // Insert the incremented value
        // if an operation is performed
        // on the ith index
        var extra
            = ((arr[i][0] + 1)
               / (arr[i][1] + 1))
              - (arr[i][0]
                 / arr[i][1]);
        q.push([extra, i]);
    }
    q.sort();
    // Loop to perform K operations
    while (K--) {
        var i = q[q.length-1][1];
        q.pop();
 
        // Increment the numerator and
        // denominator of ith fraction
        arr[i][0] += 1;
        arr[i][1] += 1;
 
        // Add the incremented value
        var extra
            = ((arr[i][0] + 1)
               / (arr[i][1] + 1))
              - (arr[i][0]
                 / arr[i][1]);
 
        q.push([extra, i]);
        q.sort();
    }
 
    // Stores the average ratio
    var ans = 0;
    for (var i = 0; i < N; i++) {
        ans += (arr[i][0]
                / arr[i][1]);
    }
 
    // Return the ratio
    return ans / N;
}
 
// Driver Code
var arr = [[1, 2 ], [3, 5], [2, 2 ]];
var K = 2;
document.write(maxAverageRatio(arr, K).toFixed(6));
 
// This code is contributed by rrrtnx.

输出：

0.783333

时间复杂度： O(K*log N)
辅助空间： O(N)