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:
13 21 1 1
1000 6000
7
1 2
3 7
2 4
5 8
8 9
2 5
3 4
4 7
9 10
10 11
5 9
7 12
3 6
4 5
1 3
11 12
6 7
8 11
6 13
7 8
12 13
输出样例#1: 
11000

说明

对于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=0;register char c=getchar();int f=1;
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c)){x=x*10+c-'0';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*2];
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,0,sizeof(vis));d[s]=0;vis[s]=1;
    while(!Q.empty()){
        int u=Q.front();Q.pop();vis[u]=0;
        for(int i=head[u],v;v=e[i].to,i;i=e[i].next){
            if(d[v]>d[u]+1){
                d[v]=d[u]+1;
                if(!vis[v]){
                    Q.push(v);vis[v]=1;
                }
            }
        }
    }for(int i=1;i<=n;i++){
        if(d[i]<=S&&isp[i]!=1&&i!=s) isp[i]=2;
    }
}

void SPFA(int s){
    Q.push(s);
    memset(d,0x3f,sizeof(d));memset(vis,0,sizeof(vis));
    d[s]=0;vis[s]=1;
    while(!Q.empty()){
        int u=Q.front();Q.pop();vis[u]=0;
        for(int i=head[u],v;v=e[i].to,i;i=e[i].next){
            int mon=isp[v]==2?q:p;
            if(v==n) mon=0;
            if(d[v]>d[u]+mon&&isp[v]!=1){
                d[v]=d[u]+mon;
                if(!vis[v]){
                    Q.push(v);vis[v]=1;
                }
            }
        }
    }
}

int main()
{
    in(n);in(m);in(k);in(S);in(p);in(q);
    for(int i=1;i<=k;i++){
        int w;in(w);isp[w]=1;
    }for(int i=1;i<=m;i++){
        int u,v;in(u);in(v);
        add(u,v);add(v,u);
    }for(int i=1;i<=n;i++){
        if(isp[i]==1) spfa(i);
    }SPFA(1);
    printf("%d\n",d[n]);
    return 0;
}
这么丑一定不是我写的

  

  优化:

  我们可以很明显的感觉到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[222222];
void dfs(int u,int tot)
{
    f[u]=1;
    if(tot<=dis[u])return ;
    dis[u]=tot;
    if(tot==0)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-1);
    }
}

完整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[200020];
bool f[200020];
int p[200020];
int head[200200],tot;
struct ahah{
    int nxt,to;
    long long cost;
}edge[400000];
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[222222];
queue <int> que;
bool vis[222222];
void SPFA(int u)
{
    for(int i=1;i<=n;i++)d[i]=1234567890000;
    d[u]=0;vis[u]=1;que.push(u);
     while(!que.empty())
     {
         int temp=que.front();
         que.pop(); vis[temp]=0;
         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]=1;
                     que.push(v); 
                 }
            }
        }
     }
}
int dis[222222];
void dfs(int u,int tot)
{
    f[u]=1;
    if(tot<=dis[u])return ;
    dis[u]=tot;
    if(tot==0)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-1);
    }
}
int main()
{
    int x[222222],y[222222];
    scanf("%lld%lld%lld%lld%lld%lld",&n,&m,&k,&s,&P,&Q);
    for(int i=1;i<=k;i++)scanf("%d",&p[i]),start[p[i]]=1;
    for(int i=1;i<=m;i++)scanf("%d%d",&x[i],&y[i]),add(x[i],y[i],1),add(y[i],x[i],1);
    for(int i=1;i<=k;i++)
        if(!f[p[i]])dfs(p[i],s);
    tot=0;
    for(int i=1;i<=m;i++)
    {
        if(y[i]==n)edge[++tot].cost=0;
        else if(f[y[i]])edge[++tot].cost=Q;
        else edge[++tot].cost=P;
        
        if(x[i]==n)edge[++tot].cost=0;
        else if(f[x[i]])edge[++tot].cost=Q;
        else edge[++tot].cost=P;
    }
    SPFA(1);
    printf("%lld",d[n]);
}

猜你喜欢

转载自www.cnblogs.com/rmy020718/p/9272374.html
今日推荐