BZOJ 1565: [NOI2009]植物大战僵尸

1565: [NOI2009]植物大战僵尸

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 2318  Solved: 1072
[Submit][Status][Discuss]

Description

Input

Output

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

Sample Input

3 2
10 0
20 0
-10 0
-5 1 0 0
100 1 2 1
100 0

Sample Output

25

HINT

在样例中, 植物P1,1可以攻击位置(0,0), P2, 0可以攻击位置(2,1)。 
一个方案为，首先进攻P1,1, P0,1，此时可以攻击P0,0 。共得到能源收益为(-5)+20+10 = 25。注意, 位置(2,1)被植物P2,0保护，所以无法攻击第2行中的任何植物。 
【大致数据规模】
约20%的数据满足1 ≤ N, M ≤ 5；
约40%的数据满足1 ≤ N, M ≤ 10；
约100%的数据满足1 ≤ N ≤ 20，1 ≤ M ≤ 30，-10000 ≤ Score ≤ 10000 。

Source

 

[Submit][Status][Discuss]

 

 

推荐一下僧仙的题解，很好的。

 

这叫什么最大权闭合子图问题，额，好听死了。

首先，如果有形如A保护B，B保护A这样的扯淡关系，那么A和B都不能吃。

按照保护关系建出有向图后拓扑排序可以筛出这些顽强的植物，并把它们从题中永久删除。

可以把最终得分，转换为所有正权之和，减去选取的负权之和，减去未选取的正权之和，咦，这东西可以最小割了……

 

#include <cstdio>
#include <cstring>

inline int nextChar(void)
{
    const static int siz = 1024;
    
    static char buf[siz];
    static char *hd = buf + siz;
    static char *tl = buf + siz;
    
    if (hd == tl)
        fread(hd = buf, 1, siz, stdin);
        
    return *hd++;
}

inline int nextInt(void)
{
    register int ret = 0;
    register int neg = false;
    register int bit = nextChar();
    
    for (; bit < 48; bit = nextChar())
        if (bit == '-')neg ^= true;
        
    for (; bit > 47; bit = nextChar())
        ret = ret * 10 + bit - 48;
        
    return neg ? -ret : ret;
}

const int siz = 500005;
const int inf = 1000000007;

int n, m;
int S[1005];
int P[55][55];

inline void getP(void)
{
    int tot = 0;
    
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
            P[i][j] = ++tot;
}

namespace flow
{
    int s, t;
    int hd[siz];
    int nt[siz];
    int fl[siz];
    int to[siz];
    
    int dep[siz];
    
    inline bool bfs(void)
    {
        static int que[siz], head, tail;
        memset(dep, 0, sizeof(dep));
        head = 0, tail = 0;
        que[tail++] = s;
        dep[s] = 1;
        
        while (head != tail)
        {
            int u = que[head++], v;
            
            for (int i = hd[u]; ~i; i = nt[i])
                if (!dep[v = to[i]] && fl[i])
                    dep[que[tail++] = v] = dep[u] + 1;
        }
        
        return dep[t];
    }
    
    int cur[siz];
    
    int dfs(int u, int f)
    {
        if (u == t || !f)
            return f;
            
//        printf("dfs %d %d\n", u, f);
        
        int used = 0, flow, v;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (dep[v = to[i]] == dep[u] + 1 && fl[i])    
            {
                if (f - used < fl[i])
                    flow = dfs(v, f - used);
                else
                    flow = dfs(v, fl[i]);
                
                used += flow;
                fl[i] -= flow;
                fl[i^1] += flow;
                
                if (used == f)
                    return f;
                    
                if (fl[i])
                    cur[u] = i;
            }
        
        if (!used)
            dep[u] = 0;
            
        return used;
    }
    
    inline int solve(void)
    {
        int maxFlow = 0, newFlow;
        
        while (bfs())
        {
            for (int i = s; i <= t; ++i)
                cur[i] = hd[i];
            while (newFlow = dfs(s, inf))
                maxFlow += newFlow;
        }
        
        return maxFlow;
    }
}

inline void add(int u, int v, int f)
{
//    printf("add %d %d %d\n", u, v, f);
    
    using namespace flow;
    
    static int tot = 0;
    static int flg = 0;
    
    if (!flg)
        memset(hd, -1, sizeof(hd)), flg = 1;
        
    nt[tot] = hd[u]; to[tot] = v; fl[tot] = f; hd[u] = tot++;
    nt[tot] = hd[v]; to[tot] = u; fl[tot] = 0; hd[v] = tot++;
}

namespace turpo
{
    int hd[siz];
    int to[siz];
    int nt[siz];
    int cnt[siz];
    int vis[siz];
    
    inline void solve(void)
    {
        static int que[siz], head, tail;
        
        for (int i = 1; i <= P[n][m]; ++i)
            if (!cnt[i])que[tail++] = i;
            
        while (head != tail)
        {
            int u = que[head++], v;
            
            vis[u] = true;
            
            for (int i = hd[u]; ~i; i = nt[i])
                if (--cnt[v = to[i]] == 0)que[tail++] = v;
        }
        
//        for (int i = 1; i <= P[n][m]; ++i)
//            printf("%d : %d\n", i, vis[i]);
        
        for (int i = 1; i <= P[n][m]; ++i)
            for (int j = hd[i]; ~j; j = nt[j])
                if (vis[i] && vis[to[j]])
                    add(to[j], i, inf);
    }
}

inline void addEdge(int u, int v)
{
//    printf("addEdge %d %d\n", u, v);
    
    using namespace turpo;
    
    static int tot = 0;
    static int flg = 0;
    
    if (!flg)
        memset(hd, -1, sizeof(hd)), flg = 1;
    
    nt[tot] = hd[u]; to[tot] = v; hd[u] = tot++; ++cnt[v];
}

signed main(void)
{
    n = nextInt();
    m = nextInt();
    
    int sum = 0;
    
    getP();
    
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j)
        {
            S[P[i][j]] = nextInt();
            
            for (int k = nextInt(); k--; )
            {
                int x = nextInt() + 1;
                int y = nextInt() + 1;
                
                addEdge(P[i][j], P[x][y]);
            }
            
            if (j > 1)
                addEdge(P[i][j], P[i][j - 1]);
        }
        
    turpo::solve();
    
    flow::s = 0;
    flow::t = P[n][m] + 1;
    
    for (int i = 1; i <= P[n][m]; ++i)
        if (turpo::vis[i])
        {
            if (S[i] < 0)
                add(i, flow::t, -S[i]);
            else
                add(flow::s, i, S[i]), sum += S[i];
        }
        
    printf("%d\n", sum - flow::solve());
}

 

@Author: YouSiki