Codechef Bear and Clique Distances

题目：Bear and Clique Distances

描述：共有N个点，前1—K个点任意两点之间有一条无向边,边的权值为X，再任意给M条边（u，v，w）（不重复），求任意一点到其余各点的最短路。

分析：

1.最短路算法（usual Dijkstra）+一点小变形(a little twist)

2.trick：设置一个变量upd=1;因为前K个点之前两两是连通的，所以当第一次到前K个点中任一点（假设为u）时，就可以更新得到前K个点的距离（除了u）d[i](i<=k)为d[u]+X。

即：1-K中任意一点作为中间点更新1-K之间其他点的距离只用更新一次，因为最短路算法中每次队列取出来的点都是当前剩下点中距离源点最近的点，还有就是下次再更新到1-K点中的点时不用再继续更新与该点相连的1-K点的距离了

3.复杂度：O((m+k)log(V))

4.边的权值范围到达1e9，前面WA了几次，因为初始化inf=1e9+10;值太小了，有很多边，假如所有边大小都是1e9，则路径长度加起来远远大于初始化位1e9+10的inf。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<algorithm>
 #include<cmath>
 #include<vector>
 #include<queue>
 #include<map>

 using namespace std;
 #define maxn 100000+10
 #define inf 1e15+10  //该题中inf定义为1e9+10 太小，导致出错
 #define ll long long

 struct Edge{
     ll u,v,w;
     Edge(ll u=,ll v=,ll w=):u(u),v(v),w(w){}
 };

 struct Node{
     ll d,u;
     bool operator<(const Node& rhs)const{
         return d>rhs.d;
     }
 };

 Edge edges[maxn];
 vector<ll>G[maxn];
 ll N,M,X,K,S;
 bool vis[maxn];
 ll d[maxn];

 void Dijkstra()
 {
     bool flag=false;
     priority_queue<Node>Q;

     for(int i=;i<=N;i++) d[i]=inf;
     //memset(d,127,sizeof(d));
     memset(vis,,sizeof(vis));

     d[S]=;
     Q.push(Node{,S});
     while(!Q.empty())
     {
         Node x=Q.top();Q.pop();
         //cout<<x.d<<" "<<x.u<<endl;
         ll u=x.u;
         if(vis[u]) continue;
         vis[u]=true;
         if(u<=K && !flag)
         {
             flag=true;
             for(int i=;i<=K;i++)
             {
                 if(i!=u && d[i]>d[u]+X)
                 {
                     d[i]=d[u]+X;
                     Q.push(Node{d[i],i});
                 }
             }
         }
         //cout<<G[u].size()<<endl;
         for(int i=;i<G[u].size();i++)
         {
             ll id=G[u][i];
             //cout<<id<<endl;
             ll x1=edges[id].u,x2=edges[id].v,x3=edges[id].w;
             ll v=u==x1?x2:x1;
             if(d[v]>d[u]+x3)
             {
                 d[v]=d[u]+x3;
                 Q.push(Node{d[v],v});
             }
         }

     }

 }

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {

         scanf("%lld%lld%lld%lld%lld",&N,&K,&X,&M,&S);
         for(int i=;i<=N;i++) G[i].clear();
         for(int i=;i<M;i++)
         {
             ll a,b,c;
             scanf("%lld%lld%lld",&a,&b,&c);
             edges[i]=Edge(a,b,c);
             G[a].push_back(i);
             G[b].push_back(i);
         }
         //for(int i=1;i<=N;i++) cout<<G[i].size()<<" ";
         //cout<<endl;
         Dijkstra();

         for(int i=;i<=N;i++)
             printf("%lld%c",d[i],i==N?'\n':' ');
     }
     return ;
 }