HDU6438 Buy and Resell 解题报告（一个有趣的贪心问题的严格证明）

写在前面

此题是一个很容易想到的贪心题目，但是正确性的证明是非常复杂的。然而，目前网上所有题解并未给出本题贪心算法的任何正确性证明，全部仅停留在描述出一个贪心算法。本着对算法与计算机科学的热爱（逃），我花了2周时间深入研究了这个问题，并请教了Apass.Jack 大牛，终于在他的帮助下证明了该贪心的正确性。接下来将给出详细地证明过程。

PS：Apass.Jack提供了整个证明框架（尽管后来被我发现了一处错误并重新修正了证明），在此表示感谢！

题目描述

给定$n$($n \le 10^5)$个城市的物品价格，每个城市只能最多购买或卖出一个物品，可以既不买也不卖。当然，若当前手上没有物品则不能卖出。问从城市1走到城市$n$，途中进行买卖后最多赚多少钱，在此前提下最少进行多少次交易。初始手上没有任何物品，但有无限的钱。

Sample Input

Sample Output

算法描述

我们先不考虑最小化交易次数，只考虑利润最大化。本题有一个比较好想的贪心算法：

从左往右遍历城市，并维护每个城市当前的状态（买了物品、卖了物品或什么都不做）。对于城市$i$，我们找1到$i-1$中价格最低的$j$且$j$城市未买入（可以卖出），如果$j$城市价格比$i$城市低，则在$j$城市买入并在$i$城市卖出。同时更新$j$城市的买卖状态：若之前状态是卖出，则更新为什么都不做；否则更新为买入。

这样遍历完1到$n$即可得出答案。实现时，显然可用优先队列维护。这样时间复杂度$O(n\log n)$。

算法正确性证明

基本术语

为表述方便，引入以下记号：

（1）用$p_i$表示城市$i$的价格；

（2）一个策略定义为每个城市的买卖状态集合，用$s_i$表示。其中，$s_i=0$表示什么都不做；$s_i=1$表示买入；$s_i=-1$表示卖出。

（3）定义$s$的前缀和为$h_s(i)=\sum_{i=1}^n {s_i}$，并补充$h_s(0)=0$；显然一个方案是合法的，当且仅当对任意$1 \le i \le n$，$h_s(i) \ge 0$。

（4）定义$(i,j)$表示一个升序二元组$(i < j)$；

（5）称$(i,j)$被策略$s$分开，或称在策略$s$中$(i,j)$不可能属于同一次买卖，如果存在$i \le k < j$，使得$h_s(k)=0$。

证明思路

此题直接证明是非常困难的，因为它会动态修改之前的策略。我们考虑引入一个中间步骤，即得出最优解满足的充要性质，然后证明贪心的解也满足这个性质，那么贪心就自然是正确的了。

接下来将证明以下几个主要定理，分别建立最优解的性质以及贪心解的性质。

另外为了简化证明，以下部分均假设所有$p_i$互不相同。显然如果$p_i$互不相同时算法正确，那么$p_i$可以相同时算法也必然正确（通过取极限）。

定理1

如果一个策略$s$是最优策略，则$h_s(n)=0$，且对于任意$(i,j)$一定满足：

（1）若$s_i=s_j=0$或$s_i<s_j$，必有$p_i>p_j$。

（2）若$s_i=s_j=0$或$s_i>s_j$，且$p_i>p_j$，$(i,j)$必然被分开。

证明：$h_s(n)=0$显然。

（1）若不然，我们将$s_i$加1，将$s_j$减1，显然对任意$i$有$h_s(i) \ge 0$，因此是合法方案，但利润更大了，矛盾。

（2）若不然，则对任意$i \le k<j$有$h_s(k)\ge1$。我们令$s_i$减1，$s_j$加1，显然对任意$i$，$h_s(i)\ge 0$仍成立，因此是合法方案，但利润更大了，矛盾。

定理2

满足定理1的策略必然由贪心算法给出。

证明：用数学归纳法，$n=1$显然成立。

考虑$n$时满足定理1的一个策略，由于$h_s(n)=0$故必有$s_n=0$或$s_n=-1$。

（1）若$s_n=0$，那么该策略在前$n-1$个城市中满足定理1策略，已由贪心算法给出。当贪心算法到第$n$个城市时，它一定什么都不做，若不然，必存在$p_j<p_n$且$s_j \le 0$。那么二元组$(j,n)$和定理1（1）矛盾。

（2）若$s_n=-1$。设$k$是$0 \le k<n$中满足$h_s(k)=0$的最大的$k$，$j$为$k<j\le n$中$s_j \ge 0$且价格最高的城市。

考虑把$s_j$减1而其它不变，这样我们得到一个新策略，将其记为$w$，那么新的策略$h_w(n-1)=0$且$h_w$恒非负，此时$w_1$到$w_{n-1}$便是前$n-1$个城市的一个合法方案。下证它满足定理1的条件。

注意一个性质：如果$(i,j)$在$s$中被分开，在$w$中一定被分开，因为$w$只有$j$处比$s$小1，其它值都相同。利用该性质，对于策略$w$，任何不包含$j$的二元组必然满足定理1的条件；我们只需考虑包含$j$的二元组是否满足定理1条件即可。

对于定理1（1）：

a)：若$(i,j)$满足$w_i=w_j=0$或$w_i<w_j$，必有$s_i<s_j$，由于$s$满足定理1（1）故$p_i>p_j$；

b)：若$(j,i)$满足$w_j=w_i=0$或$w_j<w_i$，那么$s_i=w_i \ge 0$，由于$j$是$k$之后$s$非负的价格最高者，故$p_j>p_i$。

对于定理1（2）：

a)：若$(i,j)$满足$w_i>w_j$或$w_i=w_j=0$，且$p_i>p_j$，那么$s_i=w_i \ge 0$，由于$j$是$k$之后$s$非负的价格最高者，故必有$i \le k$，故$(i,j)$被$s$分开；

b)：若$(j,i)$满足$w_j>w_i$或$w_i=w_j=0$，且$p_j>p_i$，那么$s_j>s_i$，由定理1（2）$(j,i)$在$s$策略中被分开，这与$k$是最大的$h_s(k)=0$的城市矛盾，不会有这种情况。

综上，$w$是满足定理1的策略，由归纳知必然是贪心算法前$n-1$个城市的执行结果。最后考虑算法在第$n$个城市的操作。

首先必有$p_j<p_n$，若不然由$s_j \ge 0 >-1=s_n$但$(j,n)$并未在$s$中被分开可导出和定理1（2）的矛盾。而$w_j \le 0$，故算法必然会在$n$城市卖出（因为可以在$j$买入且能增大利润），下面只需考虑是不是一定买入$j$城市。设算法买入的城市为$t$，且$p_j>p_t$，那么$s_t \le 0$而$s_j \ge 0$，那么$t$不能在$j$之前（否则与定理1（1）矛盾）。同样$t$也不能在$j$之后（否则由定理1（2）$(j,t)$被$s$分开，与$k$是最大的$h_s(k)=0$的城市矛盾），因此买入的城市$t=j$。因此满足定理1的策略确实完全由贪心算法给出。证毕。

定理3

满足定理1的策略是唯一的，从而贪心算法正确。

证明：由于定理1的策略必由贪心算法给出，而贪心算法给出的策略只有一个，故满足定理1的策略是唯一的。又由定理1，最优策略满足定理1，故算法是正确的。

最小化交易次数

根据上面定理，当价格互不相同时最优策略是唯一的，但价格可以相同时则不一定，此时才存在最小化交易次数的问题。此时考虑修改算法，当优先队列中最低价格不止一个时，优先取原本卖出物品的城市，这样该城市的状态会被修改成什么都不做。这个正确性很显然。对于价格相同的物品，它们对于后续城市是完全等价的，因此尽可能的将它们变成不买也不卖必然达到最小交易次数。

综上，这道题目就完全解决了。

参考代码

 #include<cstdio>
 #include<queue>
 using namespace std;
 int p[];
 struct Node{
     int i;
     bool sell;
     bool operator < (const Node t)const{
         return p[i] != p[t.i] ? p[i] > p[t.i] : !sell && t.sell;
     }
 };
 int main()
 {
     int test, n;
     scanf("%d", &test);
     while (test--){
         priority_queue<Node> q;
         scanf("%d", &n);
         for (int i = ; i < n; i++)
             scanf("%d", &p[i]);
         long long ans = ;
         int cnt = ;
         q.push({ ,  });
         for (int i = ; i < n; i++){
             int j = q.top().i;
             if (p[j] < p[i]){
                 bool sell = q.top().sell;
                 q.pop();
                 ans += p[i] - p[j];
                 if (sell)q.push(Node{ j,  });
                 else cnt += ;
                 q.push(Node{ i,  });
             }
             else q.push(Node{ i,  });
         }
         printf("%lld %d\n", ans, cnt);
     }
 }