【BZOJ】[JLOI2011]飞行路线（分层最短路裸题）

Description

Alice和Bob现在要乘飞机旅行，他们选择了一家相对便宜的航空公司。该航空公司一共在n个城市设有业务，设这些城市分别标记为0到n-1，一共有m种航线，每种航线连接两个城市，并且航线有一定的价格。Alice和Bob现在要从一个城市沿着航线到达另一个城市，途中可以进行转机。航空公司对他们这次旅行也推出优惠，他们可以免费在最多k种航线上搭乘飞机。那么Alice和Bob这次出行最少花费多少？

Input

数据的第一行有三个整数，n,m,k，分别表示城市数，航线数和免费乘坐次数。

第二行有两个整数，s,t，分别表示他们出行的起点城市编号和终点城市编号。(0<=s,t<n)

接下来有m行，每行三个整数，a,b,c，表示存在一种航线，能从城市a到达城市b，或从城市b到达城市a，价格为c。(0<=a,b<n,a与b不相等，0<=c<=1000)

 

Output

 

只有一行，包含一个整数，为最少花费。

Sample Input

5 6 1
0 4
0 1 5
1 2 5
2 3 5
3 4 5
2 3 3
0 2 100

Sample Output

8

HINT

 

对于30%的数据,2<=n<=50,1<=m<=300,k=0;

 

对于50%的数据,2<=n<=600,1<=m<=6000,0<=k<=1;

 

对于100%的数据,2<=n<=10000,1<=m<=50000,0<=k<=10.

 

有关分层图的第一个题目：求分层的最短路

图片上就是这个题的给出样例，没有画完的，不然太乱了，

第一时间想到了最短路的一系列算法，但是碍于有K条路可以给我门免费试用，K条路的处置方法不确定，于是想到了分层，

分层图的话像上面的图，个人认为分层开了以后就是每一个点对于其相邻的点都加上一条长度为0的边，这个题目的话样例上给的是K=1的所以就有额外的一层平行的图，原来的图G1和新添加的图G2之间的关系就是：每一个点对于其在G1上的相邻的点我们都可以画上一条路一条权值为0的路，这也就是各个层之间的关系了了吧。

关于求解这个问题，还是要用到了最短路dijstra的思想，不过肯定要在其上增加一些东西，

比如： dist[maxn] => dist[ X ][K]  表示路途中使用了K次免费道路时的从起点到X点的最短路

            vis[maxn] =>  vis[ X ][K]   表示使用了K次免费道路时到达X点这个状态是不是发生过了，

还有就是我们在维护dist数组时也有些不一样的

• 不使用免费道路时 到达u点到v点的更新：

        dist[u][K]=min([dist[v][K] , dist[v][K]+Duv)

• 使用免费道路时 到达u到v点的更新

       dist[u][k]=min( dist[u][k] , dist[v][k+1] )

其中还包括一些条件的判断，详情就看代码吧，

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
const int maxn=1e5+10;
const int maxm=5e5+10;
const int inf=0x3f3f3f3f;

struct HeapNode
{
    int u,d,k;
    HeapNode(){}
    HeapNode(int a,int b,int c):u(a),d(b),k(c){}
    bool operator <(const HeapNode &ags)const
    {
        return d>ags.d;
    }
};
struct Edge
{
    int from,to,dist;
    Edge(){}
    Edge(int x,int y,int z):from(x),to(y),dist(z){}
};
struct Dijkstra
{
    int n,m,k;            
    vector<Edge> edges; 
    vector<int> G[maxn];
    bool vis[maxn][50+10];    
    int dist[maxn][50+10];

    void init(int n,int k)
    {
        this->n=n;
        this->k=k;
        for(int i=1;i<=n;i++) G[i].clear();
        edges.clear();  
    }

    void AddEdge(int from,int to,int dist)
    {
        edges.push_back(Edge(from,to,dist) );
        m = edges.size();
        G[from].push_back(m-1);
    }

    void dijkstra(int st)
    {
        priority_queue<HeapNode> Q;
        for(int i=1;i<=n;i++)
            for(int j=0;j<=k;j++)
                dist[i][j]=inf,vis[i][j]=0;
        dist[st][0]=0;
        Q.push(HeapNode(st,0,0));

        while(!Q.empty())
        {
            HeapNode node=Q.top(); Q.pop();
            if(vis[node.u][node.k]) continue;
            vis[node.u][node.k]=1;
            for(int i=0;i<G[node.u].size();i++)
            {
                int v=G[node.u][i];
                int to=edges[v].to;
                int d=edges[v].dist;

                if(!vis[to][node.k]&&dist[node.u][node.k]+d<dist[to][node.k])
                {
                    dist[to][node.k]=dist[node.u][node.k]+d;
                    Q.push(HeapNode(to, dist[to][node.k] , node.k));
                }

                if(node.k<k &&!vis[to][node.k+1]&&dist[node.u][node.k]<dist[to][node.k+1])
                {
                    dist[to][node.k+1]=dist[node.u][node.k];
                    Q.push(HeapNode(to,dist[to][node.k+1],node.k+1));
                }
            }
        }
    }
}DJ;
int main()
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    DJ.init(n,k);
    int st,en;
    scanf("%d%d",&st,&en);
    st++,en++;
    for(int i=1;i<=m;i++)
    {
        int u,v,dist;
        scanf("%d%d%d",&u,&v,&dist);
        u++,v++;
        DJ.AddEdge(u,v,dist);
        DJ.AddEdge(v,u,dist);
    }
    DJ.dijkstra(st);

    int ans=inf;
    for(int i=0;i<=k;i++)
        ans=min(ans,DJ.dist[en][i]);
    printf("%d\n",ans);
}