Highway Project(双条件最短路+最小生成树的感觉，SPFA，外加一个Dijkstra优先队列)

题目链接：ZOJ - 3946

题意：t组输入，n个城市，m条边(1 ≤ N, M ≤ 10⁵)，城市有一个首都，编号为0。然后给你m条边，让你建公路，要求花费时间最小，时间相等花费最小。要求输出从0到其他点的总时间和建造公路的总花费。每条路的时间和花费都是1e5的范围。

思路：一看是双条件最短路就直接敲了，但是裸双条件的话会出现一个问题，我们会把一些边重复算。所以就有点像最小生成树了QAQ…

/*
Sample Input
2
4 5
0 3 1 1
0 1 1 1
0 2 10 10
2 1 1 1
2 3 1 2
4 5
0 3 1 1
0 1 1 1
0 2 10 10
2 1 2 1
2 3 1 2
Sample Output
4 3
4 4
*/

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;

const int N = 100010;
typedef long long ll;

struct node
{
    int to,next,w,p;
} s[10*N];//因为存的是边，所以开10倍，不然会爆栈

int vis[N];
ll dis[N];//时间
ll cost[N];//花费，指的是需要再花多少钱来达到这个点，这样就避免了重复算的问题
int head[N];//下面SPFA更新时候的比较方式也会变
int n,tot;

void spfa(int st)
{
    memset(vis,0,sizeof(vis));
    memset(dis,inf,sizeof(dis));
    memset(cost,inf,sizeof(cost));
    queue<int> q;
    q.push(st);
    vis[st] = 1;
    dis[st] = 0;
    cost[st] = 0;
    while(q.size())
    {
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for(int i = head[u]; i != -1; i = s[i].next)
        {
            int v = s[i].to;
            int w = s[i].w;
            int p = s[i].p;
            if((dis[v] > dis[u]+w) || (dis[v] == dis[u]+w && cost[v] > p))
            {
                dis[v] = dis[u]+w;
                cost[v] = p;
                if(!vis[v])
                {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}

void add(int u,int v,int w,int p)
{
    s[tot].to = v;
    s[tot].w = w;
    s[tot].p = p;
    s[tot].next = head[u];
    head[u] = tot++;
}

int main()
{
    ios::sync_with_stdio(false);
    int t,m,u,v,w,p;
    cin >> t;
    while(t--)
    {
        tot = 1;
        memset(head,-1,sizeof(head));
        cin >> n >> m;
        while(m--)
        {
            cin >> u >> v >> w >> p;
            add(u,v,w,p);
            add(v,u,w,p);
        }
        spfa(0);
        ll sum = 0,ans = 0;
        for(int i = 0; i < n; i++)
        {
            sum += dis[i];
            ans += cost[i];
        }
        cout << sum << ' ' << ans << endl;
    }
    return 0;
}

然后是优先队列的板子

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;

typedef long long ll;
const int N = 100010;

struct node
{
    ll to, w, p;
    bool operator < (const node &b) const
    {
        if(w != b.w) return w > b.w;
        else return p > b.p;
    }
} s[N];

int vis[N];
ll dis[N];
ll cost[N];
ll n;
vector<node> ve[N];

void spfa()
{
    priority_queue<node> q;
    memset(vis,0,sizeof(vis));
    memset(dis,inf,sizeof(dis));
    memset(cost,inf,sizeof(cost));
    q.push((node) {0, 0, 0});
    dis[0] = 0;
    cost[0] = 0;
    while(!q.empty())
    {
        node u = q.top();
        q.pop();
        ll ww = u.w;
        ll vv = u.to;
        if(vis[vv]) continue;
        vis[vv] = 1;
        int len = ve[vv].size();
        for(int i = 0; i < len; i++)
        {
            ll v = ve[vv][i].to;
            if(!vis[v])
            {
                ll w = ve[vv][i].w;
                ll p = ve[vv][i].p;
                if(dis[v] > ww + w ||(dis[v] == ww + w && cost[v] > p))
                {
                    dis[v] = ww + w;
                    cost[v] = p;
                    q.push((node) {v, dis[v], cost[v]});
                }
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    ll t,u,v,w,m,p;
    scanf("%lld",&t);
    while(t--)
    {
        scanf("%lld %lld",&n,&m);
        for(int i = 0;i < n; i++) ve[i].clear();
        while(m--)
        {
            scanf("%lld %lld %lld %lld",&u,&v,&w,&p);
            ve[u].push_back((node) { v, w, p});
            ve[v].push_back((node) { u, w, p});
        }
        spfa();
        ll sum = 0,ans = 0;
        for(int i = 0; i < n; i++)
        {
            sum += dis[i];
            ans += cost[i];
        }
        printf("%lld %lld\n",sum,ans);
    }
    return 0;
}