分层图最短路模板（洛谷 P4822 [BJWC2012]冻结 ）

分层图最短路就是你可以选k条边，对这条边的费用进行操作后的最短路，所以每次操作就像下一层连一条单向边，这个边的权值是操作后的，这样操作后就只能去下一层，视作进行了一次操作

 

题目背景

“我要成为魔法少女！”

“那么，以灵魂为代价，你希望得到什么？”

“我要将有关魔法和奇迹的一切，封印于卡片之中„„”

在这个愿望被实现以后的世界里，人们享受着魔法卡片（SpellCard，又名符卡）带来的便捷。

现在，不需要立下契约也可以使用魔法了！你还不来试一试？

比如，我们在魔法百科全书（Encyclopedia of Spells）里用“freeze”作为关键字来查询，会有很多有趣的结果。

例如，我们熟知的 Cirno，她的冰冻魔法当然会有对应的 SpellCard 了。当然，更加令人惊讶的是，居然有冻结时间的魔法，Cirno 的冻青蛙比起这些来真是小巫见大巫了。

这说明之前的世界中有很多魔法少女曾许下控制时间的愿望，比如 Akemi Homura、Sakuya Izayoi、……

当然，在本题中我们并不是要来研究历史的，而是研究魔法的应用。

题目描述

我们考虑最简单的旅行问题吧： 现在这个大陆上有 NNN 个城市，MMM 条双向的道路。城市编号为 111 ~ NNN，我们在 111 号城市，需要到 NNN 号城市，怎样才能最快地到达呢？

这不就是最短路问题吗？我们都知道可以用 Dijkstra、Bellman-Ford、Floyd-Warshall等算法来解决。

现在，我们一共有 KKK 张可以使时间变慢 50%的 SpellCard，也就是说，在通过某条路径时，我们可以选择使用一张卡片，这样，我们通过这一条道路的时间 就可以减少到原先的一半。需要注意的是：

1. 在一条道路上最多只能使用一张 SpellCard。
2. 使用一张SpellCard 只在一条道路上起作用。
3. 你不必使用完所有的 SpellCard。

给定以上的信息，你的任务是：求出在可以使用这不超过 KKK 张时间减速的 SpellCard 之情形下，从城市 111 到城市 NNN 最少需要多长时间。

输入格式

第一行包含三个整数：NNN、MMM、KKK。

接下来 MMM 行，每行包含三个整数：AiA_iAi​、BiB_iBi​、TimeiTime_iTimei​，表示存在一条 AiA_iAi​ 与 BiB_iBi​ 之间的双向道路，在不使用 SpellCard 之前提下，通过它需要 TimeiTime_iTimei​ 的时间。

输出格式

输出一个整数，表示从 111 号城市到 NNN 号城市的最小用时。

输入输出样例

输入 #1

4 4 1 
1 2 4 
4 2 6 
1 3 8 
3 4 8 

输出 #1

7

说明/提示

样例 1 解释

在不使用 SpellCard 时，最短路为 1→2→41 \to 2 \to 41→2→4，总时间为 10。现在我们可以使用 1 次 SpellCard，那么我们将通过 2→42 \to 42→4 这条道路的时间减半，此时总时间为7。

数据规模与约定

对于 100%100\%100% 的数据，保证：

• 1≤K≤N≤501 \leq K \leq N \leq 501≤K≤N≤50，M≤103M \leq 10^3M≤103。
• 1≤Ai,Bi≤N1 \leq A_i,B_i \leq N1≤Ai​,Bi​≤N，2≤Timei≤2×1032 \leq Time_i \leq 2 \times 10^32≤Timei​≤2×103。
• 为保证答案为整数，保证所有的 TimeiTime_iTimei​ 均为偶数。
• 所有数据中的无向图保证无自环、重边，且是连通的。

  #include<stdio.h>
  #include<string.h>
  #include<string>
  #include<queue>
  using namespace std;
  #define ll long long
  #define maxn 60600
  struct node
  {
      ll id,w;
      friend bool operator <(node a,node b)
      {
          return a.w>b.w;
      }
  };
  priority_queue<node>q;
  ll dis[maxn];
  struct E
  {
      ll to,next,w;
  }e[maxn*10];
  ll head[maxn],cnt=0,vis[maxn];
  void add(ll u,ll v,ll w)
  {
      e[cnt].to=v;
      e[cnt].w=w;
      e[cnt].next=head[u];
      head[u]=cnt++;
  }
  void init()
  {
      memset(head,-1,sizeof(head));
      cnt=0;
  }
  void dijk(ll st)
  {
      q.push({st,0});
      memset(dis,0x3f,sizeof(dis));
      memset(vis,0,sizeof(vis));
      dis[st]=0;
      while(!q.empty())
      {
          ll u=q.top().id;
          q.pop();
          if(vis[u]==1) continue;
          vis[u]=1;
          //printf("dis[%lld]=%lld\n",u,dis[u]);
          for(ll i=head[u];i!=-1;i=e[i].next)
          {
              ll v=e[i].to,w=e[i].w;
              if(dis[u]+w<dis[v])
              {
                  //printf(" v=%lld w=%lld\n",v,w);
                  dis[v]=dis[u]+w;
                  if(vis[v]==0)
                  {
                      q.push({v,dis[v]});
                  }
              }
          }
      }
  }
  int main()
  {
      ll n,m,k;
      init();
      scanf("%lld %lld %lld",&n,&m,&k);
      for(ll i=1;i<=m;i++)
      {
          ll u,v,w;
          scanf("%lld %lld %lld",&u,&v,&w);
          for(ll j=1;j<=k+1;j++)
          {
              ll u1=(j-1)*n+u,v1=(j-1)*n+v,u2=j*n+u,v2=j*n+v;
              add(u1,v1,w);add(v1,u1,w);
              if(j<=k)
              {
                  add(u1,v2,w/2);add(v1,u2,w/2);
              }
          }
      }
      dijk(1);
      ll ans=0;
      for(ll i=0;i<=k;i++)
      {
          //printf("dis[%lld]=%lld\n",i,dis[i*n+n]);
          if(i==0) ans=dis[n];
          else ans=min(ans,dis[i*n+n]);
      }
      printf("%lld\n",ans);
  }