Home » 国际竞赛 » Details

USACO 2020 January Contest, Platinum Problem 1. Cave Paintings

Category: 国际竞赛, 计算机国际竞赛 Date: 2022年7月1日下午6:29

USACO 2020 January Contest, Platinum Problem 1. Cave Paintings

Bessie has become an artist and is creating paintings of caves! Her current work in progress is a grid of height $N$ such that each row of the grid contains exactly $M$ squares ( $1 \leq N, M \leq 1000$ ). Each square is either empty, filled with rock, or filled with water. Bessie has already painted the squares containing rock, including the entire border of the painting. She now wants to fill some empty squares with water such that if the painting were real, there would be no net motion of water. Define the height of a square in the $i$ -th row from the top to be $N + 1 - i$ . Bessie wants her painting to satisfy the following constraint:

Suppose that square $a$ is filled with water. Then if there exists a path from $a$ to square $b$ using only empty or water squares that are not higher than $a$ such that every two adjacent squares on the path share a side, then $b$ is also filled with water.

Find the number of different paintings Bessie can make modulo $10^{9} + 7$ . Bessie may fill any number of empty squares with water, including none or all.

SCORING:

Test cases 1-5 satisfy $N, M \leq 10.$
Test cases 6-15 satisfy no additional constraints.

INPUT FORMAT (file cave.in):

The first line contains two space-separated integers $N$ and $M$ .The next $N$ lines of input each contain $M$ characters. Each character is either '.' or '#', representing an empty square and a square filled with rock, respectively. The first and last row and first and last column only contain '#'.

OUTPUT FORMAT (file cave.out):

A single integer: the number of paintings satisfying the constraint modulo $10^{9} + 7$ .

SAMPLE INPUT:

4 9
#########
#...#...#
#.#...#.#
#########

SAMPLE OUTPUT:

If a square in the second row is filled with water, then all empty squares must be filled with water. Otherwise, assume that no such squares are filled with water. Then Bessie can choose to fill any subset of the three horizontally contiguous regions of empty squares in the third row. Thus, the number of paintings is equal to $1 + 2^{3} = 9.$

Problem credits: Daniel Zhang

<h3> USACO 2020 January Contest, Platinum Problem 1. Cave Paintings 题解(翰林国际教育提供，仅供参考)</h3>
<p style="text-align: center;">题解请<a href="/register" target="_blank" rel="noopener">注册</a>或<a href="/login" target="_blank" rel="noopener">登录</a>查看</p>
[/hide]

(Analysis by Daniel Zhang, Benjamin Qi)

Define a relation $R$ on empty and water cells where $a R b$ if and only if $a$ being water implies that $b$ is water. It is clearly reflexive and transitive. Also note that if $a R b$ then $h e i g h t (a) \geq h e i g h t (b)$ . Thus, cycles can only exist between vertices on the same layer. However, if we restrict the relation to cells with the same height, it is also symmetric. Thus, we can divide cells on each layer into (completely connected) equivalence classes.

Compressing these equivalence classes, we get a directed acyclic graph (DAG). Note that equivalence classes are not edge-connected; for example, in the sample case, the squares on the second row are all in the same equivalence class. Let $G$ be the graph with the minimum number of edges whose transitive closure is the DAG. (To compute the transitive closure of a graph, if edges $a \to b$ and $b \to c$ exist then add edge $a \to c$ , if it is not already present in the graph.)

If there is an edge from $a$ to $b$ in the DAG, then $h e i g h t (a) = h e i g h t (b) + 1$ . Suppose otherwise. Clearly $h e i g h t (a) > h e i g h t (b)$ . There must be a path from $a$ to $b$ using only cells of height at most $h e i g h t (a)$ . Take the last vertex $c$ on that path with height $h e i g h t (b) + 1$ (it must exist). This divides the path into a path from $a$ to $c$ using cells of height at most $h e i g h t (a)$ and a path from $c$ to $b$ using cells of height at most $h e i g h t (c)$ . This contradicts the minimality of $G$ .

Each node has at most one predecessor. Suppose there is an edge from $a$ to $b$ and an edge from $c$ to $b$ . Then, $h e i g h t (a) = h e i g h t (b) + 1 = h e i g h t (c)$ and concatenating the paths yields a path from $a$ to $c$ using only cells of height at most $h e i g h t (a)$ . Then $a$ and $c$ must be the same equivalence class.

Hence, $G$ is a (directed) forest. $G$ can be computed efficiently from the cave by sweeping upwards with a union-find data structure. Then, this problem can be solved by DP on $G$ .

Ben - I didn't have any solution in mind for the $N, M \leq 10$ subtask. It was merely intended to be a small correctness test.

#include <cstdio>
#include <cstring>
#include <vector>
 
const int MOD=1e9+7;
 
char grid[1005][1005];
 
int uf[1005][1005];
int up[1005][1005];
int id[1005][1005];
 
std::vector<int> children[1005*1005];
int tree_size=1;
 
int dp[1005*1005];
 
int find(int layer,int a){
	while(uf[layer][a]!=a){
		a=uf[layer][a]=uf[layer][uf[layer][a]];
	}
	return a;
}
 
void merge(int layer,int a,int b){
	a=find(layer,a),b=find(layer,b);
	uf[layer][a]=b;
}
 
void pull(int i){
	dp[i]=1;
	//product of children if not filling root
	for(int j:children[i]){
		dp[i]=1LL*dp[i]*dp[j]%MOD;
	}
	//+1 for filling root (and everything else)
	dp[i]++;
}
 
int main(){
	freopen("cave.in","r",stdin);
	freopen("cave.out","w",stdout);
	int N,M;
	scanf("%d %d",&N,&M);
	for(int i=0;i<N;i++){
		scanf("%s",grid[i]);
	}
	for(int i=0;i<N;i++){
		for(int j=0;j<M;j++){
			uf[i][j]=j;
		}
	}
	memset(up,-1,sizeof up);
	for(int i=N-1;i>=0;i--){
		for(int j=0;j<M;j++){
			uf[i][j]=j;
		}
		
		for(int j=0;j+1<M;j++){
			if(grid[i][j]=='.'&&grid[i][j+1]=='.'){
		 		merge(i,j,j+1);
			}
		}
		if(i<N-1){
			for(int j=0;j<M;j++){
				if(grid[i][j]=='.'&&grid[i+1][j]=='.'){
					if(up[i+1][find(i+1,j)]==-1){
						up[i+1][find(i+1,j)]=j;
					}else{
						merge(i,j,up[i+1][find(i+1,j)]);
					}
				}
			}
		}
	}
	for(int i=N-1;i>=0;i--){
		for(int j=0;j<M;j++){
			if(grid[i][j]=='.'&&find(i,j)==j){
				id[i][j]=tree_size++;
			}
		}
	}
	for(int i=N-1;i>=0;i--){
		for(int j=0;j<M;j++){
			if(grid[i][j]=='.'&&find(i,j)==j){
				if(up[i][j]!=-1){
					children[id[i-1][find(i-1,up[i][j])]].push_back(id[i][j]);
				}else{
					children[0].push_back(id[i][j]);
				}
			}
		}
	}
	for(int i=1;i<tree_size;i++){
		pull(i);
	}
	pull(0);
	printf("%d\n",(dp[0]+MOD-1)%MOD);
}