Node:最短路径之Dijkstra堆优化

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <stack>
#include <queue>

#define flush(arr,i) memset(arr,i,sizeof(arr))
#define INF 0xfffffff

using namespace std;
const int maxn=1010;
//到节点的距离和第i个节点的前一个节点
int dis[maxn], pre[maxn];
//边集
int cost[maxn][maxn];
//是否在集合之中
bool vis[maxn];

struct Node
{
    int nodeId;
    int len;
};

Node heap[maxn];

int n, m, s, sz;
/*
测试数据
---------
8 14 6
6 5 1
6 4 3
6 7 6
5 3 3
5 4 1
7 4 1
7 2 4
4 2 9
3 4 1
3 1 4
1 2 1
7 8 14
2 8 2
3 2 2
--------
*/
//数据录入和初始化
void initMap()
{
    //没有进入集合
    flush(vis, 0);

    sz = 0;
    scanf("%d%d%d", &n, &m, &s);

    int from, to, len;
    for(int i = 1; i <= n; i++)
    {
        dis[i] = INF;
        pre[i] = 0;
        for(int j = 1; j <= n; j++)
            cost[i][j] = INF;
    }

    for(int i = 0; i < m; i++)
    {
        scanf("%d%d%d",&from, &to, &len);
        printf("%c %c %d\n",from + 'r', to + 'r', len);
        cost[from][to] = cost[to][from] = len;
    }
}

//路径输出
void showPath(int cur)
{
    if(pre[cur])
        showPath(pre[cur]);
    printf("->%c", cur + 'r');
}

/*
//优化集中在这一部分
int getMinmunNode()
{
    int maxCost = INF, pos = -1;
    for(int i = 1; i <= n; i++)
        if(!vis[i] && dis[i] < maxCost)
        {
            pos = i;
            maxCost = dis[i];
        }
    //加入集合标记为1
    vis[pos] = 1;
    return pos;
}
*/
//--------------------------------------------------
//使用堆来进行优化:(用数组进行维护)堆从下标1开始

int getMinmNode()         //最小堆
{
    int ret = heap[1].nodeId;
    //，第一个节点删除，最后一个放到第一个位置，之后向下调整
    heap[1] = heap[sz--];

    int cur = 1, son = 2;
    //  存在儿子比父亲小
    while(son <= sz && (heap[son].len < heap[cur].len || heap[son+1].len < heap[cur].len))
    {
        if(heap[son].len > heap[son+1].len)
            son++;
        swap(heap[son].len,heap[cur].len);
        swap(heap[son].nodeId,heap[cur].nodeId);
        //指针下移
        cur = son;
        son*= 2;
    }
    return ret;
}

void deleteNode(int id)
{
    int pos = -1;
    for(int i = 0; i < sz; i++)
        if(heap[i].nodeId == id)
    {
        pos = i;
        break;
    }
    if(pos != -1)
    {
        for(int i = pos; i < sz - 1; i++)
            heap[i] = heap[i + 1];
        sz--;
    }
}

void insertNode(Node t)
{
    //添加到最后一个节点，向上调整
    heap[++sz] = t;
    int cur = sz, p = cur/2;
    while(p>=1)
    {
        //比父亲小的节点
        if(heap[cur].len < heap[p].len)
        {
            swap(heap[cur].len,heap[p].len);
            swap(heap[cur].nodeId,heap[p].nodeId);
        }
        cur = p;
        p = cur/2;
    }
}

//----------------------------------------------------
void Dijkstra(int s)
{
    dis[s] = 0;
    Node from;
    from.len = 0;
    from.nodeId = s;

    insertNode(from);
    //一共更新n次
    while(sz)
    {
        //获取当前的is最小节点进行下一步更新
        int cur = getMinmNode();
        //输出当前选出的节点
        printf("cur %c\n", cur + 'r');
        for(int j = 0; j <= n; j++)
            //满足更新条件
            if(dis[j] > dis[cur] + cost[cur][j])
        {
            dis[j] = dis[cur] + cost[cur][j];
            deleteNode(j);

            Node newNode;
            newNode.len = dis[j];
            newNode.nodeId = j;
            insertNode(newNode);

            //维护路径
            pre[j] = cur;
            //输出更新情况
            printf("%c->%c:%d ", s + 'r', j + 'r', dis[j]);
        }
        printf("\n");
    }
    for(int i = 1; i <= n; i++)
    {
        showPath(i);
        printf(" %d\n",dis[i]);
    }
}

int main()
{
    freopen("data.txt","r",stdin);
    initMap();
    Dijkstra(s);
    return 0;
}