[Dijkstra算法]--堆优化Dijkstra

题目来源：poj 1511

跟poj 3268 蛮像的

这个一直报错

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
const int maxn = 1000005;
const int INF = 0x3fffffff;
bool vis[maxn] = {false};
int N;
int dis[maxn];
int dis1[maxn];
typedef pair<int, int> pii;
priority_queue<pii> q; //大根堆优先队列(pair第一维为dist相反数(变成小根堆)，第二维为节点编号)

struct node
{
    int v;
    int weight;
};

vector<node> Adj[maxn];
vector<node> Adj1[maxn];

void Dijkstra(int dis[])
{
    while (q.size())
    {
        q.pop();
    }
    fill(vis, vis + maxn, false);
    dis[1] = 0;
    q.push(make_pair(0, 1));
    while (q.size())
    {
        int u = q.top().second;
        q.pop();
        if (vis[u])
        {
            continue;
        }
        vis[u] = true;
        int len = Adj[u].size();
        for (int i = 0; i < len; i++)
        {
            int v = Adj[u][i].v;
            if (vis[v] == false && dis[v] > dis[u] + Adj[u][i].weight)
            {
                dis[v] = dis[u] + Adj[u][i].weight;
                q.push(make_pair(-dis[v], v));
            }
        }
    }
}

int main()
{
    int T;
    cin >> T;
    while (T--)
    {
        int P;
        cin >> N >> P;
        fill(dis, dis + maxn, INF);
        fill(dis1, dis1 + maxn, INF);
        for (int i = 1; i <= N; i++)
        {
            Adj[i].clear();
            Adj1[i].clear();
        }
        for (int i = 1; i <= P; i++)
        {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            node temp;
            temp.v = v;
            temp.weight = w;
            Adj[u].push_back(temp);
            temp.v = u;
            Adj1[v].push_back(temp);
        }
        Dijkstra(dis);
        for (int i = 1; i <= N; i++)
        {
            Adj[i].clear();
            Adj[i] = Adj1[i];
        }
        Dijkstra(dis1);
        long long ans = 0;
        for (int i = 1; i <= N; i++)
        {
            ans += (dis[i] + dis1[i]);
        }
        cout << ans << endl;
    }
    return 0;
}

学长写的代码

#include <algorithm>
#include <cstdio>
#include <queue>

using namespace std;

const long long INF = 1e18;

const int M = 2000001;

struct Node
{
    int v, w, next;
    Node() {}
    Node(int v, int w, int next) : v(v), w(w), next(next) {}
};

vector<Node> nodes(M);
int top = 0;

vector<long long> dijkstra(const vector<int> &g, int src)
{
    int n = g.size();
    vector<long long> distance(n, INF);
    std::priority_queue<pair<long long, int>> q;
    vector<bool> done(n);
    q.push(make_pair(0, src));
    distance[src] = 0;
    while (!q.empty())
    {
        int u = q.top().second;
        q.pop();
        if (done[u])
        {
            continue;
        }
        done[u] = true;
        for (int i = g[u]; ~i; i = nodes[i].next)
        {
            int v = nodes[i].v, w = nodes[i].w;
            if (!done[v] && distance[u] + w < distance[v])
            {
                distance[v] = distance[u] + w;
                q.push(make_pair(-distance[v], v));
            }
        }
    }
    return distance;
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        top = 0;
        int n, m;
        scanf("%d%d", &n, &m);
        vector<int> g1(n + 1, -1), g2(n + 1, -1);
        while (m--)
        {
            int u, v, w ;
            scanf("%d%d%d", &u, &v, &w);
            nodes[top] = Node(v, w, g1[u]);
            g1[u] = top++;
            //printf("%d- %d\n", u, g1[u]);
            nodes[top] = Node(u, w, g2[v]);
            g2[v] = top++;
            //printf("%d- %d\n", v, g2[v]);
        }
        vector<long long> d1 = dijkstra(g1, 1), d2 = dijkstra(g2, 1);
        long long ans = 0;
        for (int i = 1; i <= n; i++)
        {
            ans += d1[i] + d2[i];
        }
        printf("%lld\n", ans);
    }
    return 0;
}