COGS——T 826. [Tyvj Feb11] GF打dota

http://www.cogs.pro/cogs/problem/problem.php?pid=826

★★☆   输入文件：dota.in   输出文件：dota.out   简单对比
时间限制：1 s   内存限制：128 MB

众所周知，GF同学喜欢打dota，而且打得非常好。今天GF和Spartan同学进行了一场大战。

现在GF拿到一张地图，地图上一共有n个地点，GF的英雄处于1号点，Spartan的基地位于n号点，

GF要尽快地选择较短的路线让他的英雄去虐掉Spartan的基地。但是Spartan早就料到了这一点，

他有可能会开挂(BS~)使用一种特别的魔法，一旦GF所走的路线的总长度等于最短路的总长度时，

GF的英雄就要和这种魔法纠缠不休。这时GF就不得不选择非最短的路线。现在请你替GF进行规划。

对于描述的解释与提醒：

1.无向路径，花费时间当然为非负值。

2.对于本题中非最短路线的定义：不管采取任何迂回、改道方式，

只要GF所走的路线总长度不等于1到n最短路的总长度时，就算做一条非最短的路线。

3.保证1~n有路可走。

输入：

第一行为n，m(表示一共有m条路径)
接下来m行，每行3个整数a，b，c，表示编号为a,b的点之间连着一条花费时间为c的无向路径。
接下来一行有一个整数p，p=0表示Spartan没有开挂使用这种魔法，p=1则表示使用了。

输出：

所花费的最短时间t，数据保证一定可以到达n。

样例输入1：
5 5
1 2 1
1 3 2
3 5 2
2 4 3
4 5 1
0

样例输入2：
5 5
1 2 1
1 3 2
3 5 2
2 4 3
4 5 1
1

 

样例输出1：

4

样例输出2：

5

对于50%的数据，1<=n,m<=5000
对于70%的数据，1<=n<=10000, 1<=m<=50000,p=0,
对于100%的数据，1<=n<=10000, 1<=m<=50000,p=1
无向图，花费时间c>=0

各个测试点1s

 

来源：lydliyudong    Tyvj February二月月赛第二场  第2道

最短路+次短路（练A*了、、）

 #include <cstdio>
 #include <queue>

 const int INF(0x3f3f3f3f);
 const int N();
 const int M();
 int hed[N],had[N],sumedge;
 struct Edge
 {
     int v,next,w;
 }edge1[M<<],edge2[M<<];
 inline void ins(int u,int v,int w)
 {
     edge1[++sumedge].v=v;
     edge1[sumedge].next=hed[u];
     edge1[sumedge].w=w;
     hed[u]=sumedge;
     edge2[sumedge].v=u;
     edge2[sumedge].next=had[v];
     edge2[sumedge].w=w;
     had[v]=sumedge;

     edge1[++sumedge].v=u;
     edge1[sumedge].next=hed[v];
     edge1[sumedge].w=w;
     hed[v]=sumedge;
     edge2[sumedge].v=v;
     edge2[sumedge].next=had[u];
     edge2[sumedge].w=w;
     had[u]=sumedge;
 }

 int dis[N];
 bool inq[N];
 inline void SPFA(register int s)
 {
     for(int i=;i<s;i++) dis[i]=INF;
     dis[s]=; inq[s]=;
     std::queue<int>que; que.push(s);
     for(int u,v;!que.empty();)
     {
         u=que.front(); que.pop(); inq[u]=;
         for(int i=had[u];i;i=edge2[i].next)
         {
             v=edge2[i].v;
             if(dis[v]>dis[u]+edge2[i].w)
             {
                 dis[v]=dis[u]+edge2[i].w;
                 if(!inq[v]) que.push(v),inq[v]=;
             }
         }
     }
 }

 struct Node
 {
     int now,g;
     bool operator < (Node a) const
     {
         return a.g+dis[a.now]<g+dis[now];
     }
 };
 inline int Astar(int s,int t,int k)
 {
     std::priority_queue<Node>que; Node u,v;
     u.now=s; u.g=; que.push(u); int cnt=;
     for(;!que.empty();)
     {
         u=que.top(); que.pop();
         if(u.now==t) cnt++;
         if(cnt==k) return u.g;
         for(int i=hed[u.now];i;i=edge1[i].next)
         {
             v.now=edge1[i].v;
             v.g=u.g+edge1[i].w;
             que.push(v);
         }
     }
 }

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(;ch>''||ch<'';) ch=getchar();
     for(;ch>=''&&ch<='';ch=getchar()) x=x*+ch-'';
 }
 inline void write(int x)
 {
     if(x/) write(x/);
     putchar(x%+'');
 }
 int AC()
 {
     freopen("dota.in","r",stdin);
     freopen("dota.out","w",stdout);
     int n,m,p; read(n),read(m);
     for(int u,v,w;m--;ins(u,v,w))
         read(u),read(v),read(w);
     read(p);       SPFA(n);
     write(Astar(,n,p+));
     return ;
 }

 int I_want_AC=AC();
 int main(){;}