Codeforces Round #356 (Div. 2) E. Bear and Square Grid 滑块

E. Bear and Square Grid

题目连接：

http://www.codeforces.com/contest/680/problem/E

Description

You have a grid with n rows and n columns. Each cell is either empty (denoted by '.') or blocked (denoted by 'X').

Two empty cells are directly connected if they share a side. Two cells (r1, c1) (located in the row r1 and column c1) and (r2, c2) are connected if there exists a sequence of empty cells that starts with (r1, c1), finishes with (r2, c2), and any two consecutive cells in this sequence are directly connected. A connected component is a set of empty cells such that any two cells in the component are connected, and there is no cell in this set that is connected to some cell not in this set.

Your friend Limak is a big grizzly bear. He is able to destroy any obstacles in some range. More precisely, you can choose a square of size k × k in the grid and Limak will transform all blocked cells there to empty ones. However, you can ask Limak to help only once.

The chosen square must be completely inside the grid. It's possible that Limak won't change anything because all cells are empty anyway.

You like big connected components. After Limak helps you, what is the maximum possible size of the biggest connected component in the grid?

Input

The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 500) — the size of the grid and Limak's range, respectively.

Each of the next n lines contains a string with n characters, denoting the i-th row of the grid. Each character is '.' or 'X', denoting an empty cell or a blocked one, respectively.

Output

Print the maximum possible size (the number of cells) of the biggest connected component, after using Limak's help.

Sample Input

5 2
..XXX
XX.XX
X.XXX
X...X
XXXX.

Sample Output

10

Hint

题意

给你n*n的矩阵，你有一个k*k的框框，可以把矩阵的某一块给框起来

然后这个框框内的所有格子都是.了，现在你需要使得这个矩阵的连通块最大，那么这个连通块的大小是多少呢？

题解：

简单点，我们思考一下，最大的这个答案一定是这个框框所在的连通块，这个很显然，因为你加了框框之后，连通块的大小是会增加或者保持不变的。

所以我们直接暴力枚举所有框框摆放的位置就好了。

我们利用滑块的思想去做这道题，那么我们维护这个框框的时候，就只用维护他的边界信息了

这样就可以把n^4->n3了。

然后这道题就可以AC了。

代码

#include<bits/stdc++.h>
using namespace std;
const int maxn = 505;
int n,k;
char grid[maxn][maxn];
int cc[maxn][maxn];
int cc_size[maxn*maxn];
int when_added[maxn*maxn];
int dx[4]={1,-1,0,0};
int dy[4]={0,0,-1,1};

bool inside(int x,int y)
{
    if(x<0||x>=n)return false;
    if(y<0||y>=n)return false;
    return true;
}

void dfs(int x,int y,int num)
{
    cc[x][y]=num;
    ++cc_size[num];
    for(int i=0;i<4;i++)
    {
        int x2=x+dx[i];
        int y2=y+dy[i];
        if(inside(x2,y2)&&grid[x2][y2]=='.'&&cc[x2][y2]==0)
            dfs(x2,y2,num);
    }
}

void add(int x,int y,int& ans,int num)
{
    if(inside(x,y)&&grid[x][y]=='.')
    {
        int id = cc[x][y];
        if(when_added[id]!=num)
        {
            when_added[id]=num;
            ans+=cc_size[id];
        }
    }
}

void QAQ()
{
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
        scanf("%s",grid[i]);

    int cnt = 0;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(grid[i][j]=='.'&&cc[i][j]==0)
                dfs(i,j,++cnt);

    int cur_time = 1;
    int Ans = 0;

    for(int y_low=0;y_low+k-1<n;y_low++)
    {
        for(int x=0;x<k;x++)
            for(int y=y_low;y<y_low+k;y++)
                --cc_size[cc[x][y]];

        for(int x_low=0;x_low+k-1<n;x_low++)
        {
            int ans = k*k;

            for(int x=x_low;x<x_low+k;x++)
            {
                add(x,y_low-1,ans,cur_time);
                add(x,y_low+k,ans,cur_time);
            }

            for(int y=y_low;y<y_low+k;y++)
            {
                add(x_low-1,y,ans,cur_time);
                add(x_low+k,y,ans,cur_time);
            }

            ++cur_time;
            Ans=max(Ans,ans);

            if(x_low+k!=n)
            {
                for(int y=y_low;y<y_low+k;y++)
                {
                    ++cc_size[cc[x_low][y]];
                    --cc_size[cc[x_low+k][y]];
                }
            }
        }

        for(int x=n-k;x<n;x++)
            for(int y=y_low;y<y_low+k;y++)
                ++cc_size[cc[x][y]];
    }
    cout<<Ans<<endl;
}

int main()
{
    QAQ();
}