[MSSB]分层图最短路

分层图最短路是指在可以进行分层图的图上解决最短路问题。分层图：可以理解为有多个平行的图。

特征

• 在一个正常的图上可以进行 k 次决策，对于每次决策，不影响图的结构，只影响目前的状态或代价
• 这种状态量相互影响
• 数据范围合适

解法

分层图最短路难在建图

---

建图考虑角度一:

建图的时候要考虑点和边的意义,一般来讲就是用边权来定义决策代价,将决策前的状态和决策后的状态之间连接一条权值为决策代价的边，表示付出该代价后就可以转换状态了

这里的决策代价一般是指从最终答案角度来计算的花费

因此,一般先要分析出决策的存在性,如果存在决策,就考虑如何定义决策代价(一般就把问题作为最后的答案),之后就可以连边

建图考虑角度二:

考虑题目中的状态(如跑过一条免费边,跑过两条免费边/走了0条反向边,走了一条反向边等,这是最关键的一点)

每个状态建一层图

然后考虑图之间的链接关系

---

新图正确性检查

建图方式有时不唯一,且新图不一定会正确(如:最优贸易)

如何检查新图正确性?主要要看两点

• 是否所有有效方案(路径)都能够在图中被体现出来
• 是否有非法的方案(路径)存在

---

建完图后跑一个最短路就可以了

实现起来有两种做法:建k层图和数组实现,相对来讲后者比较快,但写起来前者比较简单(至少好理解)

题目

飞行路线

>>>>>>>>>>>>>>>>>题解

luogu P4011 孤岛营救问题

>>>>>>>>>>>>>>>>>题解

行动！行动!

>>>>>>>>>>>>>>>>>题解

最优贸易

#include<bits/stdc++.h>
using namespace std;
#define loop(i,start,end) for(register int i=start;i<=end;++i)
#define anti_loop(i,start,end) for(register int i=start;i>=end;--i)
#define clean(arry,num) memset(arry,num,sizeof(arry))
#define ll long long
template<typename T>void read(T &x){
    x=0;char r=getchar();T neg=1;
    while(r>'9'||r<'0'){if(r=='-')neg=-1;r=getchar();}
    while(r>='0'&&r<='9'){x=(x<<1)+(x<<3)+r-'0';r=getchar();}
    x*=neg;
}

int n,m;
const int maxn=100000+10;
const int maxm=500000+10;

struct node{
    int e;
    int w;
    int nxt;
}edge[maxm<<2];
int head[maxn<<2];
int cnt=0;
inline void addl(int u,int v,int w){
    edge[cnt].e=v;
    edge[cnt].w=w;
    edge[cnt].nxt=head[u];
    head[u]=cnt++;
}

int dis[maxn<<2];
deque<int>q;
void spfa(){
    clean(dis,-0x3f);
    dis[0]=0;
    q.push_front(0);
    while(q.empty()==false){
        int f=q.front();
        q.pop_front();
        for(int i=head[f];i!=-1;i=edge[i].nxt){
            int v=edge[i].e;
            if(dis[v]<dis[f]+edge[i].w){
                dis[v]=dis[f]+edge[i].w;
                if(!q.empty()&&dis[v]>dis[q.front()])
                    q.push_front(v);
                else
                    q.push_back(v);
            }
        }
    }
    printf("%d\n",dis[3*n+1]);
}

int main(){
    #ifndef ONLINE_JUDGE
    freopen("datain.txt","r",stdin);
    #endif
    clean(head,-1);
    read(n);
    read(m);
    loop(i,1,n){
        int wi;
        read(wi);
        addl(0,i,0);
        addl(i,i+n,-wi);
        addl(i+n,i+2*n,wi);
    }
    loop(i,1,m){
        int x,y,z;
        read(x);
        read(y);
        read(z);
        addl(x,y,0);
        addl(x+n,y+n,0);
        addl(x+2*n,y+2*n,0);
        if(z==2){
            addl(y,x,0);
            addl(y+n,x+n,0);
            addl(y+2*n,x+2*n,0);
        }
    }
    addl(n*3,n*3+1,0);
    addl(0,3*n+1,0);
    spfa();
    return 0;
} 

改造路

#include<bits/stdc++.h>
using namespace std;
#define loop(i,start,end) for(register int i=start;i<=end;++i)
#define anti_loop(i,start,end) for(register int i=start;i>=end;--i)
#define clean(arry,num) memset(arry,num,sizeof(arry))
#define isdegit(a) ((a>='0'&&a<='9'))
#define ll long long
template<typename T>void read(T &x){
    x=0;char r=getchar();T neg=1;
    while(!isdegit(r)){if(r=='-')neg=-1;r=getchar();}
    while(isdegit(r)){x=(x<<1)+(x<<3)+r-'0';r=getchar();}
    x*=neg;
}

int n,m,k;
const int maxn=(5e4+10)*50;
struct node{
    int e;
    int w;
    int nxt;
}edge[maxn<<2];
int head[maxn];
int cnt=0;

inline void addl(register int u,register int v,register int w){
    edge[++cnt].e=v;
    edge[cnt].w=w;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
}

struct point{
    int pos;
    int dis;
    point():pos(0),dis(0){}
    point(int pos,int dis):pos(pos),dis(dis){}
    friend bool operator<(point a,point b){
        return a.dis>b.dis;
    }
};

priority_queue<point>q;
int dis[maxn];
inline void Dijkstra(){
    clean(dis,0x3f);
    dis[1]=0;
    q.push(point(1,0));
    while(q.empty()==false){
        point f=q.top();
        q.pop();
        for(int i=head[f.pos];i!=-1;i=edge[i].nxt){
            int v=edge[i].e;
            if(dis[v]>dis[f.pos]+edge[i].w){
                dis[v]=dis[f.pos]+edge[i].w;
                q.push(point(v,dis[v]));
            }
        }
    }
    int res=INT_MAX;
    loop(t,0,k){
        res=min(res,dis[n+n*t]);
    }
    printf("%d\n",res);
}

int main(){
    #ifndef ONLINE_JUDGE
    freopen("datain2.txt","r",stdin);
    #endif
    clean(head,-1);

    read(n);
    read(m);
    read(k);
    register int ui,vi,ti;
    loop(i,1,m){
        read(ui);
        read(vi);
        read(ti);
        //printf("addl>>>>>>>>>>>>>u:%d v:%d w:%d\n",ui,vi,ti);
        loop(_k,0,k){

            addl(ui+_k*n,vi+_k*n,ti);
            addl(vi+_k*n,ui+_k*n,ti);
            if(_k){
                addl(ui+(_k-1)*n,vi+_k*n,0);
                //printf("addl>>>>>>>>>>>>>u:%d v:%d w:%d\n",ui+(_k-1)*n,vi+_k*n,0);
                addl(vi+(_k-1)*n,ui+_k*n,0);
            }

        }
    }

    Dijkstra();

    return 0;
}

电话线

#include<bits/stdc++.h>
using namespace std;
#define loop(i,start,end) for(register int i=start;i<=end;++i)
#define anti_loop(i,start,end) for(register int i=start;i>=end;--i)
#define clean(arry,num) memset(arry,num,sizeof(arry))
#define ll long long
template<typename T>void read(T &x){
    x=0;char r=getchar();T neg=1;
    while(r>'9'||r<'0'){if(r=='-')neg=-1;r=getchar();}
    while(r>='0'&&r<='9'){x=(x<<1)+(x<<3)+r-'0';r=getchar();}
    x*=neg;
}

int n,m,k;
const int maxn=1000+10;
const int maxm=10000+10;
const int maxk=maxn;
struct node{
    int e;
    int w;
    int nxt;
}edge[maxn*6*maxk];
int head[maxn*maxk];
int cnt=0;

inline void addl(int u,int v,int w){
    edge[cnt].e=v;
    edge[cnt].w=w;
    edge[cnt].nxt=head[u];
    head[u]=cnt++;
}

struct point{
    int pos;
    ll dis;
    point():pos(0),dis(0){}
    point(int pos,int dis):pos(pos),dis(dis){}
    friend bool operator<(point a,point b){
        return a.dis>b.dis;
    }
};
priority_queue<point>q;
ll dis[maxn*maxk];

inline void dijkstra(){
    clean(dis,0x7f);
    dis[1]=0;
    q.push(point(1,0));
    while(!q.empty()){
        point f=q.top();
        q.pop();
        for(int i=head[f.pos];i!=-1;i=edge[i].nxt){
            int v=edge[i].e;
            if(dis[v]>max(dis[f.pos],(ll)edge[i].w)){
                dis[v]=max(dis[f.pos],(ll)edge[i].w);
                q.push(point(v,dis[v]));
            }
        }
    }
}

int main(){
    #ifndef ONLINE_JUDGE
    freopen("datain.txt","r",stdin);
    #endif // ONLINE_JUDGE
    clean(head,-1);

    read(n);
    read(m);
    read(k);

    loop(i,1,m){
        int ui,vi,li;
        read(ui);
        read(vi);
        read(li);
        addl(ui,vi,li);
        addl(vi,ui,li);
        loop(j,1,k){
            addl(ui+n*j,vi+n*j,li);
            addl(vi+n*j,ui+n*j,li);
            addl(ui+n*(j-1),vi+n*j,0);
            addl(vi+n*(j-1),ui+n*j,0);
        }
    }
    dijkstra();

    if(dis[n+k*n]<0x7f7f7f7f)
        printf("%lld\n",dis[n+k*n]);
    else printf("-1\n");

    return 0;
}

冻结

#include<bits/stdc++.h>
using namespace std;
#define loop(i,start,end) for(register int i=start;i<=end;++i)
#define anti_loop(i,start,end) for(register int i=start;i>=end;--i)
#define clean(arry,num) memset(arry,num,sizeof(arry))
#define isdegit(a) ((a>='0'&&a<='9'))
#define ll long long
template<typename T>void read(T &x){
    x=0;char r=getchar();T neg=1;
    while(!isdegit(r)){if(r=='-')neg=-1;r=getchar();}
    while(isdegit(r)){x=(x<<1)+(x<<3)+r-'0';r=getchar();}
    x*=neg;
}

int n,m,k;
const int maxn=50+50,maxk=50+50,maxm=1000+10;
struct node{
    int e;
    int w;
    int nxt;
}edge[maxm*maxk*6];
int head[maxn*maxk];
int cnt=0;

inline void addl(int u,int v,int w){
    edge[cnt].e=v;
    edge[cnt].w=w;
    edge[cnt].nxt=head[u];
    head[u]=cnt++;
}

struct point{
    int pos;
    int dis;
    point():pos(0),dis(0){}
    point(int pos,int w):pos(pos),dis(w){}
    friend bool operator<(point a,point b){
        return a.dis>b.dis;
    }
};
priority_queue<point>q;
int dis[maxn*maxk];
inline void dijkstra(){
    clean(dis,0x3f);
    dis[1]=0;
    q.push(point(1,0));
    while(q.empty()==false){
        point f=q.top();
        q.pop();
        for(int i=head[f.pos];i!=-1;i=edge[i].nxt){
            int v=edge[i].e;
            if(dis[v]>dis[f.pos]+edge[i].w){
                dis[v]=dis[f.pos]+edge[i].w;
                q.push(point(v,dis[v]));
            }
        }
    }
}

int main(){
    #ifndef ONLINE_JUDGE
    freopen("datain.txt","r",stdin);
    #endif
    clean(head,-1);

    read(n);
    read(m);
    read(k);
    loop(i,1,m){
        int ui,vi,ti;
        read(ui);
        read(vi);
        read(ti);
        addl(ui,vi,ti);
        addl(vi,ui,ti);
        loop(j,1,k){
            addl(ui+n*j,vi+n*j,ti);
            addl(vi+n*j,ui+n*j,ti);
            addl(ui+n*(j-1),vi+n*j,ti>>1);
            addl(vi+n*(j-1),ui+n*j,ti>>1);
        }
    }
    dijkstra();

    int res=INT_MAX;
    loop(i,0,k){
        res=min(res,dis[i*n+n]);
    }
    printf("%d\n",res);

    return 0;
}

回家的路

>>>>>>>>>>>>>>>>>题解

草鉴定

>>>>>>>>>>>>>>>>>题解

转载于:https://www.cnblogs.com/andrew82/p/11377712.html