Jzzhu and Cities( cf450D) 最短路

最初的思路：

先建最短路的有向图L（同时为无环图，根为1），然后把图L按以下赋值，

如果为铁路，赋值 1；否则赋值 0。

记录每个点两个值，

入边为铁路的数目sum，入边的是否只有铁路mm（当全是铁路时，显然要留下一条铁路，当有公路时，当然铁路一条都不能留）。

这样，对于每一个点所连的铁路的最多能去掉的个数就等于sum-mm，

此时从根开始深搜，计算sum和mm。

然而，t（dijkstra+堆），t（spfa+queue） , t（spfa+stack） , t (spfa+堆)。。。。 （希望有一天某位大神能指出Orz）

另一种思路

对于每一个建了铁路的点u，如果只有这条铁路是最短的，保留；如果源点到u有比它短的路，舍弃；如果源点有到u一样短的公路，舍弃；如果源点到u同时有几条一样最短的铁路，且没有一样短的公路，仅保留一条铁路。

然后（spfa+queue T，dijkstra+堆 AC)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
#include <vector>
#include <cstring>
#include <queue>
#define msc(X) memset(X,-1,sizeof(X))
#define ms(X) memset(X,0,sizeof(X))
typedef long long LL;
using namespace std;

const int MAXN=1e5+5;
const int MAXM=8e5+6;
const LL INF=1ll<<60;

struct _Edge
{
int v,next;
LL y;
bool operator <(const struct _Edge &b)const{
return y>b.y;
}
}edge[MAXM];
int hd[MAXN],tot;
void addedge(int u,int v,int x)
{
edge[tot].v=v;
edge[tot].y=x;
edge[tot].next=hd[u];
hd[u]=tot++;
}

bool vis[MAXN];
bool cs[MAXN];
LL dist[MAXN];
priority_queue<struct _Edge> que;
struct _Edge tmp;
void dijkstra(int n,int st)
{
ms(vis);
dist[st]=0;
tmp.v=st,tmp.y=0;
que.push(tmp);
while(!que.empty()){
tmp=que.top();
que.pop();
int u=tmp.v;
if(vis[u]) continue;
vis[u]=true;
for(int i=hd[u];i!=-1;i=edge[i].next)
{
int v=edge[i].v,y=edge[i].y;
if(cs[v]&&dist[v]>=dist[u]+y) cs[v]=false;
if(!vis[v]&&dist[v]>dist[u]+y){
dist[v]=tmp.y=dist[u]+y;
tmp.v=v;
que.push(tmp);
}
}
}
}

int main(int argc, char const *argv[])
{
int n,m,k;
scanf("%d%d%d",&n,&m,&k);
tot=0;
msc(hd);
for(int i=0;i<m;i++)
{
int u,v,x;
scanf("%d%d%d",&u,&v,&x);
addedge(u,v,x);
addedge(v,u,x);
}
for(int i=1;i<=n;i++)
dist[i]=INF;
for(int i=0;i<k;i++)
{
int v,x;
scanf("%d%d",&v,&x);
dist[v]=min(dist[v],(LL)x);
tmp.v=v,tmp.y=dist[v];
que.push(tmp);
cs[v]=true;
}
dijkstra(n,1);
for(int i=2;i<=n;i++) k-=cs[i];
printf("%d\n",k);
return 0;
}