洛谷 P2805 [NOI2009]植物大战僵尸 题解【最小割】【拓扑排序】【环】【最大权闭合子图】

作者: wjyyy 分类: 拓扑排序,最大权闭合子图,最小割,,网络流 发布时间: 2018-07-09 18:51

点击量:22

 

   无法正视pvz了。。。

 

题目描述

Plants vs. Zombies(PVZ)是最近十分风靡的一款小游戏。Plants(植物)和Zombies(僵尸)是游戏的主角,其中Plants防守,而Zombies进攻。该款游戏包含多种不同的挑战系列,比如Protect Your Brain、Bowling等等。其中最为经典的,莫过于玩家通过控制Plants来防守Zombies的进攻,或者相反地由玩家通过控制Zombies对Plants发起进攻。

 

现在,我们将要考虑的问题是游戏中Zombies对Plants的进攻,请注意,本题中规则与实际游戏有所不同。游戏中有两种角色,Plants和Zombies,每个Plant有一个攻击位置集合,它可以对这些位置进行保护;而Zombie进攻植物的方式是走到植物所在的位置上并将其吃掉。

 

游戏的地图可以抽象为一个N行M列的矩阵,行从上到下用0到N–1编号,列从左到右用0到M–1编号;在地图的每个位置上都放有一个Plant,为简单起见,我们把位于第r行第c列的植物记为Pr, c。

 

Plants分很多种,有攻击类、防守类和经济类等等。为了简单的描述每个Plant,定义Score和Attack如下:

Score[Pr, c]

Zombie击溃植物Pr, c可获得的能源。若Score[Pr, c]为非负整数,则表示击溃植物Pr, c可获得能源Score[Pr, c],若为负数表示击溃Pr, c需要付出能源 -Score[Pr, c]。

 

Attack[Pr, c]

植物Pr, c能够对Zombie进行攻击的位置集合。

 

Zombies必须从地图的右侧进入,且只能沿着水平方向进行移动。Zombies攻击植物的唯一方式就是走到该植物所在的位置并将植物吃掉。因此Zombies的进攻总是从地图的右侧开始。也就是说,对于第r行的进攻,Zombies必须首先攻击Pr, M-1;若需要对Pr, c(0≤c<M-1)攻击,必须将Pr,M-1, Pr, M-2 … Pr, c+1先击溃,并移动到位置(r, c)才可进行攻击。

 

在本题的设定中,Plants的攻击力是无穷大的,一旦Zombie进入某个Plant的攻击位置,该Zombie会被瞬间消灭,而该Zombie没有时间进行任何攻击操作。因此,即便Zombie进入了一个Plant所在的位置,但该位置属于其他植物的攻击位置集合,则Zombie会被瞬间消灭而所在位置的植物则安然无恙(在我们的设定中,Plant的攻击位置不包含自身所在位置,否则你就不可能击溃它了)。

 

Zombies的目标是对Plants的阵地发起进攻并获得最大的能源收入。每一次,你可以选择一个可进攻的植物进行攻击。本题的目标为,制定一套Zombies的进攻方案,选择进攻哪些植物以及进攻的顺序,从而获得最大的能源收入。

 

输入输出格式

输入格式:

输入文件pvz.in的第一行包含两个整数N, M,分别表示地图的行数和列数。

 

接下来N×M行描述每个位置上植物的信息。第r×M + c + 1行按照如下格式给出植物Pr, c的信息:第一个整数为Score[Pr, c], 第二个整数为集合Attack[Pr, c]中的位置个数w,接下来w个位置信息(r’, c’),表示Pr, c可以攻击位置第r’ 行第c’ 列。

 

输出格式:

输出文件pvz.out仅包含一个整数,表示可以获得的最大能源收入。注意,你也可以选择不进行任何攻击,这样能源收入为0。

 

输入输出样例

输入样例#1:
3 2
10 0
20 0
-10 0
-5 1 0 0
100 1 2
1 100 0
输出样例#1:
25

说明

约20%的数据满足1 ≤ N, M ≤ 5;

约40%的数据满足1 ≤ N, M ≤ 10;

约100%的数据满足1 ≤ N ≤ 20,1 ≤ M ≤ 30,-10000 ≤ Score ≤ 10000

 

题解:

   可能拿到这个题一时半会真的看不出来是最小割吧,这个题是最小割的一个分支:最大权闭合子图

最大权闭合子图:

   在图的一个子图中,所有的节点满足指向节点一定在这个子图中这一条件,就叫最大权闭合子图。

 

   在这个题中,我们可以认为,理想状态下能拿到的分数是所有正分数;当正分数\(s[i_p]\)没有拿到,或拿到了负分数\(s[i_n]\),就相当于损失了\(|s[i]|\)的分数,因此我们要控制分数损失最小,就有了最小割模型。

 

   不过怎样保证既把正负区分开,又把选或不选区分开,就是一个问题了。如果一个点要归为不选的点,那么它就可以保护它所保护的点,这个点如果选了,他所保护的点就可能造成损失。既然选不选一个点和保护能否成功有关系,那么最小割模型就可以建为:一个点指向保护它的点,如果这条边断了,说明那个点不能保护它了。与最大权闭合子图相联系,就可以想到,当一个点所有屏障都断掉时,它是可以被攻击的,也就是它所有指向的点都被割在一边,它也割在这边就是合法的。

 

   这样一来,思想框架就搭建起来了,可是最小割跑什么呢?上面提到,不选正权点是损失,选了负权点也是损失,那我们干脆把边权定为所连接点的绝对值,为了方便分成两组,把正数边连到源点,把负数边连到汇点。这样跑最小割就是把源点一端的点全部不选(不选损失了正数),汇点一端的点全部选上(选了损失负数的绝对值),也就满足了最大权闭合子图的要求,这时跑最小割就是求出了最小损失。

 

   不过题目可能会有环,也就是两个点(或多个点)互相保护,形成了环,这个环上的点是不可能被伤害的,同时这个环上的点保护的点,和这个环上保护的点保护的点……都不可能被伤害。这样我们用拓扑排序,入度可以被删为0的点,就把它们与有关边加入网络流。

 

   最后用理想得分(所有正数的和)减去最小割就行了。

 

Code:

#include<cstdio>
#include<cstring>
#define inf 0x3fffffff
struct edge
{
    int n,v;
    int nxt;
    edge(int n,int v,int nxt)
    {
        this->n=n;
        this->v=v;
        this->nxt=nxt;
    }
    edge()
    {
        nxt=-1;
    }
}E[600*600*3],e[600*600*4];//E是原图,e是网络流
int Head[650],head[650],ecnt=-1,Ecnt=-1;
void add(int from,int to,int v)
{
    e[++ecnt]=edge(to,v,head[from]);
    head[from]=ecnt;
    e[++ecnt]=edge(from,0,head[to]);
    head[to]=ecnt;
}
void addE(int from,int to)
{
    E[++Ecnt]=edge(to,1,Head[from]);
    Head[from]=Ecnt;
}
int s[666];
int in[666],n,m;
bool vis[666];
void bfs()//拓扑排序
{
    int q[666],l=0,r=0;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n*m;++i)
        if(!in[i])
        {
            vis[i]=true;
            q[++r]=i;
        }
    while(l<r)
    {
        int k=q[++l];
        for(int i=Head[k];~i;i=E[i].nxt)
        {
            in[E[i].n]--;
            if(!in[E[i].n])
            {
                vis[E[i].n]=true;
                q[++r]=E[i].n;
            }
        }
    }
}
int d[666],cur[666],pre[666],gap[666];
void Bfs()
{
    memset(gap,0,sizeof(gap));
    int q[666],l=0,r=0;
    q[++r]=601;
    d[601]=1;
    gap[1]++;
    cur[601]=head[601];
    while(l<r)
    {
        int k=q[++l];
        cur[k]=head[k];
        for(int i=head[k];~i;i=e[i].nxt)
            if(!d[e[i].n])
            {
                q[++r]=e[i].n;
                d[e[i].n]=d[k]+1;
                gap[d[e[i].n]]++;
            }
    }
}
int sum=0;
void isap()
{
    int s=0;
    Bfs();
    pre[0]=-1;
    while(d[s]<=601)
    {
        if(s==601)
        {
            int p=pre[601];
            int minn=123456789;
            while(~p)
            {
                minn=minn<e[p].v?minn:e[p].v;
                p=pre[e[p^1].n];
            }
            sum+=minn;
            p=pre[601];
            while(~p)
            {
                e[p].v-=minn;
                e[p^1].v+=minn;
                p=pre[e[p^1].n];
            }
            s=0;
        }
        int flag=0;
        for(int i=cur[s];~i;i=e[i].nxt)
            if(e[i].v&&d[e[i].n]+1==d[s])
            {
                flag=1;
                pre[e[i].n]=i;
                cur[s]=e[i].nxt;
                s=e[i].n;
                break;
            }
        if(!flag)
        {
            int tmp=d[s];
            d[s]=601;
            for(int i=head[s];~i;i=e[i].nxt)
                if(e[i].v)
                    d[s]=d[s]<d[e[i].n]+1?d[s]:d[e[i].n]+1;
            gap[tmp]--;
            gap[d[s]]++;
            if(!gap[tmp])
                return;
            cur[s]=head[s];
            if(s!=0)
                s=e[pre[s]^1].n;
        }
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    memset(Head,-1,sizeof(Head));
    int tt=0;
    int k,u,v;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;++i)
        for(int j=0;j<m;++j)
        {
            scanf("%d",&s[i*m+j+1]);
            if(j!=0)
            {
                addE(i*m+j+1,i*m+j);
                in[i*m+j]++;
            }
            scanf("%d",&k);
            for(int g=1;g<=k;++g)
            {
                scanf("%d%d",&u,&v);
                addE(i*m+j+1,u*m+v+1);
                in[u*m+v+1]++;
            }
        }
    bfs();
    for(int i=0;i<n;++i)
        for(int j=0;j<m;++j)
            if(vis[i*m+j+1])
            {
                int now=i*m+j+1;
                if(s[now]>=0)
                {
                    add(0,now,s[now]);
                    tt+=s[now];
                }
                else
                    add(now,601,-s[now]);
                for(int l=Head[now];~l;l=E[l].nxt)
                    if(vis[E[l].n])
                        add(E[l].n,now,inf);
            }
    isap();
    printf("%d\n",tt-sum);
    return 0;
}

 

说点什么

avatar
  Subscribe  
提醒
/* */