luogu P3393 逃离僵尸岛-搜索剪枝+spfa

P3393 逃离僵尸岛

题目描述

小a住的国家被僵尸侵略了！小a打算逃离到该国唯一的国际空港逃出这个国家。

该国有N个城市，城市之间有道路相连。一共有M条双向道路。保证没有自环和重边。

K个城市已经被僵尸控制了，如果贸然闯入就会被感染TAT...所以不能进入。由其中任意城市经过不超过S条道路就可以到达的别的城市，就是危险城市。换句话说只要某个没有被占城市到某个被占城市不超过s距离，就是危险。

小a住在1号城市，国际空港在N号城市，这两座城市没有被侵略。小a走每一段道路（从一个城市直接到达另外一个城市）得花一整个白天，所以晚上要住旅店。安全的的城市旅馆比较便宜要P元，而被危险的城市，旅馆要进行安保措施，所以会变贵，为Q元。所有危险的城市的住宿价格一样，安全的城市也是。在1号城市和N城市，不需要住店。

小a比较抠门，所以他希望知道从1号城市到N号城市所需要的最小花费。

输入数据保证存在路径，可以成功逃离。输入数据保证他可以逃离成功。

输入输出格式

输入格式：

第一行4个整数(N,M,K,S)

第二行2个整数(P,Q)

接下来K行，ci，表示僵尸侵占的城市

接下来M行，ai,bi，表示一条无向边

输出格式：

一个整数表示最低花费

输入输出样例

输入样例#1：

输出样例#1：

说明

对于20%数据，N<=50

对于100%数据，2 ≦ N ≦ 100000, 1 ≦ M ≦ 200000, 0 ≦ K ≦ N - 2, 0 ≦ S ≦ 100000

1 ≦ P ＜ Q ≦ 100000

注意事项：

①一号点不住店不花费，这点不用说也知道，但是要注意n号点也没有花费。

②题目中有句话说：被僵尸控制的城市不能走，注意分别控制城市和危险城市。

③数组类型开long long，记录最短路的数组赋值一定要大。

④luogu评测毒瘤不开优化AC，开优化TLE。

代码得分分析：

　　先讲A个4点：

　　为什么先说60呢？继续听下去。

　　输入的时候记录输入的每条边，并且建边(边权为1)，spfa跑 k 遍，每次记录查询距离<=s的点记录下来，标记为危险城市，然后利用刚开始的记录边状态的数组重新建边，并已花费为边权。

　　最后再次跑一遍spfa输出到n的最短距离就好啦。

贴下代码：

#include<iostream>

#include<cmath>

#include<cstdio>

#include<algorithm>

#include<vector>

#include<cstring>

#include<queue>

#define N 200009

using namespace std;

void in(int &x){

    x=;register char c=getchar();int f=;

    while(!isdigit(c)){if(c=='-')f=-;c=getchar();}

    while(isdigit(c)){x=x*+c-'';c=getchar();}

    x*=f;

}

int n,m,k,S,p,q,head[N],tot,isp[N],d[N];

bool vis[N];

struct node{

    int to,next;

}e[N*];

void add(int u,int v){

    e[++tot].to=v;e[tot].next=head[u];head[u]=tot;

}

queue<int>Q;

void spfa(int s){

    Q.push(s);

    memset(d,0x3f,sizeof(d));memset(vis,,sizeof(vis));d[s]=;vis[s]=;

    while(!Q.empty()){

        int u=Q.front();Q.pop();vis[u]=;

        for(int i=head[u],v;v=e[i].to,i;i=e[i].next){

            if(d[v]>d[u]+){

                d[v]=d[u]+;

                if(!vis[v]){

                    Q.push(v);vis[v]=;

                }

            }

        }

    }for(int i=;i<=n;i++){

        if(d[i]<=S&&isp[i]!=&&i!=s) isp[i]=;

    }

}

void SPFA(int s){

    Q.push(s);

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

    d[s]=;vis[s]=;

    while(!Q.empty()){

        int u=Q.front();Q.pop();vis[u]=;

        for(int i=head[u],v;v=e[i].to,i;i=e[i].next){

            int mon=isp[v]==?q:p;

            if(v==n) mon=;

            if(d[v]>d[u]+mon&&isp[v]!=){

                d[v]=d[u]+mon;

                if(!vis[v]){

                    Q.push(v);vis[v]=;

                }

            }

        }

    }

}

int main()

{

    in(n);in(m);in(k);in(S);in(p);in(q);

    for(int i=;i<=k;i++){

        int w;in(w);isp[w]=;

    }for(int i=;i<=m;i++){

        int u,v;in(u);in(v);

        add(u,v);add(v,u);

    }for(int i=;i<=n;i++){

        if(isp[i]==) spfa(i);

    }SPFA();

    printf("%d\n",d[n]);

    return ;

}

这么丑一定不是我写的

　　优化：

　　我们可以很明显的感觉到k遍spfa中有好多没有用的点(已标记)，浪费大量的时间，因此我们可以用搜索+剪枝代替k遍spfa处理城市状态。

　　下面可能回跳跃比较大，尽量讲明白。

　　这里用dfs进行搜索，搜索时记录两个变量(u,tot), u表示现在搜到的第u个点，tot表示这个点还可以再去感染几个点。

　　　状态转移：

　　　　僵尸控制的城市我们称之为感染源。

　　　　　如果这个点不是感染源那么，这个转移向点所连边的点v，dfs(v，tot-1)，v只能继续感染 tot-1个点。

　　　　　如果这个点是感染源，那么这个点便可继续感染 s 个城市，那么转移为dfs( v , s )。

　　　　　如果tot为0以后，则表示已不能再扩展，则return；

　　　进一步优化：

　　　　　也可以说是加了一点小的记忆化吧。

　　　　　用一个dis[ u ]数组表示搜到的 u 个点还可以再感染几个点，如果上一步转移而来的 tot 比目前点的dis[ ]小那么直接return，因为可以扩展的点已经扩展完了。

　　　dfs部分代码：

int dis[];

void dfs(int u,int tot)

{

    f[u]=;

    if(tot<=dis[u])return ;

    dis[u]=tot;

    if(tot==)return ;

    for(int i=head[u];i;i=edge[i].nxt)

    {

        int v=edge[i].to;

        if(start[v]) dfs(v,s);

        else dfs(v,tot-);

    }

}

完整AC代码：

　　别开优化哦！！！

/*....................

作者：Manjusaka

时间：2018/7/5

题目：luogu P3393 逃离僵尸岛

......................*/

#include <algorithm>

#include <iostream>

#include <cstring>

#include <cstdio>

#include <queue>

#include <cmath>

using namespace std;

long long n,m,k,s,P,Q;

bool start[];

bool f[];

int p[];

int head[],tot;

struct ahah{

    int nxt,to;

    long long cost;

}edge[];

void add(int x,int y,long long z)

{

    edge[++tot].nxt=head[x];edge[tot].to=y;edge[tot].cost=z; head[x]=tot;

}

long long d[];

queue <int> que;

bool vis[];

void SPFA(int u)

{

    for(int i=;i<=n;i++)d[i]=;

    d[u]=;vis[u]=;que.push(u);

     while(!que.empty())

     {

         int temp=que.front();

         que.pop(); vis[temp]=;

         for(int i=head[temp];i;i=edge[i].nxt)

         {

             int v=edge[i].to;

             if(!start[v]&&d[v]>d[temp]+edge[i].cost)

             {

                 d[v]=d[temp]+edge[i].cost;

                 if(!vis[v])

                 {

                     vis[v]=;

                     que.push(v);

                 }

            }

        }

     }

}

int dis[];

void dfs(int u,int tot)

{

    f[u]=;

    if(tot<=dis[u])return ;

    dis[u]=tot;

    if(tot==)return ;

    for(int i=head[u];i;i=edge[i].nxt)

    {

        int v=edge[i].to;

        if(start[v]) dfs(v,s);

        else dfs(v,tot-);

    }

}

int main()

{

    int x[],y[];

    scanf("%lld%lld%lld%lld%lld%lld",&n,&m,&k,&s,&P,&Q);

    for(int i=;i<=k;i++)scanf("%d",&p[i]),start[p[i]]=;

    for(int i=;i<=m;i++)scanf("%d%d",&x[i],&y[i]),add(x[i],y[i],),add(y[i],x[i],);

    for(int i=;i<=k;i++)

        if(!f[p[i]])dfs(p[i],s);

    tot=;

    for(int i=;i<=m;i++)

    {

        if(y[i]==n)edge[++tot].cost=;

        else if(f[y[i]])edge[++tot].cost=Q;

        else edge[++tot].cost=P;

        if(x[i]==n)edge[++tot].cost=;

        else if(f[x[i]])edge[++tot].cost=Q;

        else edge[++tot].cost=P;

    }

    SPFA();

    printf("%lld",d[n]);

}