Heap:左式堆的应用例（任意序列变单调性最小价值）

　　　　　　　　　　　　　　首先来说一下什么是左式堆：

A：左式堆是专门用来解优先队列合并的麻烦（任意二叉堆的合并都必须重新合并，O（N）的时间）。

　　左式堆的性质：

　　1.定义零路经长：节点从没有两个两个儿子节点的路经长，把NULL定义为-1

　　2.堆性性质（x的键值比x左右两个儿子节点的键值要大或者要小）

　　3.堆中的每一个节点x，左儿子的零路经长至少与右儿子的零路经长一样长。

　　4.节点的距离等于右节点的距离+1.

　　引理：

　　　　若左式堆的距离定义为一定值，则节点数最少的左式堆是完全二叉堆。

　　定理：

　　　　若左式堆的距离为k，则这棵树最少有2^(k+1)-1个节点（由引理推出）

B：左式堆的特殊操作：（Merge）

　　左式堆一般以结构体定义，结构体要有3个区域：键值区，零路经长区，左右节点区

　　左式堆和二叉堆的其他操作都是类似的，但是其核心操作都是围绕Merge展开的。

　　Merge例程：

　　

LEFTIST_NODE *Merge1(LEFTIST_NODE *const s1, LEFTIST_NODE *const s2)//以最小堆为例
{
    if (s1->left == NULL) s1->left = s2;
    else
    {
        s1->right = Merge2(s1->right, s2);
        if (s1->left->zeroh < s1->right->zeroh)//如果违反零节点定理，我们交换节点
        {
            LEFTIST_NODE *tmp = s1->left;
            s1->left = s1->right; s1->right = tmp;
        }
        s1->zeroh = s1->right->zeroh + 1;//因为这个时候右节点的零节点路经长总是小于左节点的,零点路径长总是取最小的
    }
    return s1;
}

LEFTIST_NODE *Merge2(LEFTIST_NODE *const s1, LEFTIST_NODE *const s2)
{
    if (s1 == NULL) 
        return s2;
    else if (s2 == NULL) 
        return s1;
    else if (s1->elements < s2->elements)
        return Merge1(s1, s2);
    else//s1->elements < s2->elements
        return Merge1(s2, s1);
}

　　有了Merge，一切都变得很简单了

　　Insert操作：把Insert的值单独列为一个新的节点，然后Merge即可。

　　DeleteMin（Max）操作：把根节点的左右子堆合并，并且清除根节点。

C：左式堆的应用，数字序列（就是POJ 3666）

　　POJ 3666那题，可以用左式堆来做。（这一题只用求不下降序列）

　　那么怎么做呢？这一题可以这么思考：

　　我们把泥土划分为一个一个区间：比如[q[i]-q[i+1]-1]，[q[i+1],q[i+2]-2]....这样的话，每一个区间的最小价值，就是区间内的所有值改为该区间的中位数，每个区间的中位数是上升的，即可

　　不过这样说有点先入为主了，我们想一下这样做为什么对。

　　其实也用不着多严格的证明，我们可以这样看

　　　　  我们来看这样一个图，假设一个区间的数的分布就是这样的，其实这个价值点就是到任意蓝色轴的距离，那么这个区间所有点的最小值什么时候到最小？没错，就是到中点的时候。

　　把这个结论推广到全序列，那就是保证当每个区间的中位数是递增的，然后最小值就是对应区间的数变成对应中位数所需要的价值之和。

　　那么怎么编程呢？左式堆简直就是为这一题设的！

　　我们可以弄一个这样的堆，堆的最大值是这个区间的中位数，也就是堆只管理区间的一半（当然要另外开一个区域记录区间的实际大小）。

　　我们把每一个节点当做新的堆，如果序列是递增的，我们就把一个一个节点当做区间，并且不断压入栈，如果出现新入栈的节点的数值（也就是新的区间中位数，只有一个节点当然是节点的键值就是中位数了），那么我们就合并堆，直到合并到栈中的根的键值（中位数）是递增即可，同时，我们合并的时候，因为堆的信息只保留区间一半（包括中位数），也就是(len[k]+1)/2，如果出现新的堆和旧的堆合并，且(len[k]+1)/2+(len_new+1)/2>(len[k]+len_new+1)/2的时候（最多新的堆只会比要求大1），那么直接弹出堆的最大根，弹出后的堆根键值刚好就是符合条件的中位数。

　　参考：http://blog.csdn.net/iaccepted/article/details/6748038

　　　　　http://m.blog.csdn.net/blog/u013595779/44004041

　　代码：

　　

#include <iostream>
#include <functional>
#include <algorithm>
#define NullNode -1
#define MAX_N 2001

using namespace std;

typedef int Position;
typedef struct _leftistheap
{
    int value;
    Position left, right;
    int Npl;
}Left_Heap;
Position Merge1(Position, Position, Left_Heap *);
Position Merge2(Position, Position, Left_Heap *);

static int len[MAX_N];
static int road[MAX_N];
Position stack[MAX_N];//中点栈组
Left_Heap Increase_Set[MAX_N];

long long Search(const int, Left_Heap *);
void Swap(Left_Heap *, Position);

int main(void)//O(nlogn)处理3666
{
    int n;
    long long ans1;
    while (~scanf("%d", &n))
    {
        memset(Increase_Set, -1, sizeof(Increase_Set));
        for (int i = 0; i < n; i++)
        {
            scanf("%d", &road[i]);
            Increase_Set[i].value = road[i];
            Increase_Set[i].Npl = 0;
        }
        ans1 = Search(n, Increase_Set);
        printf("%lld
", ans1);
    }
    return 0;
}

Position Merge1(Position H1, Position H2, Left_Heap *Node_Set)
{
    if (H1 == NullNode)
        return H2;
    else if (H2 == NullNode)
        return H1;
    else if (Node_Set[H1].value >= Node_Set[H2].value)//注意符号！！！
        return Merge2(H1, H2, Node_Set);
    else 
        return Merge2(H2, H1, Node_Set);
}

Position Merge2(Position H1, Position H2, Left_Heap *Node_Set)
{
    if (Node_Set[H1].left == NullNode)
        Node_Set[H1].left = H2;
    else
    {
        Node_Set[H1].right = Merge1(Node_Set[H1].right, H2, Node_Set);
        if (Node_Set[Node_Set[H1].left].Npl < Node_Set[Node_Set[H1].right].Npl)
            Swap(Node_Set, H1);
        Node_Set[H1].Npl = Node_Set[Node_Set[H1].right].Npl + 1;//不能用pos2了，已经变了
    }
    return H1;
}

void Swap(Left_Heap *Node_Set, Position x)
{
    Node_Set[x].left ^= Node_Set[x].right;
    Node_Set[x].right ^= Node_Set[x].left;
    Node_Set[x].left ^= Node_Set[x].right;
}

long long Search(const int n, Left_Heap *Node_Set)
{
    memset(len, 0, sizeof(len));
    int top = 0, sum_node_tmp, pos, k;
    long long ans = 0;

    for (int i = 0; i < n; i++)
    {
        sum_node_tmp = 1; pos = i;
        while (top > 0 && Node_Set[stack[top - 1]].value > Node_Set[pos].value)
            //左式堆只储存左半树的信息，也就是以中位数为最大的最大堆
        {
            pos = Merge1(stack[top - 1], pos, Node_Set);//合并成一棵新的堆，现在新的堆的堆头就是新的区间中位数
            if ((len[top - 1] + 1) / 2 + (sum_node_tmp + 1) / 2 > (len[top - 1] + sum_node_tmp + 1) / 2)
                //如果比保留长度大（而且只会大1，则弹出最大节点）
                pos = Merge1(Node_Set[pos].left, Node_Set[pos].right, Node_Set);
            sum_node_tmp += len[--top];
        }
        len[top] = sum_node_tmp;
        stack[top++] = pos;
    }

    for (int i = 0, j = 0; i < top; i++)
    {
        k = Node_Set[stack[i]].value;
        while (len[i]--)
            ans += abs(road[j++] - k);
    }
    return ans;
}

　　这是0（nlogn）的算法，优化程度立竿见影