Codeforces Round #257 (Div. 1) B. Jzzhu and Cities （记录最短路数量）

首先把K条特殊边处理一下，到同一个点的只保留最短的，其余都去掉并维护答案。这样形成一棵树。

然后再把这些边和m条普通边一起跑堆优化的dijkstra，并记录最短路数量。然后对于上一步剩下的每条特殊边，如果最短路长度小于它那一定可以去除，如果最短路长度等于它，就看最短路数量，如果等于1，说明就是这条特殊边，不能删，如果大于1说明有别的路，可以删。下面记录路径写的是简略版，因为本题只关心是不是大于1。

最短路如何记录数量：

DP的思想。对于每个点维护当前到该点最短路数量num[i]。

在从堆中取出一个点i

IF dis[i]+e[i][j]<dis[j]  :

num[j] = num[i]

else if dis[i]+e[i][j] == dis[j]:

num[j] += num[i]

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 100005
#include <vector>
#include <queue>
#define LL long long
const LL INF=1e15;


int len[maxn];
int num[maxn];
struct heapnode{
    LL d;
    int u;
    bool operator < (const heapnode & t) const{
        return d > t.d;
    }
    heapnode(){}
    heapnode(LL dd,int uu){
        d=dd;
        u=uu;
    }
};

struct Edge{
    int from,to;
    LL dist;
    Edge(){}
    Edge(int f,int t,LL d){
        from=f;
        to=t;
        dist=d;
    }
};

int N,M,K;
struct Dij{
    int n,m;
    vector<Edge>edges;
    vector<int> G[maxn];
    bool done[maxn];
    LL d[maxn];
    int p[maxn];

    void init(int n){
        this->n=n;
        for(int i=0;i<=n;i++){G[i].clear();}
        edges.clear();
        p[1]=-1;
    }

    void addedge(int from,int to,LL dist){
        edges.push_back(Edge(from,to,dist));
        m=edges.size();
        G[from].push_back(m-1);
    }

    void dij(int s){
        priority_queue<heapnode> Q;
        for(int i=0;i<=n;i++) d[i]=INF;
        d[s]=0;
        memset(done,0,sizeof(done));
        Q.push((heapnode(0,s)));
        while(!Q.empty()){
            heapnode x=Q.top();
            Q.pop();
            int u=x.u;
            if(done[u]) continue;
            done[u]=1;
            for(int i=0;i<G[u].size();i++){
                Edge &e=edges[G[u][i]];
                if(d[e.to]>d[u]+e.dist){
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    Q.push(heapnode(d[e.to],e.to));
                    num[e.to]=1;
                }
                else if(d[e.to]==d[u]+e.dist){
                    num[e.to]=2;
                }
            }
        }
    }
}solver;

int main(){
    scanf("%d%d%d",&N,&M,&K);
    solver.init(N);
    for(int i=0;i<M;i++){
        int x,y;
        LL d;
        scanf("%d%d%I64d",&x,&y,&d);
        solver.addedge(x,y,d);
        solver.addedge(y,x,d);
    }

    memset(len,-1,sizeof(len));
    int res=0;
    for(int i=0;i<K;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        if(len[x]==-1) len[x]=y;
        else{
            res++;
            len[x]=min(len[x],y);
        }
    }

    for(int i=1;i<=N;i++){
        if(len[i]!=-1) solver.addedge(1,i,len[i]);
    }

    solver.dij(1);

    for(int i=1;i<=N;i++){
        if(len[i]==-1) continue;
        if(solver.d[i]<len[i]) res++;
        else if(solver.d[i]==len[i]&&num[i]==2) res++;
    }
    printf("%d\n",res);
    return 0;
}