Leetcode分类总结（Greedy）

贪心类题目目前除了正则匹配（Wildcard Matching）（据说其实是DP）那道还没做其他的免费题目都做了，简单做个总结。

贪心的奥义就是每一步都选择当前回合”可见范围“（即可得知的信息）内的最优，而在每一步都仅选择当前回合”可见范围“内的最优这一策略下能够导致全局最优的结果的情况使用贪心就会是正确的，否则不适用贪心（或不适用当前对贪心中的最优的定义）。

因此，贪心一个点是选择当前最优，另一个点是这个最优要怎么定义，比如是选使得A最小的还是选使得A-B或A/B最小的等等。

贪心的正确性其实都要通过归纳法或反证法等手段进行严格地证明，而这也是算法分析课程的一个重要讲授内容。

但对于Leetcode，看到tag是Greedy时可能还是撇开严格证明赶紧KO比较多o(￣▽￣)d。

比如：

Jump Game（https://leetcode.com/problems/jump-game/）

给定非负整数列表，从0位置起按照所在位置的p值往前跳p个位置，问是否能跳出列表长度。

从第0位置开始，我们p0个“下个位置“可以选，那么选哪个呢？贪心地选，从”下个位置“能得到的信息也就仅仅是”下个位置“后还能跳多远。

按照这个想法那么每次从i位置开始往前跳的这pi个选择里，最优选择j使得i+pj+p[i+pj]最大。

简单的证明就是，如果我通过j选择下一次能跳到最大的i+pj+p[i+pj]，而选择其他的k，从k再跳一次都到不了i+pj+p[i+pj]，那么显然从k要么永远跳不到i+pj+p[i+pj]，要么必须再经过一个中间点才能到i+pj+p[i+pj]，所以不如我一步到位跳到i+pj+p[i+pj]。

按照前面这个想法，显然每次照最优定义可以一步到位于是可以少跳一些，因此

Jump Game II（https://leetcode.com/problems/jump-game-ii/）

求跳出去的最小步数也就可以照着解了。

这里仅贴Jump Game II的代码：

#define min(a,b) ((a)<(b)?(a):(b))
int jump(int* nums, int numsSize) {
     int i,j;
     if(numsSize==)
     return ;
    int nowmax=-,nowmaxj;
    int count=,ans;
    i=;
    while(i<numsSize)
    {
        if(i==)
        {
            count=;
        }
        nowmax=i+nums[i];
        count++;
        nowmaxj=i;
        if(nowmax>=numsSize-)
                break;
        for(j=i+;j<=i+nums[i];j++)//贪心地每一次跳跃目标j都是到一个j+nums[j]更远的点作为跳跃目标
        {
            if(j+nums[j]>nowmax)
                {
                    nowmaxj=j;
                    nowmax=j+nums[j];
                }

        }
        i=nowmaxj;
    }

    return count;
}

Best Time to Buy and Sell Stock II(https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)

一个股价序列，不限制交易次数，只是不允许两次交易之间有重叠（在边界重叠则可以），要赚最多钱。

策略就是从第一个位置开始，遇到比持有低的i就换手（假装前面没买，现在买），遇到高的i就出手并买入新的。

分两种情况讨论：

①如果后面遇到比i高的j，这里按i卖的收益也不会丢，然后再按i入货，到后面高的j出货前后收益和在i不卖等到这时候j卖一样多。

②如果后面遇到比i低的j，那显然我先在i卖出去的肯定赚。

因此前面的策略成立。

代码：

int maxProfit(int* prices, int pricesSize) {
    if(pricesSize==||pricesSize==)
        return ;
    int nowmin=prices[];
    int ans=;
    int i;
    for(i=;i<pricesSize;i++)
    {
        if(prices[i]>nowmin)
        {
            ans+=prices[i]-nowmin;
            nowmin=prices[i];

        }
        else
            nowmin=prices[i];
    }
    return ans;
}

Candy和Gas Station

这两道是我觉得比较难的。。

先说Candy。

按照优先级序列分糖，高优先级的人要比它旁边的低优先级的人分得多，而每人最少一颗糖。

为了最少，所以从左往右如果优先级是递增那么分的糖果数就依次+1，当然，为了最少起始那个人肯定是1。

那么如果出现优先级下降的情况呢，贪心地分我先分他个1，待会再说。
当然，这么贪心地给1可能会有问题，比如我下一个更少，还给1就不满足要求了。

所以末了需要从右往左再扫一遍修正这个遗留问题以保证如果p[i]>p[i+1],那么最少candy[i]是candy[i+1]+1。注意这里是最少，因为可能在第一躺中，为了candy[i]满足规则candy[i]已经比candy[i+1]+1大了，那么这时候为了延续之前对规则的满足是不能改成candy[i+1]+1的。

代码：

#define max(a,b) ((a)>(b)?(a):(b))
int candy(int* ratings, int ratingsSize) {
    int i,j;
    int count=;
    int* candies=(int*)malloc(sizeof(int)*ratingsSize);
    //int candies[50]={0};
    for(i=;i<ratingsSize;i++)
    {
        if(i==)
            candies[i]=;
        else
        {
            if(ratings[i]>ratings[i-])//大的情况前面一个+1是显然的
                candies[i]=candies[i-]+;
            else if(ratings[i]<=ratings[i-])//小于等于的其实无法确定，需要再一遍来确定
                candies[i]=;

        }
    }
    for(i=ratingsSize-;i>=;i--)
    {
        if(ratings[i]>ratings[i+])
            candies[i]=max(candies[i],candies[i+]+);//从左往右得到的数只能再增不能减
    }

    for(i=;i<ratingsSize;i++)
        count+=candies[i];
    free(candies);
    return count;
}

我觉得最难的Gas Station来了。。

给两个序列，一个是i位置能补充多少汽油，一个是从i位置到i+1位置需要多少汽油。可以*选起点，问能不能转个圈，能的话告知起点位置。

我还是直接引用http://www.cnblogs.com/felixfang/p/3814463.html的解释吧：

假设从站点 i 出发，到达站点 k 之前，依然能保证油箱里油没见底儿，从k 出发后，见底儿了。那么就说明 diff[i] + diff[i+1] + ... + diff[k] < 0，而除掉diff[k]以外，从diff[i]开始的累加都是 >= 0的。也就是说diff[i] 也是 >= 0的，这个时候我们还有必要从站点 i + 1 尝试吗？仔细一想就知道：车要是从站点 i+1出发，到达站点k后，甚至还没到站点k，油箱就见底儿了，因为少加了站点 i 的油。。。

因此，当我们发现到达k 站点邮箱见底儿后，i 到 k 这些站点都不用作为出发点来试验了，肯定不满足条件，只需要从k+1站点尝试即可！因此解法时间复杂度从O(n2)降到了 O(2n)。之所以是O(2n)，是因为将k+1站作为始发站，车得绕圈开回k，来验证k+1是否满足。

等等，真的需要这样吗？

我们模拟一下过程：

a. 最开始，站点0是始发站，假设车开出站点p后，油箱空了，假设sum1 = diff[0] +diff[1] + ... + diff[p]，可知sum1 < 0；

b. 根据上面的论述，我们将p+1作为始发站，开出q站后，油箱又空了，设sum2 = diff[p+1] +diff[p+2] + ... + diff[q]，可知sum2 < 0。

c. 将q+1作为始发站，假设一直开到了未循环的最末站，油箱没见底儿，设sum3 = diff[q+1] +diff[q+2] + ... + diff[size-1]，可知sum3 >= 0。

要想知道车能否开回 q 站，其实就是在sum3 的基础上，依次加上 diff[0] 到 diff[q]，看看sum3在这个过程中是否会小于0。但是我们之前已经知道 diff[0] 到 diff[p-1] 这段路，油箱能一直保持非负，因此我们只要算算sum3 + sum1是否 <0，就知道能不能开到 p+1站了。如果能从p+1站开出，只要算算sum3 + sum1 + sum2 是否 < 0，就知都能不能开回q站了。

因为 sum1, sum2 都 < 0，因此如果 sum3 + sum1 + sum2 >=0 那么 sum3 + sum1 必然 >= 0，也就是说，只要sum3 + sum1 + sum2 >=0，车必然能开回q站。而sum3 + sum1 + sum2 其实就是 diff数组的总和 Total，遍历完所有元素已经算出来了。因此 Total 能否 >= 0，就是是否存在这样的站点的 充分必要条件。

这样时间复杂度进一步从O(2n)降到了 O(n)。

代码：

int canCompleteCircuit(int* gas, int gasSize, int* cost, int costSize) {
    int i,j,sta;

    int count=,sum=;
    for(i=;i<gasSize;i++)
    {
        count+=gas[i]-cost[i];
        if(sum<){
            sum=gas[i]-cost[i];
            sta=i;
        }
        else
        {
            sum+=gas[i]-cost[i];
        }
    }
    if(count<)
        return -;

    return sta;

}

总体而言，贪心就是在每次有多个策略可以选的情况下选当前最优的策略，而最优怎么定义以及要如何证明（比如分情况讨论等）就需要费脑了。。

最后，我哪天心情平稳再刷了正则匹配那道。。