BOI 2013 Tracks in the snow Flood-fill

题目

BOI 2013
Rostock, Germany
April 8 – May 12, 2013 b i Day 2
ENG
tracks
Page 1 of 2
Tracks in the Snow
There is a rectangular meadow in a forest, having been covered with a blanket of fresh snow in the
morning (left in the figure below).
Rabbits and foxes, who live in the forest, are crossing the meadow and leave their tracks in the snow.
They always enter in the upper left corner and leave the meadow from the lower right corner. In
between they can move back and forth, playing in the snow, even crossing their own tracks. At any
time there is at most one animal on the meadow. No animal enters the meadow more than once. The
movements of the animals can be described by dividing the meadow into quadratic cells. The animals
never move diagonally in a single step and they never jump over a cell. When an animal enters a cell
its tracks will cover all previous tracks left in this cell.
For example, first a rabbit crossed the meadow from top-left to bottom-right (middle in the figure).
After that, a fox crossed, and now his tracks are partially covering the rabbit’s (right in the figure).
........ RRR..... FFR.....
........ ..RRR... .FRRR...
........ ..R..... .FFFFF..
........ ..RRRR.R ..RRRFFR
........ .....RRR .....FFF
You are given a map of the meadow at some time after indicating for each cell if there are any visible
tracks and whether they were left by a rabbit or by a fox (right in the figure). You are interested in the
local wildlife population. Write a program to determine the minimal possible number N of animals
that must have crossed the meadow to leave the given pattern of tracks in the snow.
Input
The first line contains two integers H and W, the height and the width of the map of the meadow. H
lines follow with exactly W characters on each: the map, where ‘.’ marks untouched snow, ‘R’ a spot
where a rabbit’s track is the topmost one, and ‘F’ a spot where a fox’s track is the topmost one. There
is at least one track on the meadow.
Output
The output should consist of a single integer: the minimal number N  1 of animals that could have
left the tracks given in the input.
Constraints
1  H;W  4000
In test cases worth 30 points: N  200 and H;W  500
BOI 2013
Rostock, Germany
April 8 – May 12, 2013 b i Day 2
ENG
tracks
Page 2 of 2
Example
Input Output
5 8
FFR.....
.FRRR...
.FFFFF..
..RRRFFR
.....FFF
2
Limits
Time limit: 2 sec per test case
Memory limit: 1300 MB per test case

分析

首先我们先从简单的地方开始，首先不难判断出最后一次的动物是怎么走的。用属于来说，就是起点和终点所在的联通块。这个概念在这道题里还是比很重要的。然后对于这个联通块进行染色（用一个数字来标记这个联通块里的格子）。

其实就是先将起点入队，然后用BFS从起点开始向上下左右进行发散，（先判断是否这个点可行）将新点入队。如果新的点与前一个点颜色匹配，那么刷成同一种颜色，如果不是同种颜色，就用没用过的另一种颜色来代替（也就是Track[v.x][v.y] != Track[u.x][u.y]成立的情况下，Anti为1，那么color[v.x][v.y] = color[u.x][u.y]+Anti;就会使得color[v.x][v.y] = color[u.x][u.y]+1）。直到所有的点遍历完成，那么其中最大的数字（最后一个染上的颜色）就是我们要的答案（还要+1啊！）。

这就是这道题的算法：Flood-fill

程序

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4000+1;
const int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1};
char Track[MAXN][MAXN];
bool vis[MAXN][MAXN];
int h, w, color[MAXN][MAXN];
struct node
{
    int x,y;
};
void BFS()
{
    memset(color,0,sizeof(color));
    queue<node> Q[2];
    memset(vis,false,sizeof(false));
    int Now = 0;
    Q[Now].push((node){1,1});
    vis[1][1] = true;
    while (!Q[Now].empty())
    {
        while (!Q[Now].empty())
        {
            node u = Q[Now].front();
            Q[Now].pop();
            for (int i = 0; i < 4; i++)
            {
                node v = (node){u.x+dx[i],u.y+dy[i]};
                if (v.x > h || v.x < 1 || v.y > w || v.y < 1 || Track[v.x][v.y] == '.' || vis[v.x][v.y])
                    continue;
                int Anti = (Track[v.x][v.y] != Track[u.x][u.y]);
                vis[v.x][v.y] = true;
                color[v.x][v.y] = color[u.x][u.y]+Anti;
                Q[Now^Anti].push(v);
            }
        }
        Now = 1-Now;
    }
    int ans = 0;
    for (int i = 1; i <= h; i++)
        for (int j = 1; j <= w; j++)
            ans = max(ans, color[i][j]);
    cout << ans+1 << endl;
}
int main()
{
    freopen("tracks.in","r",stdin);
    freopen("tracks.out","w",stdout);
    cin >> h >> w;
    for (int i = 1; i <= h; i++)
        for (int j = 1; j <= w; j++)
            cin >> Track[i][j];
    BFS();
    return 0;
}