hud2544dijkstra+堆优化

该算法对于稠密图更加有效：

对于给出具有非负权重的边和源顶点S的图G，算法可在O（mlogn）时间内找出从s点到其他每一个顶点的距离。

如果图是稠密的，即对于某个ε>0，m>=n^(1+ε），可以被改善在O（m/ε）内执行。（m为图的边数，n为图的定点数）

最小堆模板：

 jfdkjfks

 struct HeapElement {
     // key存储顶点序号，value存储到该顶点的最短距离
     int key, value;
 };
 struct MinHeap {
     HeapElement heap[MAXN];
     int position[MAXN];
     int size; // 顶点数
     void init() {
         heap[size=].value = -INF;
         memset(position, , sizeof(position));
     }
     void insert(int key, int value) {
         heap[++size].key = key;
         heap[size].value = value;
         position[key] = size;
         siftUp(size);
     }
     void decrease(int index) {
         int x = heap[index].value;
         int y = heap[size].value;
         -- size;
         if (index == size+)
             return;

         swap(heap[index], heap[size+]);
         if (y >= x) {
             siftDown(index);
         } else {
             siftUp(index);
         }
     }
     int delmin() {
         int x = heap[].key;
         decrease();
         return x;
     }
     void siftUp(int index) {
         while (index > ) {
             if (heap[index].value < heap[index/].value) {
                 swap(heap[index],heap[index/]);
             } else {
                 break;
             }
             index /= ;
         }
     }
     void siftDown(int index) {
         while (index* <= size) {
             index *= ;
             if (index < size && heap[index].value > heap[index+].value) {
                 ++ index;
             }
             if (heap[index].value < heap[index/].value) {
                 swap(heap[index],heap[index/]);
             } else {
                 break;
             }
         }
     }
     void makeHeap() {
         for (int i = size/; i > ; -- i)
             siftDown(i);
     }
     void swap(HeapElement &a, HeapElement &b) {
         HeapElement temp = a;
         a = b;
         b = temp;
         int tmp = position[a.key];
         position[a.key] = position[b.key];
         position[b.key] = tmp;
     }
 }H;

代码实现：（hdu2544）

#include <iostream>
#define INF 0x7FFFFFFF
using namespace std;

const int SIZE = 105;
int dist[SIZE];
int G[SIZE][SIZE];
bool vis[SIZE];
struct HeapElement {
    int key, value;
};
void swap(HeapElement &ha, HeapElement &hb) {
    int key = ha.key;
    int value = ha.value;
    ha.key = hb.key;
    ha.value = hb.value;
    hb.key = key;
    hb.value = value;
};
// 使用邻接表储存图，线性表储存堆
struct MinHeap {
    HeapElement heap[SIZE];
    int n;    // 顶点数    

    void makeheap() {
        for (int i = n/2; i > 0; -- i)
            siftDown(i);
    };
    void siftUp(int index) {
        int k = index;
        while (k > 1) {
            if (heap[k].value < heap[k/2].value) {
                swap(heap[k],heap[k/2]);
            } else {
                break;
            }
            k /= 2;
        }
    };
    void siftDown(int index) {
        int k = index;
        while (k*2 <= n) {
            k *= 2;
            if (k < n && heap[k].value > heap[k+1].value) {
                ++ k;
            }
            if (heap[k].value < heap[k/2].value) {
                swap(heap[k],heap[k/2]);
            } else {
                break;
            }
        }
    };
    void insert(HeapElement element) {
        heap[++n] = element;
        siftUp(n);
    };
    void decrease(int index) {
        int x = heap[index].value;
        int y = heap[n].value;
        n -= 1;

        // 若删除节点位于最末位置，则删除成功，无需其他操作。
        if (index == n+1)
            return;

        heap[index] = heap[n+1];
        if (y >= x) {
            siftDown(index);
        } else {
            siftUp(index);
        }
    };
    int decreaseMin() {
        int x = heap[1].key;
        decrease(1);
        return x;
    };
}H;

void dijkstra(int src, int n) {
    int i, j, w;
    bool flag;

    for (i = 1; i <= n; ++ i) {
        if (G[i][src] != INF) {
            dist[i] = G[src][i];
            HeapElement h = {i, dist[i]};
            H.insert(h);
        } else {
            dist[i] = INF;
        }
    }

    memset(vis, false, sizeof(vis));
    vis[src] = true;
    dist[src] = 0;

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

        int node = H.decreaseMin();
        vis[node] = true;

        for (w = 1; w <= n; ++ w) {
            flag = false;
            if (!vis[w] && G[node][w] != INF) {
                if (dist[node] < dist[w] - G[node][w]) {
                    dist[w] = dist[node] + G[node][w];

                }
                for (j = 1; j <= H.n; ++ j) {
                        if (H.heap[j].key == w) {
                            H.heap[j].value = dist[w];
                            flag = true;
                            break;
                        }
                    }    

                if (!flag) {
                    HeapElement h = {w, dist[w]};
                    H.insert(h);
                } else {
                    H.siftUp(j);
                }
            }
        }
    }
};

void init(int n) {
    for (int i = 1; i <= n; ++ i)
        for (int j = 1; j <= n; ++ j)
            G[i][j] = INF;
    H.n = 0;
};

int main()
{
    int N, M, a, b, c;

    //freopen("C:\\Users\\Smile\\test.txt","r",stdin);
    //freopen("C:\\Users\\Smile\\out.txt", "w", stdout);

    while (scanf("%d%d",&N,&M)!=EOF, N&&M) {
        init(N);

        for (int i = 0; i < M; ++ i) {
            scanf("%d%d%d",&a,&b,&c);
            if (G[a][b] > c) {
                G[a][b] = c;
                G[b][a] = c;
            }
        }

        dijkstra(1, N);

        printf("%d\n",dist[N]);
    }
}