贪心算法的应用实例：子问题的局部最优解可推导出全局最优解

下面，我将用三道题目说明贪心算法的思维方式、使用范围、使用方法、排序不等式证明和过程的推导。

一、多操作的贪心算法实现：如何趋向最优解

1. 形式化题目描述

现有两个数 $X$ 和 $Y$ ，要求我们用以下两种操作在最少的次数内将 $X$ 变成 $Y$ 。

• $X\leftarrow 2X$ ；
• $X\leftarrow X-1$ 。
  求最少操作次数。
  数据范围：$1\le X,Y\le 1\times 10^{10}$
  

2. 实现方式

算法的选择：我们首先考虑使用 $\text{DFS}$ 算法。对于每个节点，分两种情况：乘以 $2$ ，减去 $1$ 。如果我们发现目前的数已经大于 $2\times 10^{10}$ ，则到达递归边界，退出该轮递归。否则，继续分支，直到 $Y=X$ 为止，并记录当前的操作次数。如果当前的操作次数是最优操作次数，更新答案，重新寻找是否有更优的操作次数。但是，这种算法的时间复杂度为 $O(2^{Y-X})$ ，所以严重超时。
如果我们使用 $\text{DP}$ ，则我们需要定义一个规模为 $2\times 10^{10}$ 的数组，并且需要循环两重，所以时间复杂度最高可以达到 $4\times 10^{20}$ ，依旧严重超时。因此，我们考虑使用复杂度更低的贪心算法。

结论：我们可以使用逆向的推理方法，当 $Y$ 能除以 $2$ 时（定义：$Y>X$ 且 $Y\text{mod }2=0$）将 $Y\leftarrow \frac{Y}{2}$ ，否则将 $Y\leftarrow Y+1$ ，直到 $X=Y$ 为止。
证明：使用反证法求证。
如果我们在 $Y$ 能除以 $2$ 时不除以 $2$ 而选择加上 $1$ 且 $Y>X$，则
$\because$ $1\le Y\le 1\times 10^{10}$ ，即 $Y\in \mathbb{N}\text{*}$ ，
$\therefore$ $Y+1>\frac{Y}{2}$ 。
$\because$ $Y>X$ ，
$\therefore$ $Y+1-X>\frac{Y}{2}-X$ 。
$\therefore$ 无论我们如何变换 $Y$ 和 $X$ ，$\frac{Y}{2}$ 始终更加接近正确答案。
$\therefore$ 让 $Y\leftarrow \frac{Y}{2}$ 能花费更少的次数。
同理，如果我们在 $Y\le X$ 时选择将 $Y\leftarrow \frac{Y}{2}$ ，则
$\because$ $X-(Y+1)>X-\frac{Y}{2}$ （部分与上面类似的条件省略），
$\therefore$ 让 $Y\leftarrow Y+1$ 能花费更少的次数。
证毕。

误区：误认为使用顺向思维，将 $X$ 不断乘以 $2$ ，最后可以使次数最少。
反例如下：让 $X=1,Y=1\times 10^{10}$ ，则使用上述的贪心算法只需要花费 $39$ 次，但使用上面的错误算法将要花费
$$\begin{array}{c}\begin{array}{rl}& \lceil {\log }_{2}Y\rceil +2^{\lceil {\log }_{2}Y\rceil }-Y\\ & =\lceil {\log }_{2}1\times 10^{10}\rceil +2^{\lceil {\log }_{2}Y\rceil }-Y\\ & =34+2^{34}-10^{10}\\ & =34+7179869184\\ & =7179869218\\ & >39\end{array}\end{array}$$
$\therefore$ 不能使用以上方法求解。

时间复杂度：$O(\frac{{\log }_{2}Y}{{\log }_{2}X})$ 。

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

#define ONLINE_JUDGE 1

typedef long long ll;

ll x, y;
int ans;

int main()
{
#if ONLINE_JUDGE
    freopen("change.in", "r", stdin);
    freopen("change.out", "w", stdout);
#endif
    
    cin >> x >> y;

    while (y > x)
    {
        if (y % 2 == 0) y /= 2;
        else y++;

        ans++;
    }
    ans += x - y;

    cout << ans << endl;

    return 0;
}

二、“排队接水”变形题目的贪心算法实例：分析排序不等式

1. 形式化题目描述

我们现在有两个长度均为 $N$ 的序列 $a$ 和 $b$ ，试通过恰当的位置调换使 ${\sum }_{i=1}^N(a_i{\sum }_{j=1}^i{b}_j)$ 最小。

2. 实现方式

算法的选择：此题可以看作带权值的“排队接水”问题，故应该使用贪心算法分析排序的不等式。

结论：排序不等式为 $a_j{b}_i<a_i{b}_j$ 。

证明：假设我们当前看到的是第 $i$ 个和第 $j$ 个。
$\because$ 当前两项的和有两种可能：$a_i{b}_i+a_j(b_i+b_j)$ ， $a_j{b}_j+a_i(b_i+b_j)$ 。
$\therefore$ 排序不等式为 $a_i{b}_i+a_j(b_i+b_j)<a_j{b}_j+a_i(b_i+b_j)$ 。
$\therefore$ 经过推导可得
$$\begin{array}{rl}{a}_i{b}_i+a_j{b}_i+a_j{b}_j& <a_j{b}_j+a_i{b}_i+a_i{b}_j\\ \bcancel{a_i{b}_i}+a_j{b}_i+\bcancel{a_j{b}_j}& <\bcancel{a_j{b}_j}+\bcancel{a_i{b}_i}+a_i{b}_j\\ a_j{b}_i& <a_i{b}_j\end{array}\text{\hspace{1em}(1)}$$
不等式 $(1)$ 即为所求。
证毕。

时间复杂度：瓶颈为快排的复杂度，$O(N{\log }_{2}N)$ 。

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

#define ONLINE_JUDGE 1

const int N = 1e5 + 10;

struct Node
{
    long long x, y;
} a[N];

long long n, ans;

int main()
{
#if ONLINE_JUDGE
    freopen("eat.in", "r", stdin);
    freopen("eat.out", "w", stdout);
#endif

    cin >> n;
    for (int i = 1; i <= n; ++i)
    {
        cin >> a[i].x >> a[i].y;
        //x重要度 y等待时间
    }

    sort(a + 1, a + n + 1, [&](const Node& a, const Node& b)
    {
        return a.y * b.x < a.x * b.y;
    });
    int t = 0;
    for (int i = 1; i <= n; ++i)
    {
        t += a[i].y;
        ans += t * a[i].x;
    }

    cout << ans << endl;

    return 0;
}

三、多任务执行测试的排序不等式推理方法

1. 题意简述

我们现在要在一台电脑上运行 $N$ 个程序，每个程序在运行时需要花费 $r_i$ 的内存空间，最小化进入后台后需要花费 $o_i$ 的内存空间。
已知我们要运行全部的程序，请问最少需要占用多少的内存空间？

2. 算法框架

本题的关键在于排序不等式的推理。

我们首先关注题意，题目让我们求的是最少需要占用的内存空间数。那么，我们可以从以下几个方面来思考解决方式：
首先，我们发现，每次运行占用空间最多的项就是当我们存储上面的第 $i$ 个程序并开始运行下面的第 $j$ 个程序时或只是上面的第 $i$ 个程序运行时占用最大的内存空间。那么，我们可以得到排序不等式如下：
max{ri,rj+oi}<max{rj,ri+oj}max\{r_i,r_j+o_i\} < max\{r_j,r_i+o_j\}max{ri​,rj​+oi​}<max{rj​,ri​+oj​}

总之，该题的整体思路与上面的题类似。

3. 代码实现

#include <bits/stdc++.h>

using namespace std;

#define ONLINE_JUDGE 1

const int N = 1e5 + 10;

struct Node
{
    int o, r;
} a[N];

int n;

int main()
{
#if ONLINE_JUDGE
    freopen("task.in", "r", stdin);
    freopen("task.out", "w", stdout);
#endif

    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n;
    for (int i = 1; i <= n; ++i)
    {
        cin >> a[i].r >> a[i].o;
    }

    sort(a + 1, a + n + 1, [&](const Node& a, const Node& b)
    {
        return max(a.r, b.r + a.o) < max(b.r, a.r + b.o);
    });
    int ans = 0, t = 0;
    for (int i = 1; i <= n; ++i)
    {
        ans = max(ans, t + a[i].r);
        t += a[i].o;
    }

    cout << ans << endl;

    return 0;
}

四、总结

在使用贪心算法的时候，不要尝试去证明一个贪心算法，这样会花费大量的时间。我们可以尝试举出反例，反例一般都是在特殊或极端数据下出现。在不确定是否应该使用一个贪心算法的时候，我们可以使用对拍等方法来验证。若这种题考查的是排序不等式，则我们可以使用数学方法来推导这个不等式。否则，我们应该用画图理解的方式尝试去说明一个贪心策略的合理性。