单源最短路的扩展应用

1.选择最佳线路

题意:有多个起点 然后求到唯一终点的最短路

方法一:建反向边 然后从终点开始扩展 找最短路

方法二:(适用于多起点多终点)就是任选起点的情况下 到达每一个终点的最小路径

建立虚拟源点

建立虚拟源点以后问题就变成了从虚拟源点出发 到终点的最小值

#include <bits/stdc++.h>
using namespace std;
const int N=1010,M=21010,INF=0x3f3f3f3f;
int n,m,t;
int h[N],e[M],w[M],ne[M],idx;
int dis[N],q[N];
bool st[N];
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa()
{
    memset(dis,0x3f,sizeof dis);
    int hh=0,tt=1;
    dis[0]=0;
    q[0]=0;
    while(hh!=tt)
    {
         int tmp=q[hh++];
        if(hh==N) hh=0;
        st[tmp]=false;
        for(int i=h[tmp];~i;i=ne[i])
        {
            int j=e[i];
            if(dis[j]>dis[tmp]+w[i])
            {
                dis[j]=dis[tmp]+w[i];
                if(!st[j])
                {
                    q[tt++]=j;
                    if(tt==N) tt=0;
                    st[j]=true;
                }
            }
        }
    }
    if(dis[t]==INF) return -1;
    return dis[t];
}
int main()
{
    while(scanf("%d%d%d",&n,&m,&t)!=EOF)
    {
        memset(h,-1,sizeof h);
        idx=0;
        while(m--)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
        }
        int s;
        scanf("%d",&s);
        while(s--)
        {
            int ver;
            scanf("%d",&ver);
            add(0,ver,0);
        }
        printf("%d\n",spfa());
    }
    return 0;
}

2.孤岛营救问题 - 洛谷

最短路拆点 分层图

题意：n*m的矩阵中从左上角走到右下角的最短时间 有可能有墙和门和钥匙

先用dp分析 f [x][y][state]表示所有从起点走到(x,y)格子，且当前已经拥有了的钥匙是state的所有路线的集合 

状态计算 

1.（x，y）这里有一些钥匙 一定要拿 因为拿钥匙不会消耗体力 状态变成state | key

d[x][y][ state | key ]=min(d[x][y][ state| key ].d[x][y][state] );

2.向上下左右四个方向走

(1)没有门和墙 直接走 (2)有门有钥匙 直接走

d[a][b][state]=min(d[a][b][state] , d[x][y][state]+1)

但是由于这里可能会有环 没有拓扑序 实际不能用dp做 只能转换为最短路

将d[x][y][state]看成一个点

则建图就是

d[x][y][state]向d[x][y][ state| key ]连了一条边权为0的边

d[a][b][state]向左右四个格子可以走的格子连一条权重为1的边

则终点就为d[n][m][ 0~ 2^p -1] 的最小值

权重只有0 1那么就是双端队列广搜就可以做了

#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
typedef pair<int,int> PII;
const int N=11,M=N*N,E=400,P=1<<10;
int n,m,p;
int k;
int h[M],e[E],w[E],ne[E],idx;
int g[N][N],key[M];
int dis[M][P];
bool st[M][P];
set<PII> edges;
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
void build()
{
    int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            for(int u=0;u<4;u++)
            {
                int x=i+dx[u],y=j+dy[u];
                if(!x||x>n||!y||y>m) continue;
                int a=g[i][j],b=g[x][y];
                if(edges.count({a,b})==0) add(a,b,0);
            }
}
int bfs()
{
    deque<PII> q;
    memset(dis,0x3f,sizeof dis);
    dis[1][0]=0;
    q.push_back({1,0});
    while(q.size())
    {
        PII t=q.front();
        q.pop_front();
        if(st[t.x][t.y]) continue;
        st[t.x][t.y]=true;
        if(t.x==n*m)
            return dis[t.x][t.y];
        if(key[t.x])
        {
            int state=t.y|key[t.x];
            if(dis[t.x][state]>dis[t.x][t.y])
            {
                dis[t.x][state]=dis[t.x][t.y];
                q.push_front({t.x,state});
            }
        }
        for(int i=h[t.x];~i;i=ne[i])
        {
            int j=e[i];
            if(w[i]&&!(t.y>>w[i]-1 & 1))  continue;
            if(dis[j][t.y]>dis[t.x][t.y]+1)
            {
                dis[j][t.y]=dis[t.x][t.y]+1;
                q.push_back({j,t.y});
            }
        }
    }
    return -1;
}
int main()
{
    cin>>n>>m>>p>>k;
    for(int i=1,t=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            g[i][j]=t++;
    memset(h,-1,sizeof h);
    while(k--)
    {
        int x1,y1,x2,y2,c;
        cin>>x1>>y1>>x2>>y2>>c;
        int a=g[x1][y1],b=g[x2][y2];
        edges.insert({a,b}),edges.insert({b,a});
        if(c) add(a,b,c),add(b,a,c);
    }
    build();
    int s;
    cin>>s;
    while(s--)
    {
        int id,x,y;
        cin>>x>>y>>id;
        key[g[x][y]]|=1<<id-1;
    }
    cout<<bfs()<<endl;
    return 0;
}

3.最短路计数

题意：求起点到每个点的最短路的条数

#include <bits/stdc++.h>
using namespace std;
const int N=100010,M=400010,mod=100003;
int n,m;
int h[N],e[M],ne[M],idx;
int dis[N],cnt[N];
int q[N];
void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void bfs()
{
    memset(dis,0x3f,sizeof dis);
    dis[1]=0,cnt[1]=1;
    int hh=0,tt=0;
    q[0]=1;
    while(hh<=tt)
    {
        int t=q[hh++];
        for(int i=h[t];~i;i=ne[i])
        {
            int j=e[i];
            if(dis[j]>dis[t]+1)
            {
                dis[j]=dis[t]+1;
                cnt[j]=cnt[t];
                q[++tt]=j;
            }
            else if(dis[j]==dis[t]+1)
            {
                cnt[j]=(cnt[j]+cnt[t])%mod;
            }
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b),add(b,a);
    }
    bfs();

    for(int i=1;i<=n;i++)
        printf("%d\n",cnt[i]);
    return 0;
}

4.383. 观光 - AcWing题库

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;

const int N=1010,M=10010;

int n,m,S,F,T;

int h[N],e[M],ne[M],w[M],idx;
int st[N][2],cnt[N][2],d[N][2];

struct Node{
    int ver,type,dist;//点，类型(最短路0，次短路1)，距离
    bool operator>(const Node &node)const{
        return dist>node.dist;
    }
};

void add(int a,int b,int c){
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
int Dijstra(){
    memset(st,0,sizeof st);
    memset(d,0x3f,sizeof d);
    memset(cnt,0,sizeof cnt);
    priority_queue<Node,vector<Node>,greater<Node>>heap;//小根堆
    heap.push({S,0,0});
    d[S][0]=0;
    cnt[S][0]=1;
    while(heap.size()){
        Node t=heap.top();
        heap.pop();
        int ver=t.ver,type=t.type,dist=t.dist,count=cnt[ver][type];
        if(st[ver][type])   continue;
        st[ver][type]=1;
        for(int i=h[ver];~i;i=ne[i]){
            int j=e[i];
            if(dist+w[i]<d[j][0]){//如果最短路发生更新
                d[j][1]=d[j][0];
                d[j][0]=dist+w[i];
                cnt[j][1]=cnt[j][0];
                cnt[j][0]=count;
                heap.push({j,1,d[j][1]});//如果最短路发生更新，那么次短路也更新
                heap.push({j,0,d[j][0]});
            }
            else if(dist+w[i]==d[j][0]){
                cnt[j][0]+=count;
            }
            else if(dist+w[i]<d[j][1]){//如果次短路发生更新
                d[j][1]=dist+w[i];
                cnt[j][1]=count;
                heap.push({j,1,d[j][1]});
            }
            else if(dist+w[i]==d[j][1]){
                cnt[j][1]+=count;
            }
        }
    }
    int ans=cnt[F][0];
    if(d[F][1]==d[F][0]+1)   ans+=cnt[F][1];
    return ans;
}
int main(){
    cin>>T;
    while(T--){
        cin>>n>>m;
        memset(h,-1,sizeof h);
        idx=0;
        for(int i=0;i<m;i++){
            int a,b,c;
            cin>>a>>b>>c;
            add(a,b,c);
        }
        cin>>S>>F;
        cout<<Dijstra()<<endl;
    }
    return 0;
}