題目分析：很早以前在同學助攻下寫出來的，想想還是放出來好了，是個不錯的思想。

原題是在動態將可行區域變成不可行區域的同時求全域性最大子正方形，n，m，k至多2000。

既然只有加點，於是我們離線，倒著來，這樣便只有刪點。

我們給每個節點（i,j）儲存它向上能延伸的距離U[i][j]以及向下能延伸的距離D[i][j]。

易知刪除一個點最多影響一列上的U和D，暴力更新U，D。複雜度為O（n^2），可以承受。

首先我們預處理出所有點都加上後的最大子正方形（直接dp）。

然後建立一棵線段樹，線段樹儲存一段區間向下延伸的最大子矩形的高度（即最小的D），同時儲存一段區間向上延伸的最大子矩形的高度（即最小的U）。

每次刪點時我們暴力維護U，D，然後對刪點的那一行建立線段樹進行最大子正方形大小的維護（最大子正方形大小的改變一定和這一行上的點有關）。

維護方法直接見程式碼好了。

然後查詢就是O（1）的操作了。

覺得這解題的思想很不錯，值得思考~

而且這題的解法貌似很多的樣子。。

程式碼如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std ;

typedef long long LL ;

#define rep( i , a , b ) for ( int i = a ; i < b ; ++ i )
#define For( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define rev( i , a , b ) for ( int i = a ; i >= b ; -- i )
#define clr( a , x ) memset ( a , x , sizeof a )
#define ls ( o << 1 )
#define rs ( o << 1 | 1 )
#define lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
#define root 1 , 1 , m

const int MAXN = 2005 ;
const int INF = 0x3f3f3f3f ;

struct Node {
	int x , y ;
} p[MAXN] ;

int minu[MAXN << 2] , mind[MAXN << 2] ;
int G[MAXN][MAXN] ;
int U[MAXN][MAXN] ;
int D[MAXN][MAXN] ;
int left[MAXN] , right[MAXN] ;
int ans[MAXN] ;
int n , m , k ;

int min1 , min2 ;
void query ( int L , int R , int o , int l , int r ) {
	if ( L <= l && r <= R ) {
		min1 = min ( min1 , minu[o] ) ;
		min2 = min ( min2 , mind[o] ) ;
		return ;
	}
	int m = mid ;
	if ( L <= m ) query ( L , R , lson ) ;
	if ( m <  R ) query ( L , R , rson ) ;
}

void build ( int x , int o , int l , int r ) {
	if ( l == r ) {
		minu[o] = U[x][l] ;
		mind[o] = D[x][l] ;
		return ;
	}
	int m = mid ;
	build ( x , lson ) ;
	build ( x , rson ) ;
	minu[o] = min ( minu[ls] , minu[rs] ) ;
	mind[o] = min ( mind[ls] , mind[rs] ) ;
}

int calc () {
	int ans = 0 ;
	For ( i , 1 , n ) {
		For ( j , 1 , m ) {
			int x = j ;
			while ( x > 1 && U[i][x - 1] >= U[i][j] ) x = left[x - 1] ;
			left[j] = x ;
		}
		rev ( j , m , 1 ) {
			int x = j ;
			while ( x < m && U[i][x + 1] >= U[i][j] ) x = right[x + 1] ;
			right[j] = x ;
		}
		For ( j , 1 , m ) {
			ans = max ( ans , min ( U[i][j] , right[j] - left[j] + 1 ) ) ;
			//printf ( "%d %d %d\n" , U[i][j] , left[j] , right[j] ) ;
		}
		//printf ( "%d\n" , ans ) ;
	}
	return ans ;
}

int check ( int size , int y ) {
	if ( size > n || size > m ) return 0 ;
	For ( i , max ( 1 , y - size + 1 ) , m - size + 1 ) {
		min1 = min2 = INF ;
		query ( i , i + size - 1 , root ) ;
		if ( min1 + min2 - 1 >= size ) return 1 ;
	}
	return 0 ;
}

void solve () {
	clr ( U , 0 ) ;
	clr ( D , 0 ) ;
	clr ( G , 0 ) ;
	clr ( ans , 0 ) ;
	For ( i , 1 , n ) {
		getchar () ;
		For ( j , 1 , m ) {
			char c = getchar () ;
			G[i][j] = c == '.' ;
		}
	}
	rep ( i , 0 , k ) {
		scanf ( "%d%d" , &p[i].x , &p[i].y ) ;
		G[p[i].x][p[i].y] = 0 ;
	}
	//For ( i , 1 , n ) For ( j , 1 , m ) printf ( "%d%c" , G[i][j] , j < m ? ' ' : '\n' ) ;
	For ( i , 1 , n ) For ( j , 1 , m ) U[i][j] = G[i][j] ? U[i - 1][j] + 1 : 0 ;
	rev ( i , n , 1 ) For ( j , 1 , m ) D[i][j] = G[i][j] ? D[i + 1][j] + 1 : 0 ;
	int size = calc () ;
	rev ( i , k - 1 , 0 ) {
		ans[i] = size ;
		if ( !i ) break ;
		int x = p[i].x ;
		int y = p[i].y ;
		G[x][y] = 1 ;
		U[x][y] = U[x - 1][y] + 1 ;
		For ( j , x + 1 , n ) {
			if ( !G[j][y] ) break ;
			U[j][y] += U[x][y] ;
		}
		D[x][y] = D[x + 1][y] + 1 ;
		rev ( j , x - 1 , 1 ) {
			if ( !G[j][y] ) break ;
			D[j][y] += D[x][y] ;
		}
		build ( x , root ) ;
		while ( check ( size + 1 , y ) ) ++ size ;
	}
	rep ( i , 0 , k ) printf ( "%d\n" , ans[i] ) ;
}

int main () {
	while ( ~scanf ( "%d%d%d" , &n , &m , &k ) ) solve () ;
	return 0 ;
}