[NOI2009]植物大战僵尸 题解

[NOI2009]植物大战僵尸 题解

题目地址:洛谷:【P2805】[NOI2009]植物大战僵尸 – 洛谷、BZOJ:Problem 1565. — [NOI2009]植物大战僵尸

题目描述

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

题解

首先,这是一个最大权闭合子图的模型,即,建立源→负权点,正权点→汇,保护点→被保护点的网络,其中源汇连边边权为点权绝对值,保护关系边权无限。这样,正权和-最小割就是答案。但是如果正负权点和源汇的建边关系反过来了会WA,这是由于一个正权点保护一个负权点显然是不优的,这些边的存在没有意义,更应该让负权点→正权点的边参与到流中。
信心满满的你写了一个Dinic,然后发现不对劲,这个图上有环!注意到本题提供了一个隐藏条件,即一个植物也可以保护它后面的植物,如果它后面的一个植物也保护了它,那它就无敌了。我们拓扑找环,然后把环上的点连同这些点可以到达的点全删了,然后把剩下的图当网络跑最大流就是正解。

代码

// Code by KSkun, 2018/7
#include <cstdio>
#include <cctype>
#include <cstring>

#include <algorithm>
#include <queue>

typedef long long LL;

inline char fgc() {
    static char buf[100000], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
        ? EOF : *p1++;
}

inline LL readint() {
    register LL res = 0, neg = 1; register char c = fgc();
    for(; !isdigit(c); c = fgc()) if(c == '-') neg = -1;
    for(; isdigit(c); c = fgc()) res = res * 10 + c - '0';
    return res * neg;
}

const int MAXN = 605, INF = 1e9;

int n, m;

struct Edge {
    int to, cap, nxt;
} gra[1000005], gra2[1000005];
int head[MAXN], head2[MAXN], deg[MAXN], tot, tot2;

inline void addedge(int u, int v, int cap) {
    gra[tot] = Edge {v, cap, head[u]}; head[u] = tot++;
    gra[tot] = Edge {u, 0, head[v]}; head[v] = tot++;
}

inline void addedge2(int u, int v) {
    gra2[tot2] = Edge {v, 0, head2[u]}; head2[u] = tot2++;
    deg[v]++;
}

bool del[MAXN];

void dfs_del(int u) {
    del[u] = true;
    for(int i = head2[u]; ~i; i = gra2[i].nxt) {
        int v = gra2[i].to;
        if(!del[v]) dfs_del(v);
    }
}

inline void toposort() {
    std::queue<int> que;
    for(int i = 1; i <= n * m; i++) {
        if(!deg[i]) que.push(i);
        else del[i] = true;
    }
    while(!que.empty()) {
        int u = que.front(); que.pop(); del[u] = false;
        for(int i = head2[u]; ~i; i = gra2[i].nxt) {
            int v = gra2[i].to;
            if(!--deg[v]) que.push(v);
        }
    }
    for(int i = 1; i <= n * m; i++) {
        if(del[i]) dfs_del(i);
    }
}

int level[MAXN];

inline bool bfs(int s, int t) {
    memset(level, -1, sizeof(level));
    std::queue<int> que;
    que.push(s); level[s] = 1;
    while(!que.empty()) {
        int u = que.front(); que.pop();
        for(int i = head[u]; ~i; i = gra[i].nxt) {
            int v = gra[i].to;
            if(level[v] == -1 && gra[i].cap) {
                level[v] = level[u] + 1;
                if(v == t) return true;
                que.push(v);
            }
        }
    }
    return level[t] != -1;
}

int cur[MAXN];

int dfs(int u, int t, int left) {
    if(u == t || !left) return left;
    int flow = 0;
    for(int &i = cur[u]; ~i; i = gra[i].nxt) {
        int v = gra[i].to;
        if(level[v] == level[u] + 1 && gra[i].cap) {
            int d = dfs(v, t, std::min(left, gra[i].cap));
            if(d) {
                gra[i].cap -= d; gra[i ^ 1].cap += d;
                flow += d; left -= d;
                if(!left) break;
            }
        }
    }
    return flow;
}

inline int dinic(int s, int t) {
    int flow = 0;
    while(bfs(s, t)) {
        memcpy(cur, head, sizeof(head));
        int f;
        while(f = dfs(s, t, INF)) flow += f;
    }
    return flow;
}

inline int id(int x, int y) {
    return (x - 1) * m + y;
}

int w[MAXN], S, T;

int main() {
    memset(head, -1, sizeof(head));
    memset(head2, -1, sizeof(head2));
    n = readint(); m = readint(); S = n * m + 1; T = S + 1;
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            w[id(i, j)] = readint();
            int t = readint();
            while(t--) {
                int x = readint() + 1, y = readint() + 1;
                addedge2(id(i, j), id(x, y));
            }
        }
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 2; j <= m; j++) {
            addedge2(id(i, j), id(i, j - 1));
        }
    }
    toposort();
    int sum = 0;
    for(int i = 1; i <= n * m; i++) {
        if(del[i]) continue;
        if(w[i] > 0) {
            sum += w[i]; addedge(i, T, w[i]);
        } else {
            addedge(S, i, -w[i]);
        }
        for(int j = head2[i]; ~j; j = gra2[j].nxt) {
            int v = gra2[j].to;
            addedge(i, v, INF);
        }
    }
    printf("%d", sum - dinic(S, T));
    return 0;
}


发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据