目录链接：

力扣编程题-解法汇总_分享+记录-CSDN博客

GitHub同步刷题项目：

https://github.com/September26/java-algorithms

原题链接：力扣

描述：

有两只老鼠和 n 块不同类型的奶酪，每块奶酪都只能被其中一只老鼠吃掉。

下标为 i 处的奶酪被吃掉的得分为：

• 如果第一只老鼠吃掉，则得分为 reward1[i] 。
• 如果第二只老鼠吃掉，则得分为 reward2[i] 。

给你一个正整数数组 reward1 ，一个正整数数组 reward2 ，和一个非负整数 k 。

请你返回第一只老鼠恰好吃掉 k 块奶酪的情况下，最大 得分为多少。

示例 1：

输入：reward1 = [1,1,3,4], reward2 = [4,4,1,1], k = 2
输出：15
解释：这个例子中，第一只老鼠吃掉第 2 和 3 块奶酪（下标从 0 开始），第二只老鼠吃掉第 0 和 1 块奶酪。
总得分为 4 + 4 + 3 + 4 = 15 。
15 是最高得分。

示例 2：

输入：reward1 = [1,1], reward2 = [1,1], k = 2
输出：2
解释：这个例子中，第一只老鼠吃掉第 0 和 1 块奶酪（下标从 0 开始），第二只老鼠不吃任何奶酪。
总得分为 1 + 1 = 2 。
2 是最高得分。

提示：

• 1 <= n == reward1.length == reward2.length <= 105
• 1 <= reward1[i], reward2[i] <= 1000
• 0 <= k <= n

解题思路：

/**

* 这个的核心其实就是两个数组比较选择较大的那个。

* 但是由于必须选择k个，所以我们就要reward1[i]-reward2[i]的差值最大的那K个

*/

代码：

#include <iostream>
#include <map>
#include <list>
#include <vector>
#include <set>
#include <algorithm>

using namespace std;

struct Model2611
{
    int index;
    int diffValue;
    void initialize(int index, int diffValue)
    {
        this->index = index;
        this->diffValue = diffValue;
    };
};

bool compareModel(Model2611 model1, Model2611 model2)
{
    return model1.diffValue > model2.diffValue;
}
class Solution2611
{
public:
    int miceAndCheese(vector<int> &reward1, vector<int> &reward2, int k)
    {
        vector<Model2611> sortList;
        for (int i = 0; i < reward1.size(); i++)
        {
            Model2611 model;
            model.initialize(i, reward1[i] - reward2[i]);
            sortList.push_back(model);
        }
        sort(sortList.begin(), sortList.end(), compareModel);
        int sum = 0;
        for (int i = 0; i < sortList.size(); i++)
        {
            Model2611 model = sortList[i];
            if (i < k)
            {
                sum += reward1[model.index];
            }
            else
            {
                sum += reward2[model.index];
            }
        }

        return sum;
    }
};