Acwing 贪心算法遗留

最新推荐文章于 2024-11-13 23:09:11 发布

Curry_Math

最新推荐文章于 2024-11-13 23:09:11 发布

阅读量1k

点赞数 12

分类专栏：算法学习文章标签：贪心算法算法

本文链接：https://blog.csdn.net/qq_43060884/article/details/142814933

版权

算法学习专栏收录该内容

65 篇文章 0 订阅

订阅专栏

1.Huffman树

Acwing 148.合并果子
在这里插入图片描述
实现思路：构建一颗哈夫曼树，求最短带权路径长度（树中所有的叶结点的权值乘上其到根结点的路径长度）

每次选择重量最小的两堆进行合并
使用小根堆存储每一堆果子，每次两次弹出堆顶元素，合并后就放入小根堆中

具体实现代码（详解版）：

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>

using namespace std;

int main() {
    int n;
    cin >> n;  // 输入元素数量
    
    // 使用最小堆来保存元素
    priority_queue<int, vector<int>, greater<int>> heap;
    
    // 读取 n 个整数并将其压入最小堆
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        heap.push(x);
    }
    
    int res = 0;  // 保存合并的总代价
    
    // 每次取出两个最小的元素，直到堆中只剩下一个元素
    while (heap.size() > 1) {
        int a = heap.top(); heap.pop();  // 取出堆中最小的元素
        int b = heap.top(); heap.pop();  // 取出堆中第二小的元素
        
        res += a + b;  // 计算这次合并的代价，并累加到总代价
        heap.push(a + b);  // 将合并后的元素重新压入堆中
    }
    
    cout << res << endl;  // 输出最终的总代价
    
    return 0;
}

2. 排序不等式

Acwing 913.排队打水
在这里插入图片描述
实现思路：
假设各个同学的打水时间为：3 6 1 4 2 5 7 并且就按照这个顺序来打水。当第一个同学打的时候，后面所有同学都要等他，所以等待的总时长要加上一个3 * 6，第二个同学打的时候，后面所有同学也都要等他，所以要加上个6 * 5，以此类推，所有同学等待的总时长为3 * 6 + 6 * 5 + 1 * 4 + 4 * 3 + 2 * 2 + 5 * 1

假设各个同学打水花费的时长为 t1，t2，t3，…，tn，则按照次序打水，总的等待时长为：t1 * (n-1) + t2 * (n-2) + ... + tn * 1。

可以看出，当打水顺序按照花费时间从小到大排序时，所得的等待时间最小

采用反证法（调整法），假设最优解不是按照从小到大的顺序，则必然存在2个相邻的人，前一个人打水时长比后一个大，即必然存在一个位置i，满足t_i > t_i+1，那我们尝试把这两个同学的位置交换，看看对总的等待时长有什么影响，这两个同学的交换，只会影响他们两的等待时长，不会影响其他同学的等待时长。交换前，这部分等待时长为t_i * (n-i) + t_i+1 * (n-i-1)，交换后，这部分等待时长为t_i+1 * (n-i) + t_i * (n-i-1)，容易算得，交换后的等待时长变小了，则该方案不是最优解，矛盾了。则最优解就是按照从小到大的顺序依次打水。

具体实现代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;
typedef long long LL;
int n,t[N];

int main(){
    cin >> n;
    for(int i = 0 ; i < n ; i ++) cin >> t[i];
    sort(t,t + n);
    
    LL res = 0;
    for(int i = 0 ; i < n ; i ++) res += t[i] * (n - i - 1);
    
    cout << res << endl;
    
    return 0;
}

3.绝对值不等式

Acwing 104.货舱选址
在这里插入图片描述
思路分析：
假设n个商店在数轴上的坐标依次为：x1，x2，x3，…，xn

设仓库的位置为x，则总的距离为

f(x) = |x1 - x| + |x2 - x| + ... + |xn - x|

我们要求解的就是f(x)的最小值。

我们可以先进行一下分组，1和n为一组，2和n-1为一组…

f(x) = (|x1 - x| + |xn - x|) + (|x2 - x| + |x_n-1 - x|) + ....

单独看一组，任意一组都可以写成形如|a - x| + |b - x|的形式，a和b是已知的常数，x是未知数。假设a < b，则容易知道，当x取值在[a,b]这个区间内时，上面的表达式取得最小值b - a，而x取值只要落在[a,b]区间外，则上面的表达式的值一定是大于b - a的。

由此可知，对于分组1和n，只要x取值在[x1,xn]这个区间内，就能使|x1 - x| + |xn - x|取得最小值xn - x1。同理，对于|x2 - x| + |x_n-1 - x|，只要x取值在[x2,x_n-1]区间内，就能使这个部分取得最小值x_n-1 - x2…容易得出，只要取所有分组的区间的交集即整个区间的中间点，能使总的f(x)最小。即，当n为偶数时，x只要落在最中间2个点之间即可；当n为奇数时，x只需要落在最中间的那个点上即可。

具体实现代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1000010;

int p[N];
int n;

int main(){
    int n;
    cin >> n;
    for(int i = 0 ; i < n ; i ++) cin >> p[i];
    sort(p,p + n);
    
    int res = 0;
    for(int i = 0 ; i < n ; i ++) res += abs(p[i] - p[n / 2]);
    
    
    cout << res << endl;
    return 0;
}

4.推公式

Acwing 125.耍杂技的牛
在这里插入图片描述
实现思路：wi表示牛的体重，si表示牛的强壮度
先给结论：按照w + s从小到大的顺序，从上往下排，最大的危险系数一定是最小的。

简单理解：把重量轻的牛放下面是很亏的，同样把不强壮的牛放下面也是亏的，所以就尽可能把又重又强壮的牛放下面

就不证明了。

#include <iostream>
#include <algorithm>

using namespace std;

typedef pair<int,int> PII;//存储牛的体重+强健度，体重
const int N = 50010;

PII cow[N];
int n;

int main(){
    cin >> n;
    for(int i = 0 ; i < n ; i ++){
        int w,s;
        cin >> w >> s;
        cow[i] = {w + s,w};
    }
    sort(cow ,cow + n);//自动先按体重+强健度排序
    int sum = 0,res = -2e9;
    
    for(int i = 0 ; i < n ; i ++){
        int w = cow[i].second,s = cow[i].first - w;//s为强健度
        res = max(res,sum - s);
        sum += w;
    }
    
    cout << res << endl;
}

总结：贪心算法（Greedy Algorithm）是一类在每一步选择中都采取当前最优策略，以期最终获得全局最优解的算法。贪心算法非常适用于解决局部最优能够导出全局最优的场景。在实际应用中，贪心算法通常比动态规划和回溯算法更为简单高效，但它并不总是能保证找到最优解。因此，贪心算法的应用需要证明其贪心策略是正确的，确保每一步的局部最优解能够累积成为全局最优解。

完结撒花~多复习