【最短路】分层图最短路

参考博客：

分层图最短路

分层图最短路--最通俗易懂的讲解

---

小说

题目描述

由于小X是一位奆老，奆老总是忙得一刻也停不下来。他刚刚准备完食物，小X童年的挚友小S和小Z来找他帮忙了……
小S和小Z十分喜欢看网络写手“25”的小说，但由于需要付费才能阅读，而小S和小Z的零花钱有非常少，他们只能找小X靠黑科技侵入给网站，把小说给他们。
然而小X又非常的爱慕虚荣，他要小S和小Z到自己家里来取小说。
小S、小Z和小X都居住在扬中市，扬中市共有n个小区，m条主干道（假设每条主干道都是双行线）。小S家住在1号小区，小X家住在n号小区。小S每经过一条主干道需要耗费z点体力，但由于小S的人脉非常广，每当他到达一个小区，他都会和好友攀谈直到体力回满。
由于小Z也希望能看到小说，所以他答应帮助小S k次，这k次小S经过主干道不需要耗费体力。
由于小S生性懒惰，他希望耗费最少的体力到达小X家，请问他最少耗费多少体力？
注意：如果小S到小X家可以一路上都由小Z背着，那么体力上限为0；
如果小S到不了小X家，小S会很伤心，体力上限为-1；

输入

第1行三个整数n,m,k，意思如题目描述。
第2到第n+1行是x,y,z指走连接x号小区和y号小区的主干道要耗费z点体力

输出

一行一个整数，表示小S最少耗费的体力。

样例输入

5 7 1
1 2 5
3 1 4
2 4 8
3 2 3
5 2 9
3 4 7
4 5 6

样例输出

4

提示

小S的行走路线：1->3->2->5，其中2->5这条主干道由小Z帮助小S通过。

对于30%的数据：n<=20;m<=100;
对于60%的数据：n<=100;m<=1000;
对于100%的数据：n<=1000;m<=10000;z<=1000000;

#include<bits/stdc++.h>
using namespace std;
const int N = 1005 ;
const int M = 10005;

/*          */

typedef struct Edge{
    int to , next , w ;
}Edge;

Edge e[M<<1] ;

int head[N],idx ;

void Add_edge( int u , int v ,int w ){
    e[idx] = Edge{ v , head[u] , w };
    head[u] = idx ++ ;
}

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0;
}

/*              */
typedef struct Node{
    int u , w ;
    Node ( int _u = 0 , int _w = 0 ){
        u = _u , w = _w ;
    }
    bool operator < ( const Node &rhs ) const {
        return w > rhs.w ;
    }
}Node;

int vis[N],dis[N];
int n,m,k;
bool Dijstra( int Len ){

    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0 ,sizeof vis );

    dis[1] = 0 ;

    priority_queue < Node > Q ;
    Q.push( Node(1,0) );

    int cnt = 0 ;
    while( !Q.empty() ){
        Node cur = Q.top();
        Q.pop();
        int u = cur.u , w = cur.w ;

        if( vis[u] ) continue ;
        vis[u] = 1 ;

        for( int i = head[u] ; ~i ; i = e[i].next ){
            int To = e[i].to  ;
            int w = e[i].w > Len ? 1 : 0 ;
            if( dis[To] > dis[u] + w ){
                dis[To] = dis[u] + w ;
                Q.push( Node(To,dis[To]) );
            }
        }
    }
    return dis[n] <= k ;
}
int main()
{
    Init();
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;
    cin >> n >> m >> k ;

    for( int i = 0,u,v,w; i < m ; i++ ){
        cin >> u >> v >> w ;
        Add_edge( u,v,w );
        Add_edge( v,u,w );
    }
    //cout << "### "<< endl;
    int L = 0 , R = 0x3f3f3f3f ;
    while( L < R ){
        int Mid = L + R >> 1 ;
        if( Dijstra( Mid ) ){
            R = Mid ;
        }else{
            L = Mid + 1 ;
        }
    }
    if( dis[n] > 1e6+10 ){
        printf("-1
");
    }else{
        printf("%d
",R);
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10 ;
const int M = 1e6+10;

/*          */

typedef struct Edge{
    int to , next , w ;
}Edge;

Edge e[M<<1] ;

int head[N],idx ;

void Add_edge( int u , int v ,int w ){
    e[idx] = Edge{ v , head[u] , w };
    head[u] = idx ++ ;
}

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0;
}

/*              */
typedef struct Node{
    int u , w ;
    Node ( int _u = 0 , int _w = 0 ){
        u = _u , w = _w ;
    }
    bool operator < ( const Node &rhs ) const {
        return w > rhs.w ;
    }
}Node;

int vis[N],dis[N];
int n,m,k;
void Dijstra(){

    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0 ,sizeof vis );

    dis[1] = 0 ;

    priority_queue < Node > Q ;
    Q.push( Node(1,0) );

    int cnt = 0 ;
    while( !Q.empty() ){
        Node cur = Q.top();
        Q.pop();
        int u = cur.u , w = cur.w ;
        if( vis[u] ) continue ;
        vis[u] = 1 ;
        for( int i = head[u] ; ~i ; i = e[i].next ){
            int To = e[i].to  ;
            int w = max( e[i].w , dis[u] );
            if( dis[To] > w ){
                dis[To] = w ;
                Q.push( Node( To,dis[To] ) );
            }
        }
    }
}
int main()
{
    Init();
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;
    cin >> n >> m >> k ;

    for( int i = 0,u,v,w; i < m ; i++ ){
        cin >> u >> v >> w ;
        for( int j = 0 ; j <= k ; j++ ){
            Add_edge( u + (j*n) , v + (j*n) , w );
            Add_edge( v + (j*n) , u + (j*n) , w );
            if( j != k ){
                Add_edge( u + (j*n) , v + (j+1)*n , 0 );
                Add_edge( v + (j*n) , u + (j+1)*n , 0 );
            }
        }
    }

    Dijstra();
    int ans = 0x3f3f3f3f ;
    ans = min( ans , dis[n + n*k] ) ;

    printf("%d
",ans==0x3f3f3f3f ? -1 : ans );
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3+10 ;
const int M = 1e5+10 ;
const int K = 1e3+10 ;

/*          */

typedef struct Edge{
    int to , next , w ;
}Edge;

Edge e[M<<1] ;

int head[N],idx ;

void Add_edge( int u , int v ,int w ){
    e[idx] = Edge{ v , head[u] , w };
    head[u] = idx ++ ;
}

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0;
}

/*              */
typedef struct Node{
    int u , w ;
    Node ( int _u = 0 , int _w = 0 ){
        u = _u , w = _w ;
    }
    bool operator < ( const Node &rhs ) const {
        return w > rhs.w ;
    }
}Node;


int n,m,k;
int vis[N][K],dis[N][K];
void Dijstra(){

    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0 ,sizeof vis );

    dis[0][0] = 0 ;

    priority_queue < Node > Q ;
    Q.push( Node(0,0) );

    while( !Q.empty() ){
        Node cur = Q.top();
        Q.pop();
        int c = cur.u / n ;
        int u = cur.u % n ;
        if( vis[u][c] ) continue ;
        vis[u][c] = 1 ;
        for( int i = head[u] ; ~i ; i = e[i].next ){
            int To = e[i].to  ;
            int w = max( e[i].w , dis[u][c] );
            if( dis[To][c] > w && !vis[To][c] ){
                dis[To][c] = w ;
                Q.push( Node( To + c * n , dis[To][c] ) );
            }
        }
        if( c < k ){
            for( int i = head[u] ; ~i ; i = e[i].next ){
                int To = e[i].to  ;
                int w =  dis[u][c] ;
                if( dis[To][c+1] > w && !vis[To][c+1] ){
                    dis[To][c+1] = w ;
                    Q.push( Node( To + (c+1) * n , dis[To][c+1] ) );
                }
            }
        }

    }
}
int main()
{
    Init();
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;
    cin >> n >> m >> k ;

    for( int i = 0,u,v,w; i < m ; i++ ){
        cin >> u >> v >> w ;
        u -- , v -- ;
        Add_edge( u , v , w );
        Add_edge( v , u , w );
    }

    Dijstra();
    int ans = 0x3f3f3f3f ;
    for( int i = 0 ; i <= k ; i++ ){
        ans = min( ans , dis[n-1][i] );
    }

    printf("%d
",ans==0x3f3f3f3f ? -1 : ans );
    return 0;
}

---

P4568 [JLOI2011]飞行路线

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+10;
const int M = 2e6+10;

typedef struct Edge{
    int to , next , w ;
}Edge;

Edge e[M<<1] ;
int head[N] , idx ;

void add_edge(int u , int v , int w ){
    e[idx] = Edge{ v , head[u] , w };
    head[u] = idx ++ ;
}
void Init(){
    memset( head , -1 , sizeof head );
    idx = 0 ;
}
int n , m , k ;
int S , T ;
int dis[N] , vis[N] ;

typedef struct Node{
    int u , w ;
    Node( int _u = 0 , int _w = 0 ){
        u = _u , w = _w ;
    }
    bool operator < ( const Node & rhs )const{
        return w > rhs.w ;
    }
}Node;

void Dijstra(int S){

    memset( vis , 0 , sizeof vis );
    memset( dis , 0x3f , sizeof dis );
    dis[S] = 0 ;

    priority_queue < Node > Q ;
    Q.push( Node(S,0) );

    while( !Q.empty() ){
        Node cur = Q.top();
        Q.pop() ;
        int u = cur.u ;
        if( vis[u] ) continue ;
        vis[u] = 1 ;

        for( int i = head[u] ; ~i ; i = e[i].next ){
            int To = e[i].to ;
            int w = e[i].w ;
            if( !vis[To] && dis[u] + w < dis[To] ){
                dis[To] = dis[u] + w ;
                Q.push( Node( To , dis[To] ) );
            }
        }
    }
}

int main()
{
    Init();
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;


    cin >> n >> m >> k ;
    cin >> S >> T ;

    for( int i = 0,u,v,w; i < m ; i++ ){
        cin >> u >> v >> w ;
        for( int j = 0 ; j <= k ; j ++ ){
            add_edge( u + j*n , v + j*n , w );
            add_edge( v + j*n , u + j*n , w );
            if( j != k ){
                add_edge( u + j*n , v + (j+1)*n , 0 ) ;
                add_edge( v + j*n , u + (j+1)*n , 0 ) ;
            }
        }
    }
    Dijstra(S);
    int ans = 0x3f3f3f3f ;
    for( int i = 0 ; i <= k ; i++ ){
        ans = min( ans , dis[ T+i*n ]);
    }
    cout << ans << endl ;
    return 0;
}

P3831 [SHOI2012]回家的路

#include<bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
const int M = 5e6 + 10;

typedef struct Edge{
    int to , next , w ;
}Edge;
Edge e[M<<1] ;

int head[N] , idx ;
void Add_edge( int u , int v , int w ){
    e[idx] = Edge{ v , head[u] , w };
    head[u] = idx ++ ;
}

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0 ;
}
typedef struct P{
    int x , y , No ;
}P;
P a[N] ;
bool cmp1(P u,P v){
    if( u.x == v.x ) return u.y < v.y ;
    return u.x < v.x ;
}
bool cmp2(P u,P v ){
    if( u.y == v.y ) return u.x < v.x ;
    return u.y < v.y ;
}

int n,m,S,T,k;
int dis[N],vis[N];

typedef struct Node{
    int u,w;
    Node ( int _u = 0 , int _w = 0 ):u(_u),w(_w){}
    bool operator < (const Node &rhs )const {
        return w > rhs.w ;
    }
}Node;
void Dijstra(int S){
    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0 , sizeof vis );

    dis[S] = 0 ;
    priority_queue < Node > Q;
    Q.push( Node(S,0) );


    while(!Q.empty() ){

        Node cur = Q.top();
        Q.pop();
        int u = cur.u;
        if( vis[u] ) continue ;
        vis[u] = 1 ;

        //printf("#### %d ### 
",u);

        for( int i = head[u] ; ~i ; i = e[i].next ){
            int To = e[i].to ;
            int w = e[i].w ;
            if( dis[To] > dis[u] + w ){
                dis[To] = dis[u] + w ;
                Q.push( Node(To,dis[To] ) );
            }
        }
    }
}


int main()
{
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;

    cin >> n >> m ;

    Init() ;
    S = m + 1 , T = m + 2 ;
    n = m + 2 ;

    for( int i = 1; i <= n ; i++ ){
        cin >> a[i].x >> a[i].y ;
        a[i].No = i ;
    }

    sort( a + 1 , a + 1 + n , cmp1 );
    for( int i = 1 ; i < n ; i ++ ){
        if( a[i].x == a[i+1].x ){
            Add_edge( a[i].No , a[i+1].No , 2 * (a[i+1].y-a[i].y) );
            Add_edge( a[i+1].No , a[i].No , 2 * (a[i+1].y-a[i].y) );
        }
    }

    sort( a + 1 , a + 1 + n , cmp2 );
    for( int i = 1 ; i < n ; i ++ ){
        if( a[i].y == a[i+1].y ){
            Add_edge( a[i].No+n , a[i+1].No+n , 2 * (a[i+1].x-a[i].x));
            Add_edge( a[i+1].No+n , a[i].No+n , 2 * (a[i+1].x-a[i].x) );
        }
    }

    for( int i = 1 ; i <= m ; i++ ){
        Add_edge( i , i+n , 1 );
        Add_edge( i+n , i , 1 );
    }
    Add_edge( S + n , S , 0 );
    Add_edge( S , S + n , 0 );
    Add_edge( T , T + n , 0 );
    Add_edge( T + n , T , 0 );

    Dijstra(S);
    printf("%d
",dis[T] == 0x3f3f3f3f ? -1 : dis[T] );
    return 0;
}

爱情之路

#include<bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
const int M = 5e6 + 10;

typedef struct Edge{
    int to , next , w , ch ;
}Edge;
Edge e[M<<1] ;

int head[N] , idx ;
void Add_edge( int u , int v , int w , int ch ){
    e[idx] = Edge{ v , head[u] , w , ch };
    head[u] = idx ++ ;
}

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0 ;
}
typedef struct P{
    int x , y , No ;
}P;
P a[N] ;

int n,m,S,T,k;
int dis[N][5],vis[N][5];
int cnt[N][5];

typedef struct Node{
    int u , w , id ;
    Node ( int _u = 0 , int _w = 0 ,int Id = 0 ):u(_u),w(_w),id(Id){}
    bool operator < (const Node &rhs )const {
        return w > rhs.w ;
    }
}Node;
void Dijstra(int S){
    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0 , sizeof vis );

    dis[S][0] = cnt[S][0] = 0 ;

    priority_queue < Node > Q;
    Q.push( Node(S,0,0) );

    while( !Q.empty() ){
        Node cur = Q.top();
        Q.pop();

        int u = cur.u , id = cur.id ;
        if( vis[u][id] ) continue ;
        vis[u][id] = 1 ;

        //printf("##### %d #### 
",u);
        for( int i = head[u] ; ~i ; i = e[i].next ){
            int To = e[i].to ;
            int ch = e[i].ch ;
            int w = e[i].w ;

            if( ch == id % 4 + 1 && dis[To][ch] > dis[u][id] + w ){
                dis[To][ch] = dis[u][id] + w ;
                cnt[To][ch] = dis[u][id] + 1 ;
                Q.push( Node( To , dis[To][ch] , ch ) ) ;
            }
        }
    }
}


int main()
{
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;

    cin >> n >> m ;

    Init() ;
    char ch[10];
    int Type ;
    for( int i = 1 , u , v , w ; i <= m ; i++ ){
        cin >> u >> v >> w >> ch ;
        switch( ch[0] ){
            case 'L' : Type = 1 ; break ;
            case 'O' : Type = 2 ; break ;
            case 'V' : Type = 3 ; break ;
            case 'E' : Type = 4 ; break ;
        }
        Add_edge( u , v , w , Type );
        Add_edge( v , u , w , Type );
    }
    Dijstra( 1 );
    if( dis[n][4] != 0x3f3f3f3f ){
        printf("%d %d
",dis[n][4] , cnt[n][4] >> 2 );
    }else{
        puts("HOLY SHIT!");
    }
    return 0;
}

POJ-1724 Road

#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int inf = 0x3f3f3f3f ;
const int N = 308 ;
const int M = 1e4+10;
int n , m , k , idx ;
int head[N] , ans ;
int vis[N][M];
int dis[N][M];

typedef struct Edge{
    int to , next , w, val ;
}Edge ;
Edge e[M<<1];

typedef struct Node{
    int u,w,val;
    Node( int _u = 0 , int _w = 0 , int v = 0 )
    :u(_u),w(_w),val(v){}

    bool operator < ( const Node &rhs ) const{
        return w > rhs.w ;
    }
}Node;

void Add_edge( int u , int v , int w , int val ){
    e[idx] = Edge { v , head[u] , w , val };
    head[u] = idx ++ ;
}
void Init(){
    memset( head , -1 , sizeof head );
    idx = 0 ;
}
void Dijstra(){
    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0 , sizeof vis );
    dis[1][k] = 0 ;
    priority_queue < Node > Q ;
    Q.push( Node(1,0,k) );
    while( !Q.empty() ){
        Node cur = Q.top();
        Q.pop();
        int u = cur.u ;
        int k = cur.val ;
        if( vis[u][k] ) continue ;
        vis[u][k] = 1 ;
        for( int i = head[u] ; ~i ; i = e[i].next ){
            int to = e[i].to ;
            int val = e[i].val ;
            int w = e[i].w ;

            if( k >= val ){
                if( dis[to][k-val] > dis[u][k] + w ){
                    dis[to][k-val] = dis[u][k] + w ;
                    Q.push( Node( to , dis[to][k-val] , k-val ) );
                }
            }
        }
    }
}

int main()
{
    Init();
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;
    cin >> k >> n >> m ;
    for( int i = 0,u,v,w,val ; i < m ; i++ ){
        cin >> u >> v >> w >> val ;
        Add_edge( u , v , w , val );
        //Add_edge( v , u , w , val );
    }
    Dijstra();
    ans = inf ;
    for( int i = 0 ; i <= k ; i++ )
        ans = min( ans , dis[n][i] );
    if( ans == inf )
        cout << -1 << endl ;
    else
        cout << ans << endl ;
    return 0;
}

P4822 [BJWC2012]冻结

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10;
const int M = 1e6+10;

typedef struct Edge{
    int to , next , w ;
}Edge ;
Edge e[M<<1] ;

typedef struct Node{
    int u , w ;
    Node( int _u = 0 , int _w = 0 ):u(_u),w(_w){}
    bool operator < ( const Node &rhs ) const {
        return w > rhs.w ;
    }
}Node;

int head[N] , idx ;
void Add_Edge( int u , int v , int w ){
    e[idx] = Edge{ v , head[u] , w };
    head[u] = idx ++ ;
}

int dis[N] , vis[N] ;
int n , m , k ;

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0 ;
}

void Dijstra(){
    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0 , sizeof vis );

    dis[1] = 0 ;
    priority_queue < Node > Q;
    Q.push( Node(1,0) ) ;
    while( !Q.empty() ){
        Node cur = Q.top() ;
        Q.pop() ;
        int u = cur.u ;
        if( vis[u] ) continue ;
        vis[u] = 1 ;

        for( int i = head[u] ; ~i ; i = e[i].next ){
            int To = e[i].to ;
            int w = e[i].w ;
            if( dis[To] > dis[u] + w ){
                dis[To] = dis[u] + w ;
                Q.push( Node( To, dis[To] ) );
            }
        }
    }
}

int main()
{
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;
    Init() ;
    cin >> n >> m >> k ;
    for( int i = 0 ,u,v,w ; i < m ; i++ ){
        cin >> u >> v >> w ;
        for( int j = 0 ; j <= k ; j++ ){
            Add_Edge( u + (j*n) , v + (j*n) , w );
            Add_Edge( v + (j*n) , u + (j*n) , w );
            if( j < k ){
                Add_Edge( u + j*n ,  v + (j+1)*n , w>>1 );
                Add_Edge( v + j*n ,  u + (j+1)*n , w>>1 );
            }
        }
    }
    Dijstra();
    int ans = 0x3f3f3f3f ;
    for( int i = 0 ; i <= k ; i++ ){
        ans = min( ans , dis[n+i*n] ) ;
    }
    cout << ans << endl ;
    return 0;
}

P2176 [USACO14FEB]路障Roadblock

#include<cstdio>
#include<cctype>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
const int N=1e5+10;
const int M = 255;
inline void read(int &x){
    int ans=0,f=1;
    char c=getchar();
    for(;!isdigit(c);c=getchar()){
        if(c=='-')
            f=-1;
    }
    for(;isdigit(c);c=getchar()){
        ans=ans*10+c-'0';
    }
    x=ans*f;
}
 
typedef struct Edge{
    int to,next,w;
}Edge;
 
Edge edge[N];
Edge e[N] ;
int cnt,head[M],dis[M];
int Cnt,Head[M],Dis[M];
int n,m;
 
void add_edge(int u,int v,int w){
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void Add_edge(int u,int v,int w){
    e[Cnt].to=v;
    e[Cnt].w=w;
    e[Cnt].next=Head[u];
    Head[u]=Cnt++;
}
 
typedef struct Cmp{
    bool operator () (const int &p1,const int &p2){
        return dis[p1]<dis[p2];
    }
}Cmp;
 
typedef struct cmp{
    bool operator () (const int &p1,const int &p2){
        return Dis[p1]<Dis[p2];
    }
}cmp;
 
int Dijstra(int k);
int dijstra(int k){
    memset(dis,0x3f,sizeof(dis));
    dis[k]=0;
    priority_queue< int ,vector<int> , Cmp > q;
    q.push(k);
 
    while(!q.empty()){
        int u=q.top();
        q.pop();
        for(int i=head[u];~i;i=edge[i].next){
            int v=edge[i].to;
            if(dis[v]>dis[u]+edge[i].w){
                dis[v]=dis[u]+edge[i].w;
                q.push(v);
            }
        }
    }
 
    //printf("%d
",dis[n]);
 
    int W = 0 ;
    for(int u=1;u<=n;u++){
        for(int i=head[u];~i;i=edge[i].next){
            if( dis[u] + edge[i].w == dis[edge[i].to] ){
                //printf(" %d , %d  = %d 
",u,edge[i].to,edge[i].w);
                Add_edge(u,edge[i].to,edge[i].w);
                //Add_edge(edge[i].to,u,edge[i].w);
                W = max ( W , edge[i].w );
            }
        }
    }
 
    for(int u=1;u<=n;u++){
        for(int i=head[u];~i;i=edge[i].next){
            if( dis[u] + edge[i].w != dis[edge[i].to] && dis[u] + edge[i].w - W <= dis[edge[i].to]){
                //printf(" %d , %d  = %d 
",u,edge[i].to,edge[i].w);
                Add_edge(u,edge[i].to,edge[i].w);
                //Add_edge(edge[i].to,u,edge[i].w);
            }
        }
    }
 
    int tmp = dis[n];
    int maxz = dis[n];
    for(int u=1;u<=n;u++){
        for(int i=Head[u];~i;i=e[i].next){
            //printf(" %d , %d  = %d 
",u,e[i].to,e[i].w);
            e[i].w = e[i].w * 2;
            //e[i^1].w = e[i^1].w * 2 ;
            maxz = max(Dijstra(1),maxz);
            e[i].w = e[i].w / 2;
            //e[i^1].w = e[i^1].w / 2 ;
        }
    }
    return maxz - tmp ;
 
}
int Dijstra(int k) {
    memset(Dis, 0x3f, sizeof(Dis));
    Dis[k] = 0;
    priority_queue<int, vector<int>, cmp> q;
    q.push(k);
    //printf("### %d
",Dis[0]);
    while (!q.empty()) {
        int u = q.top();
        q.pop();
        for (int i = Head[u]; ~i; i = e[i].next) {
            int v = e[i].to;
            if (Dis[v] > Dis[u] + e[i].w) {
                Dis[v] = Dis[u] + e[i].w;
                q.push(v);
                //printf(" Dis[%d] , %d
",v,Dis[v]);
            }
        }
    }
    //printf("### %d
",Dis[n]);
    return Dis[n];
}
int main()
{
    memset(Head,-1,sizeof(Head));
    memset(head,-1,sizeof(head));
    scanf("%d%d",&n,&m);
 
    for(int i=0,u,v,w;i<m;i++){
        read(u),read(v),read(w);
        add_edge(u,v,w);
        add_edge(v,u,w);
    }
    printf("%d
",dijstra(1));
 
    return 0;
}

P2939 [USACO09FEB]改造路Revamping Trails

#include<bits/stdc++.h>
using namespace std;
const int N = 4e6+10;
const int M = 4e6+10;

typedef struct Edge{
    int to , next , w ;
}Edge ;
Edge e[M<<1] ;

typedef struct Node{
    int u , w ;
    Node( int _u = 0 , int _w = 0 ):u(_u),w(_w){}
    bool operator < ( const Node &rhs ) const {
        return w > rhs.w ;
    }
}Node;

int head[N] , idx ;
void Add_Edge( int u , int v , int w ){
    e[idx] = Edge{ v , head[u] , w };
    head[u] = idx ++ ;
}

int dis[N] , vis[N] ;
int n , m , k ;

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0 ;
}

void Dijstra(){
    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0 , sizeof vis );

    dis[1] = 0 ;
    priority_queue < Node > Q;
    Q.push( Node(1,0) ) ;
    while( !Q.empty() ){
        Node cur = Q.top() ;
        Q.pop() ;
        int u = cur.u ;
        if( vis[u] ) continue ;
        vis[u] = 1 ;

        for( int i = head[u] ; ~i ; i = e[i].next ){
            int To = e[i].to ;
            int w = e[i].w ;
            if( dis[To] > dis[u] + w ){
                dis[To] = dis[u] + w ;
                Q.push( Node( To, dis[To] ) );
            }
        }
    }
}

int main()
{
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL) , cout.tie(NULL) ;
    Init() ;
    cin >> n >> m >> k ;
    for( int i = 0 ,u,v,w ; i < m ; i++ ){
        cin >> u >> v >> w ;
        for( int j = 0 ; j <= k ; j++ ){
            Add_Edge( u + (j*n) , v + (j*n) , w );
            Add_Edge( v + (j*n) , u + (j*n) , w );
            if( j < k ){
                Add_Edge( u + j*n ,  v + (j+1)*n , 0 );
                Add_Edge( v + j*n ,  u + (j+1)*n , 0 );
            }
        }
    }
    Dijstra();
    int ans = 0x3f3f3f3f ;
    for( int i = 0 ; i <= k ; i++ ){
        ans = min( ans , dis[n+i*n] ) ;
    }
    cout << ans << endl ;
    return 0;
}

南京网络赛 Magical Girl Haze

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 3200010;
const int M = 5400000;
int n,m,k;
typedef struct Edge{
    int to , next ;
    ll w ;
}Edge;
Edge e[M];

typedef struct Node{
    int u ;
    ll w ;
    Node ( int _u = 0 , ll _w = 0 ):u(_u),w(_w){}
    bool operator < ( const Node & rhs ) const {
        return w > rhs.w ;
    }
}Node;

int head[N],idx;
void Add_edge( int u, int v ,ll w ){
    e[idx] = Edge { v , head[u] , w };
    head[u] = idx ++ ;
}

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0 ;
}

ll dis[N];
bool vis[N];

void Dijstra(){
    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0  , sizeof vis );

    dis[1] = 0 ;
    priority_queue<Node> Q;
    Q.push( Node(1,0) );

    while( !Q.empty() ){
        Node cur = Q.top();
        Q.pop();
        int u = cur.u ;
        if( vis[u] ) continue ;
        vis[u] = 1 ;

        for( int i = head[u] ; ~i ; i = e[i].next ){
            int to = e[i].to , w = e[i].w ;
            if( dis[to] > dis[u] + w ){
                dis[to] = dis[u] + w ;
                Q.push( Node(to,dis[to]) );
            }
        }
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        Init();
        scanf("%d%d%d",&n,&m,&k);
        for( int i = 0 ; i < m ; i++ ){
            int u , v ; ll w ;
            scanf("%d%d%lld",&u,&v,&w);
            for( int j = 0 ; j <= k ; j++ ){
                Add_edge( u + ( j*n ), v + j*n , w );
                if( j < k ){
                    Add_edge( u + j * n , v + (j+1)*n , 0 );
                }
            }
        }
        Dijstra();
        printf("%lld
",dis[n*(k+1)]);
    }
    return 0;
}

2019牛客多校 第四场 J_free

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 3200010;
const int M = 5400000;
int n,m,k;
typedef struct Edge{
    int to , next ;
    ll w ;
}Edge;
Edge e[M];

typedef struct Node{
    int u ;
    ll w ;
    Node ( int _u = 0 , ll _w = 0 ):u(_u),w(_w){}
    bool operator < ( const Node & rhs ) const {
        return w > rhs.w ;
    }
}Node;

int head[N],idx;
void Add_edge( int u, int v ,ll w ){
    e[idx] = Edge { v , head[u] , w };
    head[u] = idx ++ ;
}

void Init(){
    memset( head , -1 , sizeof head );
    idx = 0 ;
}

ll dis[N];
bool vis[N];

void Dijstra(int S){
    memset( dis , 0x3f , sizeof dis );
    memset( vis , 0  , sizeof vis );

    dis[S] = 0 ;
    priority_queue<Node> Q;
    Q.push( Node(S,0) );

    while( !Q.empty() ){
        Node cur = Q.top();
        Q.pop();
        int u = cur.u ;
        if( vis[u] ) continue ;
        vis[u] = 1 ;

        for( int i = head[u] ; ~i ; i = e[i].next ){
            int to = e[i].to , w = e[i].w ;
            if( dis[to] > dis[u] + w ){
                dis[to] = dis[u] + w ;
                Q.push( Node(to,dis[to]) );
            }
        }
    }
}
int main()
{
    int S,T;
    Init();
    scanf("%d%d%d%d%d",&n,&m,&S,&T,&k);
    for( int i = 0 ; i < m ; i++ ){
        int u , v ; ll w ;
        scanf("%d%d%lld",&u,&v,&w);
        for( int j = 0 ; j <= k ; j++ ){
            Add_edge( u + ( j*n ), v + j*n , w );
            Add_edge( v + ( j*n ), u + j*n , w );
            if( j < k ){
                Add_edge( u + j * n , v + (j+1)*n , 0 );
                Add_edge( v + j * n , u + (j+1)*n , 0 );
            }
        }
    }
    Dijstra(S);
    ll ans = 0x3f3f3f3f3f3f3f3f;
    for( int i = 0 ; i <= k ; i++ ){
        ans = min( ans , dis[T+(i*n)] );
    }
    printf("%lld
",ans);
    return 0;
}