《算法竞赛进阶指南》0.7贪心

110. 防晒

有C头奶牛进行日光浴，第i头奶牛需要minSPF[i]到maxSPF[i]单位强度之间的阳光。
每头奶牛在日光浴前必须涂防晒霜，防晒霜有L种，涂上第i种之后，身体接收到的阳光强度就会稳定为SPF[i]，第i种防晒霜有cover[i]瓶。
求最多可以满足多少头奶牛进行日光浴。

输入格式
第一行输入整数C和L。
接下来的C行，按次序每行输入一头牛的minSPF和maxSPF值,即第i行输入minSPF[i]和maxSPF[i]。
再接下来的L行，按次序每行输入一种防晒霜的SPF和cover值,即第i行输入SPF[i]和cover[i]。
每行的数据之间用空格隔开。

输出格式
输出一个整数，代表最多可以满足奶牛日光浴的奶牛数目。

数据范围
1≤C,L≤2500,
1≤minSPF≤maxSPF≤1000,
1≤SPF≤1000

输入样例：
3 2
3 10
2 5
1 5
6 2
4 1

输出样例：
2

#include <iostream>
#include <algorithm>
#include <map>
#include <cstring>

using namespace std;

typedef pair<int, int> PII;//pair 易于排序

const int N = 2510;

int n, m;
PII cows[N];

int main()
{
    cin >> n >> m;
    for(int i = 0; i < n; i++) cin >> cows[i].first >> cows[i].second;
    sort(cows, cows + n);
    map<int, int> spfs; //用map 来储存防晒霜
    for(int i = 0; i < m; i++) // 0开始没有 <= 1开始才是
    {
        int spf, cover;
        cin >> spf >> cover;
        spfs[spf] += cover; // 注意这里要写 +=，因为数据中存在spf值相同的防晒霜
    }
    
    int res = 0; //初始化要赋值
    spfs[0] = spfs[1001] = n; //平衡树两个哨兵,方便找最大最小
    for(int i = n - 1; i >= 0; i--) // 从后往前遍历前n个数 ，从大到小考虑
    {
        auto cow = cows[i]; //lower_bound >=某个数的最小值 upper_bound是>某个数的最小值
        auto it = spfs.upper_bound(cow.second);//auto 为 map<int, int>::iterator
        it --;
        if(it->first >= cow.first && it->first <= cow.second)
        {
            res ++;
            if(-- it->second == 0)
                spfs.erase(it);
        }
    }
    cout << res << endl;
    return 0;
}

111. 畜栏预定

有N头牛在畜栏中吃草。

每个畜栏在同一时间段只能提供给一头牛吃草，所以可能会需要多个畜栏。

给定N头牛和每头牛开始吃草的时间A以及结束吃草的时间B，每头牛在[A,B]这一时间段内都会一直吃草。

当两头牛的吃草区间存在交集时（包括端点），这两头牛不能被安排在同一个畜栏吃草。

求需要的最小畜栏数目和每头牛对应的畜栏方案。

输入格式
第1行：输入一个整数N。
第2..N+1行：第i+1行输入第i头牛的开始吃草时间A以及结束吃草时间B，数之间用空格隔开。

输出格式
第1行：输入一个整数，代表所需最小畜栏数。
第2..N+1行：第i+1行输入第i头牛被安排到的畜栏编号，编号从1开始，只要方案合法即可。

数据范围
1≤N≤50000,
1≤A,B≤1000000

输入样例：
5
1 10
2 4
3 6
5 8
4 7

输出样例：
4
1
2
3
2
4

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

using namespace std;

typedef pair<int, int> PII;
const int N = 50010;

int n;
pair<PII, int> cows[N]; //可以存三个，pair两个，int一个 pair 自定有排序函数
int id[N];

int main()
{
    cin >> n;
    for(int i = 0; i < n; i++) 
    {
        cin >> cows[i].first.first >> cows[i].first.second;
        cows[i].second = i;  //cows[i].second为 id
    }
    sort(cows, cows + n);
    
    priority_queue<PII, vector<PII>, greater<PII>> heap; //小根堆定义
    
    for(int i = 0; i < n; i++)
    {
        auto cow = cows[i].first;
        if(heap.empty() || heap.top().first >= cow.first)
        {
            PII stall = {cow.second, heap.size() + 1};//畜栏数目,从1开始数，加1
            id[cows[i].second] = stall.second; //cows[i].second为 id
            heap.push(stall); //将当前畜栏加到堆里面
        }
        else
        {
            auto stall = heap.top();
            heap.pop();
            stall.first = cow.second; // first存当前牛的结束吃草时间
            id[cows[i].second] = stall.second;
            heap.push(stall);
        }
    }
    cout << heap.size() << endl;
    for(int i = 0; i < n; i++) cout << id[i] <<endl;
    return 0;
}

112. 雷达设备

假设海岸是一条无限长的直线，陆地位于海岸的一侧，海洋位于另外一侧。

每个小岛都位于海洋一侧的某个点上。

雷达装置均位于海岸线上，且雷达的监测范围为d，当小岛与某雷达的距离不超过d时，该小岛可以被雷达覆盖。

我们使用笛卡尔坐标系，定义海岸线为x轴，海的一侧在x轴上方，陆地一侧在x轴下方。

现在给出每个小岛的具体坐标以及雷达的检测范围，请你求出能够使所有小岛都被雷达覆盖所需的最小雷达数目。

输入格式
第一行输入两个整数n和d，分别代表小岛数目和雷达检测范围。
接下来n行，每行输入两个整数，分别代表小岛的x，y轴坐标。
同一行数据之间用空格隔开。

输出格式
输出一个整数，代表所需的最小雷达数目，若没有解决方案则所需数目输出“-1”。

数据范围
1≤n≤1000

输入样例：
3 2
1 2
-3 1
2 1

输出样例：
2

#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

typedef pair<double, double> PDD;
const int N = 1010;
const double eps = 1e-6, INF = 1e10; // double一般定义一个eps精确值
 
int n, R;
PDD segs[N];

int main()
{
    bool success = true;
    
    cin >> n >> R;
    for(int i = 0; i < n; i++)
    {
        int x, y;
        cin >> x >> y;
        if(y > R)
        {
            success = false;
            break;
        }
        double len = sqrt(R * R - y * y);
        segs[i] = {x + len, x - len}; //区间 按终点起点排序
    }
    if(!success) puts("-1");
    else
    {
        sort(segs, segs + n);
        int res = 0;
        double last = -INF; //***这里要定义double
        for(int i = 0; i < n; i++)
        {
            auto seg = segs[i];
            if(seg.second > last + eps) //seg.second 是起点
            {
                res ++;
                last = seg.first; // seg.first的终点
                
            }
        }
        cout << res << endl;
    }
    return 0;
}

114. 国王游戏

恰逢 H 国国庆,国王邀请 n 位大臣来玩一个有奖游戏。

首先,他让每个大臣在左、右手上面分别写下一个整数,国王自己也在左、右手上各写一个整数。

然后,让这 n 位大臣排成一排,国王站在队伍的最前面。

排好队后,所有的大臣都会获得国王奖赏的若干金币,每位大臣获得的金币数分别是:

排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数,然后向下取整得到的结果。

国王不希望某一个大臣获得特别多的奖赏,所以他想请你帮他重新安排一下队伍的顺序,使得获得奖赏最多的大臣,所获奖赏尽可能的少。

注意,国王的位置始终在队伍的最前面。

输入格式
第一行包含一个整数 n,表示大臣的人数。
第二行包含两个整数 a 和 b,之间用一个空格隔开,分别表示国王左手和右手上的整数。
接下来 n 行,每行包含两个整数 a 和 b,之间用一个空格隔开,分别表示每个大臣左手和右手上的整数。

输出格式
输出只有一行,包含一个整数,表示重新排列后的队伍中获奖赏最多的大臣所获得的金币数。

数据范围
1≤n≤1000
0<a,b<10000

输入样例：
3
1 1
2 3
7 4
4 6

输出样例：
2

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

using namespace std;

typedef pair<int, int>PII;
const int N = 1010;

int n;
PII ps[N];

vector<int> mul(vector<int> a, int b) //高精度乘法
{
    vector<int> c;
    int t = 0;
    for(int i = 0; i < a.size(); i++)
    {
        t += a[i] * b;
        c.push_back(t % 10); //取出余数
        t /= 10; //进位
    }
    while(t) c.push_back(t % 10), t /= 10;
    return c; 
}

vector<int> div(vector<int> a, int b)
{
    vector<int> c;
    bool is_first = false; // 避免输出前面位的0
    for(int i = a.size() - 1, t = 0; i >= 0; i--) //从高位往低位
    {
        t = t * 10 + a[i]; //竖式后位的值
        int x = t / b;
        if(x || is_first)
        {
            is_first  = true;
            c.push_back(x);
        }
        t %= b;
    }
    return vector<int>(c.rbegin(), c.rend()); //逆序遍历
}

vector<int> max_vec(vector<int>a, vector<int> b) // 返回vector
{
    if(a.size() > b.size()) return a;
    if(a.size() < b.size()) return b;
    if(vector<int>(a.rbegin(), a.rend()) > vector<int>(b.rbegin(), b.rend()))//构造新的vector，是a的逆序
        return a;
    return b;    
}

void output(vector<int> a)
{
    for(int i = a.size() - 1; i >= 0; i--) cout << a[i]; //高精度存，小位在前，高位在后,因为增加一位只能在后面增加
    cout << endl;
}

int main()
{
    cin >> n;
    for(int i = 0; i <= n; i++) // 0位国王，1...n+1为大臣
    {
        int a, b;
        cin >> a >> b;
        ps[i] = {a * b, a};
    }
    sort(ps + 1, ps + n + 1);
    
    vector<int>product(1, 1); //乘积长度为1，初始为1
    vector<int>res(1,0); // 结果长度为1，初始为0
    
    for(int i = 0; i <= n; i++)
    {
        if(i) res = max_vec(res, div(product, ps[i].first / ps[i].second));
        product = mul(product, ps[i].second);
    }
    
    output(res);
    return 0;
}

115. 给树染色

一颗树有 n 个节点，这些节点被标号为：1,2,3…n，每个节点 i 都有一个权值 A[i]。

现在要把这棵树的节点全部染色，染色的规则是：

根节点R可以随时被染色；对于其他节点，在被染色之前它的父亲节点必须已经染上了色。

每次染色的代价为T*A[i]，其中T代表当前是第几次染色。

求把这棵树染色的最小总代价。

输入格式
第一行包含两个整数 n 和 R ，分别代表树的节点数以及根节点的序号。
第二行包含 n 个整数，代表所有节点的权值，第 i 个数即为第 i 个节点的权值 A[i]。
接下来n-1行，每行包含两个整数 a 和 b ，代表两个节点的序号，两节点满足关系： a 节点是 b 节点的父节点。
除根节点外的其他 n-1 个节点的父节点和它们本身会在这 n-1 行中表示出来。
同一行内的数用空格隔开。

输出格式
输出一个整数，代表把这棵树染色的最小总代价。

数据范围
1≤n≤1000,
1≤A[i]≤1000

输入样例：
5 1
1 2 1 2 4
1 2
1 3
2 4
3 5
0 0

输出样例：
33

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

struct Node
{
    int father, size, sum;
    double avg;
}nodes[N];

int n, root;

int find() //找权值最大的根节点
{
    double avg = 0;
    int res = -1;
    for(int i = 1; i <=n; i++)
        if(i != root && avg < nodes[i].avg)
        {
            avg = nodes[i].avg;
            res = i;
        }
    return res;    
}

int main()
{
    int res = 0;
    cin >> n >> root;
    for(int i = 1; i <= n; i++)
    {
        auto &nd = nodes[i];
        cin >> nd.sum;
        nd.size = 1;
        nd.avg = nd.sum;
        res += nd.sum; //初始赋值 每个数乘一加一块，所有数的和
    }
    for(int i = 0, a, b; i < n - 1;i++)
    {
        cin >> a >> b;
        nodes[b].father = a;
    }
    
    for(int i = 0; i < n - 1; i++)
    {
        int ver = find();
        int f = nodes[ver].father;
        res += nodes[ver].sum * nodes[f].size;
        nodes[ver].avg = -1;
        for(int j = 1; j <= n; j++)
            if(nodes[j].father == ver)
                nodes[j].father = f;
        nodes[f].sum += nodes[ver].sum;
        nodes[f].size += nodes[ver].size;
        nodes[f].avg = (double)nodes[f].sum / nodes[f].size;
    }
    cout << res << endl;
    return 0;
}