BZOJ1066: [SCOI2007]蜥蜴

1066: [SCOI2007]蜥蜴

Time Limit: 1 Sec  Memory Limit: 162 MB
Submit: 4506  Solved: 2305
[Submit][Status][Discuss]

Description

　　在一个r行c列的网格地图中有一些高度不同的石柱，一些石柱上站着一些蜥蜴，你的任务是让尽量多的蜥蜴逃
到边界外。 每行每列中相邻石柱的距离为1，蜥蜴的跳跃距离是d，即蜥蜴可以跳到平面距离不超过d的任何一个石
柱上。石柱都不稳定，每次当蜥蜴跳跃时，所离开的石柱高度减1（如果仍然落在地图内部，则到达的石柱高度不
变），如果该石柱原来高度为1，则蜥蜴离开后消失。以后其他蜥蜴不能落脚。任何时刻不能有两只蜥蜴在同一个
石柱上。

Input

　　输入第一行为三个整数r，c，d，即地图的规模与最大跳跃距离。以下r行为石竹的初始状态，0表示没有石柱
，1~3表示石柱的初始高度。以下r行为蜥蜴位置，“L”表示蜥蜴，“.”表示没有蜥蜴。

Output

　　输出仅一行，包含一个整数，即无法逃离的蜥蜴总数的最小值。

Sample Input

5 8 2
00000000
02000000
00321100
02000000
00000000
........
........
..LLLL..
........
........

Sample Output

1

HINT

100%的数据满足：1<=r, c<=20, 1<=d<=4

Source

 

【题解】

此题每个点有流量限制，可以考虑拆点。

点x拆成x和x'。

有蜥蜴的点x，从S连向x，容量为1

能跳到外部的点x，从x'连向T，容量为INF

能彼此到达的点x,y,从x'连向y,从y'连向x，容量为INF，这样从x走向y，必须先从x走向x'再走向y,限制了点x的流量

然后从x连向x'，容量为点x的流量限制

 

挂了好多细节

写题要专心，一不专心就挂细节

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define abs(a) ((a) < 0 ? (-1 * (a)) : (a))
inline void swap(int &a, int &b)
{
    long long tmp = a;a = b;b = tmp;
}
inline void read(int &x)
{
    x = 0;char ch = getchar(), c = ch;
    while(ch < '0' || ch > '9') c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
    if(c == '-')x = -x;
}

const int INF = 0x3f3f3f3f;
const int MAXN = 500;
const int MAXM = 2000000;

struct Edge
{
    int u,v,w,nxt;
    Edge(int _u, int _v, int _w, int _nxt){u = _u;v = _v;w = _w;nxt = _nxt;}
    Edge(){}
}edge[MAXM << 1];
int head[200000], cnt = 1, q[200000], h[200000], ans = 0, S, T;

inline void insert(int a, int b, int c)
{
    edge[++cnt] = Edge(a,b,c,head[a]);
    head[a] = cnt;
    edge[++cnt] = Edge(b,a,0,head[b]);
    head[b] = cnt;
}

bool bfs()
{
    int he = 0, ta = 1;
    memset(h, -1, sizeof(h));
    q[he] = S, h[S] = 0;
    while(he < ta)
    {
        int now = q[he ++];
        for(int pos = head[now];pos;pos = edge[pos].nxt)
        {
            int v = edge[pos].v;
            if(h[v] == -1 && edge[pos].w)
            {
                h[v] = h[now] + 1;
                q[ta ++] = v;
            }
        }
    }
    return h[T] != -1;
}

int dfs(int x, int f)
{
    if(x == T) return f;
    int w, used = 0;
    for(int pos = head[x];pos;pos = edge[pos].nxt)
    {
        int v = edge[pos].v;
        if(h[v] == h[x] + 1)
        {
            w = dfs(v, min(f - used, edge[pos].w));
            edge[pos].w -= w;
            edge[pos ^ 1].w += w;
            used += w;
            if(used == f) return f;
        }
    }
    if(!used) h[x] = -1;
    return used;
}

void dinic()
{
    while(bfs()) ans += dfs(S, INF);
}

int r,c,d,g[MAXN][MAXN],x[MAXN << 1],y[MAXN << 1],w[MAXN << 1],tot,t;
char s[MAXN][MAXN];

int main()
{
    S = 100000, T = 100001;
    read(r), read(c), read(d);
    for(register int i = 1;i <= r;++ i)
    {
        scanf("%s", s[i] + 1);
        for(register int j = 1;j <= c;++ j)
            g[i][j] = s[i][j] - '0';
    }
    for(register int i = 1;i <= r;++ i)
        scanf("%s", s[i] + 1);
    for(register int i = 1;i <= r;++ i)
        for(register int j = 1;j <= c;++ j)
        {
            if(s[i][j] == 'L') ++ t;
            if(g[i][j] > 0)
            {
                ++ tot;x[tot] = i, y[tot] = j, w[tot] = g[i][j];
            }
        } 
    for(register int i = 1;i <= tot;++ i)
    {
        int tmp = min(x[i], min(y[i], min(r - x[i] + 1, c - y[i] + 1)));
        if(tmp <= d) 
            insert(i + tot, T, INF);
        if(s[x[i]][y[i]] == 'L') 
            insert(S, i, 1);
        insert(i, i + tot, w[i]);
    }
    for(register int i = 1;i <= tot;++ i)
        for(register int j = i + 1;j <= tot;++ j)
        {
            if((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]) <= d * d)
                insert(i + tot, j, INF), insert(j + tot, i, INF);
        }
    dinic();
    printf("%d", t - ans);
    return 0;
}