区间问题

//区间选点
给定 N 个闭区间 [ai,bi]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。
输出选择的点的最小数量。
位于区间端点上的点也算作区间内。

把区间按右端点排序
如果上一个选的端点不包含在本区间，则选择当前区间的右端点作为新的包含点

证明：

首先最终的答案 ans 一定是最小的选择数量，所以上面决策的数量 cnt（cnt 一定能满足所有区间都包含一个点），一定满足cnt>=ans

其次，当序列中包含了 cnt 个相互之间没有交集的区间，对于一个合法方案，必然至少包含 cnt 个点，所以cnt<=ans

所以ans==cnt

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;


const int N = 1e5+10;
pair<int,int>nums[N];
int main()
{
    int n;
    cin>>n;
    int a,b;
    for(int i=0;i<n;i++)
    {
        cin>>a>>b;
        nums[i]={a,b};
    }
    sort(nums,nums+n,[&](pair<int,int>&a,pair<int,int>&b){
       return a.second<b.second; 
    });
    int ans=0,ed=-2e9;
    for(int i=0;i<n;i++)
    {
        if(ed<nums[i].first)
        {
            ans++;
            ed=nums[i].second;
        }
    }
    cout<<ans;
    return 0;
}

//区间分组
给定 N 个闭区间 [ai,bi]，请你将这些区间分成若干组
使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。

左端点排序
每次拿当前点的左端点和组内最大右端点（所有组的最小右端点比）决定是加入组并且更新组内最大右端点还是新建一个组

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 1e5+10;
pair<int,int>nums[N];
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int a,b;
        cin>>a>>b;
        nums[i]={a,b};
    }
    
    sort(nums,nums+n,[&](auto &a,auto &b){
        return a.first<b.first;
    });
    
    priority_queue<int, vector<int>, greater<int>> q;
    for(int i=0;i<n;i++)
    {
        int a=nums[i].first;
        int b=nums[i].second;
        if(q.empty()||q.top()>=a)q.push(b);
        else {
            int t=q.top();
            q.pop();
            int k=max(t,b);
            q.push(k);
        }
    }
    cout<<q.size()<<endl;
    return 0;
}

Huffman 树

设二叉树具有 n 个带权叶结点，从根结点到各叶结点的路径长度与相应叶节点权值的乘积之和称为 树的带权路径长度（Weighted Path Length of Tree，WPL） 。

对于给定一组具有确定权值的叶结点，可以构造出不同的二叉树，其中，WPL 最小的二叉树 称为 霍夫曼树（Huffman Tree） 。

对于霍夫曼树来说，其叶结点权值越小，离根越远，叶结点权值越大，离根越近

//合并果子
在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。
达达决定把所有的果子合成一堆。
每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。
可以看出，所有的果子经过 n−1 次合并之后，就只剩下一堆了。
达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。
因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。
假定每个果子重量都为 1，并且已知果子的种类数和每种果子的数目
你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。

每次拿最小的两堆合并

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

int main()
{
    int n;
    cin>>n;
    priority_queue<int, vector<int>, greater<int>> q;
    while(n--)
    {
        int a;
        cin>>a;
        q.push(a);
    }
    int ans=0;
    while(q.size()>1)
    {
        int a=q.top();
        q.pop();
        int b=q.top();
        q.pop();
        q.push(a+b);
        ans=ans+a+b;
    }
    cout<<ans<<endl;
    return 0;
}

排序不等式

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

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

绝对值不等式

//货仓选址
在一条数轴上有 N 家商店，它们的坐标分别为 A1∼AN。
现在需要在数轴上建立一家货仓，每天清晨，从货仓到每家商店都要运送一车商品。
为了提高效率，求把货仓建在何处，可以使得货仓到每家商店的距离之和最小。

选在所有店铺之间，也就是中位数

#include <iostream>
#include <algorithm>

using namespace std;
const int N = 1e5+10;
int nums[N];
int main()
{
    int n;
    cin>>n;
    
    for(int i=0;i<n;i++)cin>>nums[i];
    
    sort(nums,nums+n,[&](int &a,int &b){
        return a<b;
    });
    
    int ans=0;
    for(int i=0;i<n;i++)ans+=abs(nums[i]-nums[n/2]);
    
    cout<<ans;
    return 0;
}

推公式

//耍杂技的牛
农民约翰的 N 头奶牛（编号为 1..N）计划逃跑并加入马戏团，为此它们决定练习表演杂技。
奶牛们不是非常有创意，只提出了一个杂技表演：
叠罗汉，表演时，奶牛们站在彼此的身上，形成一个高高的垂直堆叠。
奶牛们正在试图找到自己在这个堆叠中应该所处的位置顺序。
这 N 头奶牛中的每一头都有着自己的重量 Wi 以及自己的强壮程度 Si。
一头牛支撑不住的可能性取决于它头上所有牛的总重量（不包括它自己）减去它的身体强壮程度的值
现在称该数值为风险值，风险值越大，这只牛撑不住的可能性越高。
您的任务是确定奶牛的排序，使得所有奶牛的风险值中的最大值尽可能的小。

按照wi+si从小到大，从上到下的顺序排序，最大的危险系数一定是最小的

证明：

当前的贪心方案是一定满足：贪心方案>=最优解

如果说最优解的方案不是贪心的方案：

从上到下第i头牛 wi+si

第i+1头牛： wi+1+si+1

他们满足 wi+si>wi+1+si+1

此时他们的风险值为

i : w1+w2+....+wi-1-si i+1: w1+w2+....+wi-1+wi-si+1

化简：i : si+1 i+1: wi+si

如果交换他们的位置（也就是满足贪心方案）此时有：

i : w1+w2+....+wi-1-si+1 i+1: w1+w2+....+wi-1+wi+1-si

化简：i: si i+1: wi+1+si+1

化简的方式也就是同时减去w1+w2+...+wi-1再加上si+si+1

可以看出的关系 : wi+si>si+1 wi+si>wi+1+si+1 wi+si>si

所以可以看出非贪心方案的风险最大值是 wi+si

贪心的最大值是 si或者wi+1+si+1 且至少不大于 wi+si

所以可以判断贪心解<=最优解

最终得到贪心解==最优解

#include<iostream>
#include <algorithm>
using namespace std;

const int N = 1e5;

pair<int,int>nums[N];
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int a,b;
        cin>>a>>b;
        nums[i]={a,b};
    }
    
    sort(nums,nums+n,[&](auto &a,auto &b){
       return a.first+a.second<b.first+b.second;
    });
    
    int sum=0,ans=-2e9;
    
    for(int i=0;i<n;i++)
    {
        ans=max(ans,sum-nums[i].second);
        sum+=nums[i].first;
    }
    cout<<ans<<endl;
}

算法(cpp) - 贪心

区间问题

Huffman 树

排序不等式

绝对值不等式

推公式