bzoj1066[SCOI2007]蜥蜴 最大流

Posted 2020-12-31 mizersy

1066: [SCOI2007]蜥蜴

Time Limit: 1 Sec  Memory Limit: 162 MB
Submit: 4931  Solved: 2546
[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

 

题解：

 把每个石柱拆成两个点（(i-1)*c+j为入点 ，(i-1)*c+j+r*c为出点 ），(i-1)*c+j ----> (i-1)*c+j+r*c连一条容量为石柱高度的边。

 每个距离边界小于d的点为能够跳出的点，(i-1)*c+j+r*c ---->汇点连一条容量为INF的边。

设(i,j)有蜥蜴，源点--->(i-1)*c+j连一条容量为1的边。

把互相可以到达的高度不为0的石柱两两相连。

从源点到汇点跑一边最大流即为能够跳出的蜥蜴数，再用总蜥蜴数-最大流即为答案

#include <bits/stdc++.h>
using namespace std;

int r,c,d;
int a[30][30];

const int MAXN = 1000100;
const int MAXM = 4000100;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int to,next,cap,flow;
} edge[MAXM];
int tol;
int head[MAXN];
int gap[MAXN],dep[MAXN],cur[MAXN];
void init()
{
    tol = 0;
    memset(head, -1,sizeof(head));
}
void addedge(int u,int v,int w,int rw = 0){
             edge[tol].to = v; edge[tol].cap = w;edge[tol].flow = 0;
                 edge[tol].next = head[u]; head[u] = tol++;
             edge[tol].to = u; edge[tol].cap = rw;edge[tol].flow = 0;
                 edge[tol].next = head[v]; head[v] = tol++;
}
int Q[MAXN];
void BFS(int start,int end)
{
    memset(dep, -1,sizeof(dep));
    memset(gap,0,sizeof(gap));
    gap[0] = 1;
    int front = 0, rear = 0;
    dep[end] = 0;
    Q[rear++] = end;
    while(front != rear)
    {
        int u = Q[front++];
        for(int i = head[u]; i != -1;i = edge[i].next){
                int v = edge[i].to;
                if(dep[v] != -1)continue;
                    Q[rear++] = v;
                    dep[v] = dep[u] + 1;
                    gap[dep[v]]++;
        }
    }
}
int S[MAXN];

int sap(int start,int end,int N)
{
    BFS(start,end);
    memcpy(cur,head,sizeof(head));
    int top = 0;
    int u = start;
    int ans = 0;
    while(dep[start] < N)
    {
        if(u == end)
        {
            int Min = INF;
            int inser;
            for(int i = 0; i < top; i++)
                if(Min > edge[S[i]].cap -edge[S[i]].flow)
                {
                    Min = edge[S[i]].cap -edge[S[i]].flow;
                    inser = i;
                }
            for(int i = 0; i < top; i++)
            {
                edge[S[i]].flow += Min;
                edge[S[i]^1].flow -= Min;
            }
            ans += Min;
            top = inser;
            u = edge[S[top]^1].to;
            continue;

        }
        bool flag = false;
        int v;
        for(int i = cur[u]; i != -1; i = edge[i].next)
        {
            v = edge[i].to;
            if(edge[i].cap -edge[i].flow && dep[v]+1 == dep[u])
            {
                flag = true;
                cur[u] = i;
                break;
            }
        }
        if(flag)
        {
            S[top++] = cur[u];
            u = v;
            continue;
        }
        int Min = N;
        for(int i = head[u]; i != -1; i = edge[i].next)
            if(edge[i].cap -edge[i].flow && dep[edge[i].to] < Min)
            {
                Min = dep[edge[i].to];
                cur[u] = i;
            }
        gap[dep[u]]--;
        if(!gap[dep[u]])
            return ans;
        dep[u] = Min + 1;
        gap[dep[u]]++;
        if(u != start)
            u = edge[S[--top]^1].to;
    }
    return ans;
}

int main()
{
    init();
    scanf("%d%d%d",&r,&c,&d);
    for (int i = 1;i <= r;++i){
        for (int j = 1;j <= c;++j){
            char tmp;
            cin >> tmp;
            a[i][j] = tmp - ‘0‘;
            if ((i <= d || i >= r - d + 1|| j <= d || j >= c - d + 1) && a[i][j] > 0){
                addedge((i-1)*c+j+r*c,r*c*2+1,INF);
            }
            if (a[i][j] > 0){
                addedge((i-1)*c+j,(i-1)*c+j+r*c,a[i][j]);
            }
        }
    }
    for (int i = 1;i <= r;++i){
        for (int j = 1;j <= c;++j){
            for (int k = 1;k <= r;++k){
                for (int m = 1;m <= c;++m){
                    if (i == k && j == m) continue;
                    if ((k-i)*(k-i) + (m-j)*(m - j) <= d*d && a[i][j] && a[k][m]) 
                        addedge((i-1)*c+j+r*c,(k-1)*c+m,INF);
                }
            }
        }
    }
    int num = 0;
    for (int i = 1;i <= r;++i){
        for (int j = 1;j <= c;++j){
            char tmp;
            cin >> tmp;
            if (tmp == ‘L‘) addedge(0,(i-1)*c+j,1),++num;
        }
    }
    int flow = sap(0,r*c*2+1,r*c*2+2);
    printf("%d
",num - flow);
    return 0;
}

View Code