【网络流】蜥蜴

1066: [SCOI2007]蜥蜴

Time Limit: 1 Sec   Memory Limit: 162 MB
Submit: 470   Solved: 202
[ 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<=3

难度很大的一道网络流的题目。代码复杂度低，但是建模很复杂，思维难度大，对于小三哥说的，我们这些基础薄弱的同学

主要是要拆点，还要离散化，我做这道题的时候，因为各种细节思路老师都讲了，也问了同学了，都理顺了，所以写起来比较顺利。

选择存储结构的时候，我纠结了好久。最后发现范围<=20，所以果断用线性表存离散化后的点的数据，用邻接矩阵存各个点的连边。

思路：

看见石头高度要降低，和网络流模型相似。因为一个点不能表示出流量来，因此要把一个点拆成两个，连边表示流量。

求蜥蜴最多能逃出多少。就以S为超级源向所有起点建边（注意流量大小为1，不是正无穷，一开始就错在这里）

为了简易表示，统一，减少高度时从上点到下点，跳时从下点到另一个点的上点，因为已经考虑了石头降低，这里流量设为正无穷。

最后建立一个超级汇，让所有的离边界距离小于等于d的点向超级汇建边，和之前方法相同。

这道题因为是初学网络流，代码写得有点乱

#include <cstdio>
#include <cstdlib>

struct node
{
    long x;
    long y;
    bool ul;
};
node sto[1000];
long size = 0;
long bm[1000][1000];
long index[30][30];

long n;long m;long dist;
long hv;long root;
long d[1000];
long vd[1000];

long min(long a,long b)
{
    if (a < b)
        return a;
    return b;
}

long sap(long u,long flow)
{
    if (u == hv)
        return flow;
    long count = 0;
    for (long v=0;v<size;v++)
    {
        if (bm[u][v]>0 && d[u]-d[v]==1)
        {
            long tmp = sap(v,min(flow-count,bm[u][v]));
            bm[u][v] -= tmp;
            bm[v][u] += tmp;
            count += tmp;
            if (count == flow)
            {
                return flow;
            }
        }
    }
    if (d[root]>=size+1)
    {
        return count;
    }
    vd[d[u]]--;
    if (vd[d[u]]==0)
        d[root] = size+1;
    d[u]++;
    vd[d[u]]++;
    return count;
}

int main()
{
    freopen("lizard.in","r",stdin);
    freopen("lizard.out","w",stdout);

    scanf("%ld%ld%ld",&n,&m,&dist);
    size = 0;
    // 读 入 数 据 和 连 边
    for (long i=1;i<n+1;i++)
    {
        char t;
        scanf("\n");
        for (long j=1;j<m+1;j++)
        {
            scanf("%c",&t);
            t -= '0';
            if (t > 0)
            {
                size ++;
                sto[size].x = i;
                sto[size].y = j;
                sto[size].ul = true;
                index[i][j] = size;

                size ++;
                sto[size].x = i;
                sto[size].y = j;
                sto[size].ul = false;

                bm[size-1][size] = t;
                if (i<=dist||j<=dist||n-i+1<=dist||m-j+1<=dist)
                    bm[size][0] = 0x7fff0000;
            }
        }
    }
    // 连 边
    for (long i=1;i<size+1;i++)
    {
        for (long j=i+1;j<size+1;j++)
        {
            if (sto[i].ul ^ sto[j].ul
                && abs((sto[i].x-sto[j].x))+abs((sto[i].y-sto[j].y)) <= dist
                && (sto[i].x!=sto[j].x || sto[i].y != sto[j].y))
            {
                if (sto[i].ul)
                    bm[j][i] = 0x7fff0000;
                else
                    bm[i][j] = 0x7fff0000;
            }
        }
    }
    // 超 级 源 的 建 立
    long count0 = 0;
    char tmp;size++;root = size;
    for (long i=1;i<n+1;i++)
    {
        scanf("\n");
        for (long j=1;j<m+1;j++)
        {
            scanf("%c",&tmp);
            if (tmp == 'L')
            {
                count0 ++ ;
                bm[size][index[i][j]] = 1;
            }
        }
    }
    // 网 络 流 算 法 S A P
    vd[0] = size+1;
    long ans = 0;
    while (d[root]<size+1)
    {
        ans += sap(root,0x7fff0000);
    }
    printf("%ld",count0 - ans);
    return 0;
}