优先队列：二叉堆优化的Prim与Dijkstra算法

终于调出来了，理解之后其实很简单，但是一些细节总是没处理好。直到现在还有一点疑问在。

两者的渐进复杂度都是O（ELogV+VLogV），因为边调整了E次，删除最小元V次，二叉堆的操作都是LogV级别的。

事实上两个算法很相似，Prim只是松弛操作和Dijksrra还有记录ans的方式不同。

在算法导论上看到，Kruskal算法是ELogE的即可以约成E*2LogV即ELogV,渐进意义上是和Prim一样的。

平时很少看见用heap优化的Prim和Dijkstra，可能是因为Kruskal和SPFA有更好的表现或编程复杂度小点吧，当然也看到不少C++用STL的优先队列写的Prim/Dijkstra。

下面是POJ 2387和1287的代码，分别对应Dijkstra和Prim算法。

/*

    很裸很水的最短路，练习二叉堆优化的Dijstra～



    之前二叉堆优化的Prim敲了好几遍前后花了不下八个小时调试还是没有调试成功，

    但是还好，熟悉了优先队列的操作。



    十几天后的今天重新想起这个，终于调出来了堆优化的Dijstra。理解之后还是蛮简单的。



    一些写法并不是最优的，例如heap的实现中可以减少交换元素等。但是有这个自己写的AC

    过的Dijkstra在，以后写二叉堆优化的Prim/Dijkstra和其它优先队列的题目就可以拿它对照着Debug了。



    2011-07-24 23:00

*/





#include <stdio.h>



#define MAXN 1200

#define MAXM 1200000

#define INF 19930317



struct node

{

    int d, v, p;

}heap[MAXN];

int pos[MAXN], hl;



int e[MAXM], cost[MAXM], next[MAXM], g[MAXN], size;



int m, n, s, t;



void insert(int u, int v, int w)

{

    e[++size] = v;

    next[size] = g[u];

    cost[size] = w;

    g[u] = size;

}





void swap(int a, int b)

{

    heap[0] = heap[a];

    heap[a] = heap[b];

    heap[b] = heap[0];

    pos[heap[a].v] = a;

    pos[heap[b].v] = b;

}



void heapfy()

{

    int i = 2;

    while (i <= hl)

    {

        if ((i < hl) && (heap[i + 1].d < heap[i].d))

            i++;

        if (heap[i].d < heap[i >> 1].d)

        {

            swap(i, i >> 1);

            i <<= 1;

        }

        else

            break;

    }

}







void decrease(int i)

{

    while ((i != 1) && (heap[i].d < heap[i >> 1].d))

    {

        swap(i, i >> 1);

        i >>= 1;

    }

}



void relax(int u ,int v, int w)

{

    if (w + heap[pos[u]].d < heap[pos[v]].d)

    {

        heap[pos[v]].p = u;

        heap[pos[v]].d = w + heap[pos[u]].d;

        decrease(pos[v]);

    }

}



void delete_min()

{

    swap(1, hl);

    hl--;

    heapfy();

}



void init()

{

    int u ,v ,w, i;



    scanf("%d%d", &m, &n);

    for (i = 1; i <= m; i++)

    {

        scanf("%d%d%d", &u, &v, &w);

        insert(u, v, w);

        insert(v, u, w);

    }

    s = 1;

    t = n;

}







int dijkstra()

{

    int u, p, i;



    for (i = 1; i <= n; i++)

    {

        heap[i].v = pos[i] = i;

        heap[i].d = INF;

    }

    heap[s].p = s;

    heap[s].d = 0;

    swap(1, s);

    hl = n;

    while (hl)

    {

        u = heap[1].v;

        delete_min();

        p = g[u];

        while (p)

        {

            if (pos[e[p]] <= hl)

                relax(u, e[p], cost[p]);

            p = next[p];

        }



    }

}

int main()

{

    init();

    dijkstra();

    printf("%d\n", heap[pos[t]].d);

    return 0;

}

 

 

 

/*

    二叉堆优化的Prim，相比Dijkstra只有松弛操作不同



    很郁闷的是heapfy函数，就是从堆顶往下筛，仿照别人的写法AC了，自己写的迭代以减少

    交换次数的在样例的一个数据陷入死循环了，而仿照数据结构与算法分析写的WA了。



    以前没写过带有pos作为优先队列的heap这样调整，所以也不知道哪错了。



    下面是强大的样例：

5 7

1 2 5

2 3 7

2 4 8

4 5 11

3 5 10

1 5 6

4 2 12

    有空调调吧。



    2011-07-25 09:32

*/







#include <stdio.h>



#define MAXN 1200

#define MAXM 120000

#define INF 19930317



int e[MAXM], cost[MAXM], next[MAXM], g[MAXN], size;



struct node

{

    int d, v;

}heap[MAXN];

int pos[MAXN], hl;



int m, n;





void swap(int a, int b)

{

    heap[0] = heap[a];

    heap[a] = heap[b];

    heap[b] = heap[0];

    pos[heap[a].v] = a;

    pos[heap[b].v] = b;

}





void heapfy()

{

    int i = 2;

    while (i <= hl)

    {

        if ((i < hl) && (heap[i + 1].d < heap[i].d))

            i++;

        if (heap[i].d < heap[i >> 1].d)

        {

            swap(i, i >> 1);

            i <<= 1;

        }

        else

            break;

    }

}







/*

void heapfy()

{

    int i = 1, j = 2;



    heap[0] = heap[1];

    while (j <= hl)

    {

        if ((j < hl) && (heap[j].d > heap[j+1].d))

            j++;

        if (heap[j].d < heap[0].d)

        {

            heap[i] = heap[j];

            pos[heap[i].v] = i;

            i = j;

            j >>= 1;

        }

        else

            break;

    }

    heap[i] = heap[0];

    pos[heap[i].v] = i;

}





void heapfy()

{

    int i, j;



    heap[0] = heap[1];

    for (i = 1; i * 2 <= hl; i = j)

    {

        j = i * 2;

        if (j < hl && heap[j+1].d < heap[j].d)

            j++;

        if (heap[0].d > heap[j].d)

        {

            heap[i] = heap[j];

            pos[heap[i].v] = i;

        }

    }

    heap[i] = heap[0];

    pos[heap[i].v] = i;

}

*/



void decrease(int i)

{

    heap[0] = heap[i];

    while ((i > 1) && (heap[0].d < heap[i >> 1].d))

    {

        heap[i] = heap[i >> 1];

        pos[heap[i].v] = i;

        i >>= 1;

    }

    heap[i] = heap[0];

    pos[heap[i].v] = i;

}













void delete_min()

{

    swap(1, hl);

    hl--;

    heapfy();

}









void relax(int v, int w)

{

    if (w < heap[pos[v]].d)

    {

        heap[pos[v]].d = w;

        decrease(pos[v]);

    }

}



void insert(int u, int v, int w)

{

    e[++size] = v;

    cost[size] = w;

    next[size] = g[u];

    g[u] = size;

}



void init()

{

    int i, u, v, w;



    size = 0;

    memset(g, 0, sizeof(g));

    for (i = 1; i <= m; i++)

    {

        scanf("%d%d%d", &u, &v, &w);

        insert(u, v, w);

        insert(v, u, w);

    }

}



int prim()

{

    int mst = 0, u , p, i;



    for (i = 1; i <= n; i++)

    {

        pos[i] = heap[i].v = i;

        heap[i].d = INF;

    }

    heap[1].d = 0;

    hl = n;

    while (hl)

    {

        u = heap[1].v;

        mst += heap[1].d;

        delete_min();

        for (p = g[u]; p; p = next[p])

            if (pos[e[p]] <= hl)

                relax(e[p], cost[p]);

    }

    return mst;

}



int main()

{

    while (scanf("%d%d", &n, &m) == 2 && n)

    {

        init();

        printf("%d\n", prim());

    }

}