[BFS]Codeforces Igor In the Museum

 Igor In the Museum

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Igor is in the museum and he wants to see as many pictures as possible.

Museum can be represented as a rectangular field of n × m cells. Each cell is either empty or impassable. Empty cells are marked with '.', impassable cells are marked with '*'. Every two adjacent cells of different types (one empty and one impassable) are divided by a wall containing one picture.

At the beginning Igor is in some empty cell. At every moment he can move to any empty cell that share a side with the current one.

For several starting positions you should calculate the maximum number of pictures that Igor can see. Igor is able to see the picture only if he is in the cell adjacent to the wall with this picture. Igor have a lot of time, so he will examine every picture he can see.

Input

First line of the input contains three integers n, m and k(3 ≤ n, m ≤ 1000, 1 ≤ k ≤ min(n·m, 100 000)) — the museum dimensions and the number of starting positions to process.

Each of the next n lines contains m symbols '.', '*' — the description of the museum. It is guaranteed that all border cells are impassable, so Igor can't go out from the museum.

Each of the last k lines contains two integers x and y (1 ≤ x ≤ n, 1 ≤ y ≤ m) — the row and the column of one of Igor's starting positions respectively. Rows are numbered from top to bottom, columns — from left to right. It is guaranteed that all starting positions are empty cells.

Output

Print k integers — the maximum number of pictures, that Igor can see if he starts in corresponding position.

Examples

input

Copy

5 6 3
******
*..*.*
******
*....*
******
2 2
2 5
4 3

output

Copy

6
4
10

input

Copy

4 4 1
****
*..*
*.**
****
3 2

output

Copy

8

题意:

在一个有n*m的格子（这些格子是矩形且每个格子与周围的4个格子邻接）平面内，能走的格子为'.',不能走的格子为'#'称为墙，有多个起点，问若从一个起点出发，能找到多少与墙相邻的边

思路:

先读入整个地图
注意要先把整个地图读完在看墙的上下左右，因为如果边度边判断就无法判断下面和右边的情况（你还没读到，现在是不存在的）
如果当前这个是墙，则其上下左右在n*m的格子内的可走区域的答案要+1
接着读入起始点
若这个格子以前被走过了就直接输出答案
否则就从这个格子开始搜索并把一开始处理好的墙边上可走的格子的答案加上，并把当前能走到的点都更新为这个答案，因为从这些点出发都能得到这个最大答案

 #include<bits/stdc++.h>
 using namespace std;
 const int amn=1e3+;
 char mp[amn][amn];
 long long ans[amn][amn],n,m,k,as,sx,sy;
 bool idx[amn][amn],f[amn][amn];
 int dic[][]={{,-},{,+},{+,},{-,}};
 struct node{
     int x;int y;
 };
 queue<node> q;
 long long fd(int x,int y){
     node a;
     a.x=x;a.y=y;
     while(q.size())q.pop();
     q.push(a);
     long long cnt=;
     while(q.size()){
         node w=q.front();q.pop();
         //cout<<w.x<<'!'<<w.y<<endl;
         f[w.x][w.y]=idx[w.x][w.y]=;
         if(ans[w.x][w.y])cnt+=ans[w.x][w.y];
         for(int k=;k<;k++){
             int dx=w.x+dic[k][];
             int dy=w.y+dic[k][];
             //cout<<k<<' '<<w.x<<' '<<w.y<<' '<<dx<<'@'<<dy<<' '<<cnt<<endl;
             if(dx>&&dx<n&&dy>&&dy<m&&mp[dx][dy]=='.'&&!idx[dx][dy]&&!f[dx][dy]){
                     f[dx][dy]=idx[dx][dy]=;
                     a.x=dx;a.y=dy;
                     q.push(a);
             }
         }
     }
     return cnt;
 }
 void cg(int x,int y,long long val){
     node a;
     a.x=x;a.y=y;
     while(q.size())q.pop();
     q.push(a);
     while(q.size()){
         node w=q.front();q.pop();
         //cout<<w.x<<'?'<<w.y<<endl;
         idx[w.x][w.y]=;
         ans[w.x][w.y]=val;
         for(int k=;k<;k++){
             int dx=w.x+dic[k][];
             int dy=w.y+dic[k][];
             if(dx>=&&dx<=n&&dy>=&&dy<=m&&mp[dx][dy]=='.'&&idx[dx][dy]&&f[dx][dy]){
                     idx[dx][dy]=;          ///idx是搜索标记，注意只有idx还原为0，f数组是看这个答案是否存在，只要有答案就不需要更改了
                     a.x=dx;a.y=dy;
                     q.push(a);
             }
         }
     }
 }
 int main(){
     ios::sync_with_stdio();
     cin>>n>>m>>k;
     for(int i=;i<=n;i++)
         for(int j=;j<=m;j++)
             f[i][j]=idx[i][j]=ans[i][j]=;
     for(int i=;i<=n;i++){
         for(int j=;j<=m;j++){
             cin>>mp[i][j];              ///先读入整个地图
         }
     }
     for(int i=;i<=n;i++){
         for(int j=;j<=m;j++){          ///注意要先把整个地图读完在看墙的上下左右，因为如果边度边判断就无法判断下面和右边的情况（你还没读到，现在是不存在的）
             if(mp[i][j]=='*'){          ///如果当前这个是墙，则其上下左右在n*m的格子内的可走区域的答案要+1
                 for(int k=;k<;k++){
                     int dx=i+dic[k][];
                     int dy=j+dic[k][];
                     if(dx>=&&dx<=n&&dy>=&&dy<=m&&mp[dx][dy]=='.')ans[dx][dy]++;//cout<<dx<<' '<<dy<<' '<<ans[dx][dy]<<endl;;
                 }
             }
         }
     }
     while(k--){
         cin>>sx>>sy;
         if(f[sx][sy])printf("%lld\n",ans[sx][sy]);      ///若这个格子以前被走过了就直接输出答案
         else{                                           ///否则就从这个格子开始搜索并把一开始处理好的墙边上可走的格子的答案加上，并把当前能走到的点都更新为这个答案，因为从这些点出发都能得到这个最大答案
             as=fd(sx,sy);
             cg(sx,sy,as);
             printf("%lld\n",ans[sx][sy]);
         }
     }
 }
 /***
 在一个有n*m的格子（这些格子是矩形且每个格子与周围的4个格子邻接）平面内，能走的格子为'.',不能走的格子为'#'称为墙，有多个起点，问若从一个起点出发，能找到多少与墙相邻的边
 先读入整个地图
 注意要先把整个地图读完在看墙的上下左右，因为如果边度边判断就无法判断下面和右边的情况（你还没读到，现在是不存在的）
 如果当前这个是墙，则其上下左右在n*m的格子内的可走区域的答案要+1
 接着读入起始点
 若这个格子以前被走过了就直接输出答案
 否则就从这个格子开始搜索并把一开始处理好的墙边上可走的格子的答案加上，并把当前能走到的点都更新为这个答案，因为从这些点出发都能得到这个最大答案
 ***/