每日四题打卡-4.15:耍杂技的牛/贪心绝对值不等式-货仓选址/贪心排序不等式-排队打水/huffman哈夫曼树-合并果子

最新推荐文章于 2024-03-16 16:24:16 发布

ai_XZP_master

最新推荐文章于 2024-03-16 16:24:16 发布

阅读量361

点赞数

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

本文链接：https://blog.csdn.net/qq_27262727/article/details/105530931

版权

算法专栏收录该内容

96 篇文章 3 订阅

订阅专栏

耍杂技的牛

具体：https://blog.csdn.net/qq_27262727/article/details/105515507

农民约翰的N头奶牛（编号为1..N）计划逃跑并加入马戏团，为此它们决定练习表演杂技。

奶牛们不是非常有创意，只提出了一个杂技表演：

叠罗汉，表演时，奶牛们站在彼此的身上，形成一个高高的垂直堆叠。

奶牛们正在试图找到自己在这个堆叠中应该所处的位置顺序。

这N头奶牛中的每一头都有着自己的重量WiWi以及自己的强壮程度SiSi。

一头牛支撑不住的可能性取决于它头上所有牛的总重量（不包括它自己）减去它的身体强壮程度的值，现在称该数值为风险值，风险值越大，这只牛撑不住的可能性越高。

您的任务是确定奶牛的排序，使得所有奶牛的风险值中的最大值尽可能的小。

输入格式

第一行输入整数N，表示奶牛数量。

接下来N行，每行输入两个整数，表示牛的重量和强壮程度，第i行表示第i头牛的重量WiWi以及它的强壮程度SiSi。

输出格式

输出一个整数，表示最大风险值的最小可能值。

数据范围

1≤N≤500001≤N≤50000,
1≤Wi≤10,0001≤Wi≤10,000,
1≤Si≤1,000,000,0001≤Si≤1,000,000,000

输入样例：

输出样例：

//为了使风险值的最大值最小，应该将牛按照W+S从小到大的顺序从下往上排列。
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> sums;
bool cmp(int a, int b)
{
    return sums[a] < sums[b];
}
int main()
{
    int N, W, S;
    cin >> N;
    vector<int> Ws(N), Ss(N), ranks(N);
    sums.resize(N);
    for (int i = 0; i < N; i ++)
    {
        cin >> W >> S;
        Ws[i] = W;
        Ss[i] = S;
        sums[i] = W + S;
        ranks[i] = i;
    }
    //sort
    sort(ranks.begin(), ranks.end(), cmp);
    int res = -1000000;
    int sum_W = 0;
    for (int i = 0; i < N; i ++)
    {
        int cur_id = ranks[i];
        res = max(res, sum_W - Ss[cur_id]);
        sum_W += Ws[cur_id];
    }
    cout << res << endl;
    return 0;
}

贪心绝对值不等式-货仓选址

在一条数轴上有 NN 家商店，它们的坐标分别为 A1A1~ANAN。

现在需要在数轴上建立一家货仓，每天清晨，从货仓到每家商店都要运送一车商品。

为了提高效率，求把货仓建在何处，可以使得货仓到每家商店的距离之和最小。

输入格式

第一行输入整数N。

第二行N个整数A1A1~ANAN。

输出格式

输出一个整数，表示距离之和的最小值。

数据范围

1≤N≤1000001≤N≤100000

输入样例：

4
6 2 9 1

输出样例：

思路：

货仓选址.png

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;
const int N = 100010;
int q[N];
int n;
int main()
{
    cin >> n;
    //这里从1开始
    for (int i = 1; i <= n; i ++) cin >> q[i];
    sort(q+1, q + 1 + n);
    LL res = 0;
    //中间值相减然后求绝对值
    for (int i = 1; i <= n; i ++) res += abs(q[i] - q[(n + 1)/2]);
    cout << res << endl;
    return 0;
}

贪心排序不等式-排队打水

有 n个人排队到 1 个水龙头处打水，第 i个人装满水桶所需的时间是 ti，请问如何安排他们的打水顺序才能使所有人的等待时间之和最小？

输入格式

第一行包含整数 nn。

第二行包含 nn 个整数，其中第 ii 个整数表示第 ii 个人装满水桶所花费的时间 titi。

输出格式

输出一个整数，表示最小的等待时间之和。

数据范围

1≤n≤1051≤n≤105,
1≤ti≤1041≤ti≤104

输入样例：

7
3 6 1 4 2 5 7

输出样例：

思路：按照从小到大排序，总时间最小

#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 100010;
int n;
int t[N];
int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++) cin >> t[i];
    sort(t, t + n);
    LL res = 0;
    //sort是从小到大排序，最小的应该*最大的值n - 1，所以得倒过来
    for (int i = 0; i < n; i ++) res += t[i] * (n - i - 1);
    cout << res << endl;
    return 0;
}

huffman哈夫曼树-合并果子

在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。

达达决定把所有的果子合成一堆。

每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。

可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。

达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。

因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。

假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。

例如有3种果子，数目依次为1，2，9。

可以先将1、2堆合并，新堆数目为3，耗费体力为3。

接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。

所以达达总共耗费体力=3+12=15。

可以证明15为最小的体力耗费值。

输入格式

输入包括两行，第一行是一个整数n，表示果子的种类数。

第二行包含n个整数，用空格分隔，第i个整数aiai是第i种果子的数目。

输出格式

输出包括一行，这一行只包含一个整数，也就是最小的体力耗费值。

输入数据保证这个值小于231231。

数据范围

1≤n≤100001≤n≤10000,
1≤ai≤200001≤ai≤20000

输入样例：

3 
1 2 9

输出样例：

思路：

哈夫曼树：树是完全二叉树，所有叶子结点都是合并的点。

方法：每次挑出值最小的来合并。

//用小根堆来做
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
int main()
{
    int n;
    cin >> n;
    priority_queue<int, vector<int>, greater<int>> heap;
    while (n --)
    {
        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;
}