蓄水（贪心+堆）

LCP 33. 蓄水 - 力扣（LeetCode）

 目录

运行结果

思路

# 倒水次数

# 操作次数

# 固定条件

# 降低最少倒水次数 min_nop

# 最大堆

C++代码，含注释

---

运行结果

思路

# 倒水次数

即一个桶向对应的缸内倒水至达到或超过最低蓄水量所需要的最少操作次数，即number of pourings，简记为nop，易知nop[i] = ceil((double) vat[i] / bucket[i] )

则每个bucket[i]均有一个对应的nop[i]，升级桶，使得++bucket[i]，可降低nop[i]，同时花费一次操作次数

# 操作次数

number of operations，简记为noo

操作次数 = 最少倒水次数 + 升级桶的次数，即：noo = min_nop + num_of_upgrades

我们所求的即为所有情况下noo的最小值，记为 Min_noo

# 固定条件

在所有bucket[i]均固定的条件下，所有的nop[i]也均为固定，所有nop[i]中的最大值，即为我们完成蓄水任务所需要的最少倒水次数 min_nop

# 降低最少倒水次数 min_nop

在固定条件下，我们可以通过升级那些nop[i] == min_nop的桶来降低min_nop，从而有可能降低总的操作次数.

不断升级那些nop[i]最大的桶，就有可能不断降低min_nop，进而不断减少总操作次数，从而求出最少操作次数.

# 最大堆

每次操作要取得nop[i]最大的那部分桶，我们需要利用最大堆来完成.

我们称每个桶和其对应的缸是一个“对”，最大堆中的每个元素是一个组，一个组要：

        1. 维护一个链表，链表中记录所有的nop相等的对的下标；

        2. 记录该组所有的对的共同的nop；

于是我们就可以直接根据每组的nop值来构建和维护最大堆.

C++代码，含注释

class Solution {
#define top 1 //记堆顶为top
    enum subject { Sec, Fir };
    typedef struct group {
        int nop;
        list<int> idx_list;
        group(int n, int i) {
            nop = n;
            idx_list = { i };
        }
    }*Group;
    typedef vector<Group> maxHeap;
    int scale_of_heap;
public:
    int storeWater(vector<int>& bucket, vector<int>& vat) {
        int N = bucket.size();
        scale_of_heap = N;
        vector<int> nop(N);
        int Min_noo = INT_MAX, num_of_upgrades = 0;

        /*处理桶或缸容量为0的情况，并计算初始情况下所有桶的最少倒水次数*/ {
            for (int i = 0; i != N; ++i) {
                if (vat[i] && !bucket[i]) {
                    ++bucket[i];
                    ++num_of_upgrades;
                }
                nop[i] = bucket[i] ? get_nop(vat[i], bucket[i]) : 0;
                if (!nop[i]) --scale_of_heap;
            }
            if (!scale_of_heap) return 0;
        }

        maxHeap xhp(scale_of_heap + 1);
        /*初始化最大堆*/ {
            int i = 1;
            for (int j = 0; j != N; ++j) if (nop[j]) xhp[i++] = new group(nop[j], j);
            for (int pos = scale_of_heap / 2; pos; --pos) sink(xhp, pos);
        }

        while (num_of_upgrades <= Min_noo) {
            int min_nop = xhp[top]->nop;

            int num_of_op = min_nop + num_of_upgrades;//操作次数 = 最少倒水次数 + 升级桶的次数
            num_of_op < Min_noo ? Min_noo = num_of_op : NULL;//取得最少操作次数

            if (min_nop == 1) break;//如果最小倒水次数已经是1次，那么就无法再通过升级桶来减少操作次数了

            /*升级top组中所有的的桶来降低最少倒水次数*/ {
                int new_min_nop = 0;
                for (int i : xhp[top]->idx_list) {
                    do {
                        ++bucket[i];
                        ++num_of_upgrades;
                        nop[i] = get_nop(vat[i], bucket[i]);
                    } while (nop[i] == min_nop);//反复升级直到降低该桶的最少倒水次数为止

                    nop[i] > new_min_nop ? new_min_nop = nop[i] : NULL;
                }

                xhp[top]->nop = new_min_nop;//取得组内所有的桶的倒水次数的最大值作为该组的最少倒水次数
            }

            /*把所有nop[i]不等于xhp[top]->nop的i移出top组*/ {
                list<int>::iterator Idx = xhp[top]->idx_list.begin();
                while (Idx != xhp[top]->idx_list.end()) {
                    if (nop[*Idx] != xhp[top]->nop) {
                        move(xhp, top, nop[*Idx], *Idx);  //先移出
                        list<int>::iterator tmp = Idx;
                        ++Idx;
                        xhp[top]->idx_list.erase(tmp);  //再删除
                    }
                    else ++Idx;
                }
            }
            
            sink(xhp, top); //最后调整好堆，进入下一轮循环
        }

        return Min_noo;
    }

    int get_nop(double vat_i, double bucket_i) {
        return ceil(vat_i / bucket_i);
    }
//以下为实现最大堆的函数，sink为堆的核心函数，堆的几乎所有操作都与这段代码有关
    void sink(maxHeap& xhp, int pos) {
        Group pebble = xhp[pos];
        int bubble;
        while ((bubble = pos * 2) <= scale_of_heap) {
            bubble != scale_of_heap && compare(xhp[bubble + 1], xhp[bubble], Sec) ?
                ++bubble : NULL;
            if (compare(pebble, xhp[bubble], Sec) || !xhp[bubble]->nop) break;
            xhp[pos] = xhp[bubble];
            pos = bubble;
        }
        xhp[pos] = pebble;
    }

    void move(maxHeap& xhp, int pos, int nop, int idx) {
        Group pebble = new group(nop, idx);
        int bubble;
        while ((bubble = pos * 2) <= scale_of_heap) {
            bubble != scale_of_heap && compare(xhp[bubble], xhp[bubble + 1], Fir) ?
                ++bubble : NULL;
            if (compare(pebble, xhp[bubble], Sec)) swap(pebble, xhp[bubble]);
            if (!xhp[bubble]->nop) break;
            pos = bubble;
        }
    }

    int compare(Group A, Group B, subject is_A_absorb_B) {
        if (A->nop > B->nop) return 1; //当A严格大于B时才返回1
        return A->nop == B->nop ?
            (is_A_absorb_B ? absorb(A, B) : absorb(B, A)) : 0;
    }
    //前者吞并后者
    int absorb(Group _front, Group _tail) {
        _front->idx_list.splice(_front->idx_list.end(), _tail->idx_list);
        _tail->nop = 0;
        return NULL;
    }
};