[关于最短路的一些小结]

Posted 2020-08-15

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了[关于最短路的一些小结]相关的知识，希望对你有一定的参考价值。

以前感觉Dijkstra没jb用今天做了几道题感觉到了一点用处首先他是在处理密集的图的时候比Spfa会快一点

时间是O(Nlogn)好像然后有一道题Spfa跑了一分钟Dijkstra 0.1s 忘了什么题

所以Dijksta还是有点用的

其实在这里只想讲一点Dijkstra小的优化而已并没有打算讲太多东西

1.用堆优化 sb都会写不会看白书(巫泽俊写的) P102-P103

2.其实这个优化不知道Spfa可不可以用好像也可以，像往常一样先给道例题 bzoj2200

技术分享

这道题有单向边有双向边然后双向边是可以构成很多个联通块单向边是连接联通块的单向边(无环)

直接草抱歉超时慢很多倍那么我们可不可以考虑一个个联通块草使得整个堆变小

这样的话我们先把双向边缩成联通块后整个图就变成了DAG

然后按照拓扑序将联通块一块块合并起来怎么说好呢不算是合并也就是一块块去做这个意思咯

对于单向边连的两块影响就一个点立即更新一下新联通块的点但是很有可能这两块有很多个单向边连起来

然后再去做新的联通块当然一开始有些联通块去不了的你照样放进跑就好反正也跑不了多少

但是有起点的联通块不一定入度不为0 所以的话有起点的联通块一定要从起点开始往外扫不能从连入这个联通块的点扫(没意义)

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
#define Maxn 26000
using namespace std;
struct node
{
  int x,y,d,next;
}edge[Maxn*10]; int len,first[Maxn];
void ins(int x,int y,int d)
{
  len++; edge[len].x=x; edge[len].y=y; edge[len].d=d; edge[len].next=first[x]; first[x]=len;
}
int N,R,P,ST;

priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > >Q;
queue<int>S;

int dis[Maxn];

int fa[Maxn]; int Find(int x){if(x==fa[x]) return fa[x]; else return fa[x]=Find(fa[x]);}
int Hash[Maxn]; int cnt;

int X[Maxn*2],Y[Maxn*2],D[Maxn*2];
vector<int>V[Maxn];
vector<int>BL[Maxn];

int ru[Maxn];
int main()
{
  freopen("roadplane.in","r",stdin);
  freopen("roadplane.out","w",stdout);
  scanf("%d%d%d%d",&N,&R,&P,&ST); len=0; memset(first,-1,sizeof(first));
  
  for(int i=1;i<=N;i++) fa[i]=i;
  for(int i=1;i<=R;i++)
  {
    int x,y,d; scanf("%d%d%d",&x,&y,&d); ins(x,y,d); ins(y,x,d);
    fa[Find(x)]=Find(y);
  }
  for(int i=1;i<=N;i++) if(fa[i]==i) Hash[i]=++cnt;
  for(int i=1;i<=N;i++) fa[i]=Find(fa[i]);
  
  for(int i=1;i<=P;i++)
  {
    scanf("%d%d%d",&X[i],&Y[i],&D[i]);
    V[Hash[fa[X[i]]]].push_back(i); ru[Hash[fa[Y[i]]]]++;
    
    BL[Hash[fa[Y[i]]]].push_back(Y[i]);
  }
  
  memset(dis,63,sizeof(dis)); dis[ST]=0; while(!S.empty()) S.pop();
  for(int i=1;i<=cnt;i++) if(ru[i]==0) S.push(i);
  for(int i=1;i<=N;i++) if(fa[i]==i&&ru[Hash[fa[i]]]==0) BL[Hash[fa[i]]].push_back(i); 
  BL[Hash[fa[ST]]].push_back(ST);
  while(!S.empty())
  {
    int now=S.front(); S.pop();
    for(int i=0;i<BL[now].size();i++)
    {
      int p=BL[now][i];
      Q.push(make_pair(dis[BL[now][i]],BL[now][i]));
    }
    while(!Q.empty())
    {
      pair<int,int> x=Q.top(); Q.pop();
      if(dis[x.second]<x.first) continue;
      for(int k=first[x.second];k!=-1;k=edge[k].next)
      {
        int y=edge[k].y;
        if(dis[y]>dis[x.second]+edge[k].d)
        {
          dis[y]=dis[x.second]+edge[k].d;
          Q.push(make_pair(dis[y],y));
        }
      }
    }
    
    for(int i=0;i<V[now].size();i++)
    {
      int p=V[now][i]; ru[Hash[fa[Y[V[now][i]]]]]--;
      
      if(ru[Hash[fa[Y[V[now][i]]]]]==0) S.push(Hash[fa[Y[V[now][i]]]]);

      dis[Y[V[now][i]]]=min(dis[Y[V[now][i]]],dis[X[V[now][i]]]+D[V[now][i]]);
    }
  }
  
  
  for(int i=1;i<=N;i++)
  {
    if(dis[i]<99999999) printf("%d\\n",dis[i]);
    else printf("NO PATH\\n");
  }
  return 0;
}
/*
6 3 3 4
1 2 5
3 4 5
5 6 10
3 5 -100
4 6 -100
1 3 -10
*/