贪心算法模型总结

最新推荐文章于 2024-04-23 13:56:04 发布

爱寂寞的时光

最新推荐文章于 2024-04-23 13:56:04 发布

阅读量1.1k

点赞数 2

分类专栏： # 二分、倍增、滑动窗口等基础算法文章标签：贪心算法算法

本文链接：https://blog.csdn.net/jiahonghao2002/article/details/119593643

版权

二分、倍增、滑动窗口等基础算法专栏收录该内容

18 篇文章 0 订阅

订阅专栏

贪心算法模型总结

调度安排问题

应用贪心算法最多的就是顺序安排问题，也是最难的一类问题，问题形式变化多样。

其一之

任务开始结束时间固定，同一时间只能做一个，最多能做几个？

此问题的贪心策略是按照任务的结束时间从小到大排序，因为先做完把时间让给后面，后面的任务就有可能做完。

以下问题不做说明均为同一时间只能做一个。

其二之

每个任务必须做，开始结束时间不固定，但是每个任务所花费的时间固定，并且设每个任务的截止时间为 $d$ ，设这个任务的完成时间为 $x$ ，那么我们这个任务的奖励为 $d - x$ ，问总计奖励的最大值。

此类问题我们也称为排序问题，因为每个任务必须做，并且存在先后顺序，则必然存在一个全序集合。

我们考虑当前的时间为 $i$ ，任务 $A$ 的持续时间为 $T_A$ ，截止时间是 $D_A$ ；任务 $B$ 的持续时间为 $T_B$ ，截止时间是 $D_B$ 。

那么把 $A$ 放在前面更优的条件为：

$D_A - (i + T_A) + D_B - (i + T_A + T_B) > D_B - (i + T_B) + D_A - (i + T_A + T_B) \\$

即 $T_A < T_B$ ，那么我们定义排序规则，将花费时间少的排在前面，这样得到的顺序就是最优顺序。

其三之

在一段数轴上有一些连续的任务点，有 $m$ 个作业任务，每一个作业任务都能覆盖一段连续的任务点（区间 $l_i,r_i]$ ），问选出最小的作业任务数量，能够覆盖所有的任务点。

考虑贪心，设立一个当前最远指针 $r$ ，每次遍历所有的作业任务，选出能把 $r$ 扩展到最远的任务即可。

P1514

其四之

P4053 建筑抢修

每个任务都有花费时间，和截止时间，如果在截止时间之内没有完成那么奖励为 $0$ ，否则奖励为 $1$ ，每个任务可做可不做。

此类问题也称为反悔贪心，因为每个任务可做可不做，找不到一个排序规则使得最优。因此我们考虑~~直觉贪心~~ ，即应该让快到截止时间的任务先做，那么我们先按照截止时间从大到小排序，依次考虑每个任务，如果这个任务发现无法在截止时间内完成，那么我们在已经做完的任务中寻找最大的花费时间那个，如果当前任务的花费时间小于最大的花费时间那个任务，那么我们放弃最大的花费时间那个任务，转手做当前任务。这样虽然不会增加贡献，但是会减少总时间让给后面的任务。

#include <bits/stdc++.h>

using namespace std;

#define FR freopen("in.txt", "r", stdin)
#define FW freopen("out.txt", "w", stdout)

typedef long long ll;

struct KK
{
    ll ti;
    ll d;

    bool operator<(const KK &o) const
    {
        return d < o.d;
    }
} gs[150005];

int main()
{
    int n;
    scanf("%d", &n);
    priority_queue<ll> pq;
    for (int i = 0; i < n; i++)
    {
        scanf("%lld %lld", &gs[i].ti, &gs[i].d);
    }
    sort(gs, gs + n);
    ll T = 0;
    int ans = 0;
    for (int i = 0; i < n; i++)
    {
        if (T + gs[i].ti > gs[i].d)
        {
            if (gs[i].ti < pq.top())
            {
                T -= pq.top();
                pq.pop();
                T += gs[i].ti;
                pq.push(gs[i].ti);
            }
        }
        else
        {
            T += gs[i].ti;
            ans++;
            pq.push(gs[i].ti);
        }
    }

    printf("%d", ans);

    return 0;
}

其五之

有一段从 $1$ 到 $n$ 的一段连续的时间点其都是整数任给一些任务，每个任务必须安放在 $l_i,r_i]$ 区域内的任意一个时间点，询问是否存在一种方案，能够满足要求。

ABC 214E

我们根据扫描线思想，按照每个任务从左到右的顺序放置即可。

#include <bits/stdc++.h>

#define FR freopen("in.txt", "r", stdin)
#define FW freopen("out.txt", "w", stdout)

using namespace std;

int pos[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

typedef long long ll;

const ll mod = 1e9 + 7;

void solve()
{
    int n;
    cin >> n;
    map<int, vector<int>> mp;
    set<int> ls;
    for (int i = 1; i <= n; i++)
    {
        int l, r;
        cin >> l >> r;
        mp[l].push_back(r);
        ls.insert(l);
    }
    priority_queue<int, vector<int>, greater<int>> pq;
    int i = *ls.begin();
    bool ok = true;
    while (i <= 1000000000)
    {
        for (int k : mp[i])
            pq.push(k);
        pq.pop();

        if (pq.empty())
        {
            auto it = ls.upper_bound(i);
            if (it == ls.end())
            {
                break;
            }
            else
            {
                i = *it;
            }
        }
        else
        {
            if (pq.top() <= i)
            {
                ok = false;
                break;
            }
            i++;
        }
    }

    if (pq.empty() && ok)
    {
        cout << "Yes" << endl;
    }
    else
    {
        cout << "No" << endl;
    }
}

int main()
{
    int T;
    cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}

其六之

给定一些任务，每一个任务代表一个区间 $l_i,r_i]$ ，求出最小数量的点，使得每个任务区间都能包含至少一个点。

此问题也称区间最小点覆盖问题，我们先对区间进行结束排序，即按 $r$ 从小到大排序，依次遍历区间，如果发现区间没有被覆盖，那么这个区间必定包含一个点，根据贪心的思想，这个点应该越靠后越好，因为能够覆盖后面的区间，因此我们按照区间的最右点即 $r$ 端点处放置，同时维护一个最大右边界 $R$ ，如果当前区间包含 $R$ ，说明当前区间已经被覆盖，可以跳过。

int r = 0;
int ans = 0;
for (int i = 1; i <= tot; i++)
{
    if (segs[i].l <= r)
    {
        continue;
    }
    r = segs[i].r;
    ans++;
}

其七之

给定能覆盖 $[1, n]$ 的一些线段，先让 $[1, n]$ 的 $n$ 个点都属于任意一个线段，线段必须包含这个点，并且每个线段只能包含一个点。求出是否存在可能的方案。

首先我们将线段按照 $l$ 从小到大排序，然后设当前处理的点为 $k$ ，那么将所有 $l$ 小于等于 $k$ 的线段放入一个优先队列中，然后再在这个优先队列中选出 $r$ 最小的线段即可，如果存在不满足的线段，需要弹出。

配对问题

配对问题的关键字为一个节点和一个节点进行匹配，类似于二分图的匹配，问如何达到最大匹配问题。

LeetCode 5913

首先该问题具有决策单调性和二段性，如果 $k$ 能完成要求，那么 $k - 1$ 一定也能完成要求，并且 $k - 1$ 一定不是最优策略。我们考虑最弱的 $k$ 个任务如何匹配最强的 $k$ 个人。考虑最弱的 $k$ 个任务中的第 $i$ 强的任务，如果当前未匹配的工人列表中有能完成这件任务的工人，我们一定选最弱的那个工人，因为我们想最大化利用工人，如果选强的工人，那么多出的那部分力量就会浪费，其次如果有能吃药完成的工人，我们选择吃药能完成或者不吃药能完成都是一样的，因为不吃药能完成一定能完成吃药能完成的匹配任务，因此不影响答案。最后，如果列表中没有不吃药能完成的工人，那么我们就必须选择吃药，我们想让药力最大化不浪费，我们选择列表中第一个大于等于 $t a s k s [i] - s t r e n g t h$ 的工人即可。但如果此时没药了或者吃药也完成不了该任务，那么就无法完成 $k$ 个任务。

外层套二分即可。


class Solution
{
public:
    int maxTaskAssign(vector<int> &tasks, vector<int> &workers, int pills, int strength)
    {
        int n = tasks.size();
        int m = workers.size();
        sort(tasks.begin(), tasks.end());
        sort(workers.begin(), workers.end());

        auto check = [&](int k)
        {
            multiset<int> st(workers.rbegin(), workers.rbegin() + k);
            int res = pills;
            for (int i = k - 1; i >= 0; i--)
            {
                auto it = st.lower_bound(tasks[i]);
                if (it != st.end())
                {
                    st.erase(it);
                    continue;
                }
                if (res == 0)
                    return false;
                auto it = st.lower_bound(tasks[i] - strength);
                if (it != st.end())
                {
                    st.erase(it);
                    res--;
                    continue;
                }
                return false;
            }
            return true;
        };

        int x = 0;
        int lim = min(n, m);
        for (int b = lim; b; b >>= 1)
        {
            while (x + b <= lim && check(x + b))
                x += b;
        }
        return x;
    }
};

另外，我们也可以使用单调队列来优化二分的过程，减少一个 $\log$ 的调用。

考虑第 $i$ 个弱的工人，那么将小于等于 $w o r k e r s [i] + s t r e n g t h$ 的任务放进一个双端队列中，如果工人能够不吃药就能做队首任务，那么他一定做队首任务，否则吃药做队尾任务，再否则就完成不了 $k$ 个任务。


class Solution
{
public:
    int maxTaskAssign(vector<int> &tasks, vector<int> &workers, int pills, int strength)
    {
        int n = tasks.size();
        int m = workers.size();
        sort(tasks.begin(), tasks.end());
        sort(workers.begin(), workers.end());

        auto check = [&](int k)
        {
            deque<int> que;
            int res = pills;
            int ptr = 0;
            for (int i = m - k; i < m; i++)
            {
                while (ptr < k && tasks[ptr] <= workers[i] + strength)
                {
                    que.push_back(tasks[ptr]);
                    ptr++;
                }
                if (que.empty())
                    return false;
                if (workers[i] >= que.front())
                {
                    que.pop_front();
                }
                else if (res)
                {
                    que.pop_back();
                    res--;
                }
                else
                    return false;
            }
            return true;
        };

        int x = 0;
        int lim = min(n, m);
        for (int b = lim; b; b >>= 1)
        {
            while (x + b <= lim && check(x + b))
                x += b;
        }
        return x;
    }
};

爱寂寞的时光

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
贪心算法模型总结

贪心算法——调度安排问题应用贪心算法最多的就是顺序安排问题，也是最难的一类问题，问题形式变化多样。其一之任务开始结束时间固定，同一时间只能做一个，最多能做几个？此问题的贪心策略是按照任务的结束时间从小到大排序，因为先做完把时间让给后面，后面的任务就有可能做完。以下问题不做说明均为同一时间只能做一个。其二之每个任务必须做，开始结束时间不固定，但是每个任务所花费的时间固定，并且设每个任务的截止时间为ddd，设这个任务的完成时间为xxx，那么我们这个任务的奖励为d−xd-xd−x，问总计奖励的
复制链接

扫一扫