Codeforces Round #346 (Div. 2) F. Polycarp and Hay 并查集 bfs

老规矩，先抄一波qsc的，自己的写在后面https://www.cnblogs.com/qscqesze/p/5342366.html

 

F. Polycarp and Hay

题目连接：

http://www.codeforces.com/contest/659/problem/F

Description

The farmer Polycarp has a warehouse with hay, which can be represented as an n × m rectangular table, where n is the number of rows, and m is the number of columns in the table. Each cell of the table contains a haystack. The height in meters of the hay located in the i-th row and the j-th column is equal to an integer ai, j and coincides with the number of cubic meters of hay in the haystack, because all cells have the size of the base 1 × 1. Polycarp has decided to tidy up in the warehouse by removing an arbitrary integer amount of cubic meters of hay from the top of each stack. You can take different amounts of hay from different haystacks. Besides, it is allowed not to touch a stack at all, or, on the contrary, to remove it completely. If a stack is completely removed, the corresponding cell becomes empty and no longer contains the stack.

Polycarp wants the following requirements to hold after the reorganization:

the total amount of hay remaining in the warehouse must be equal to k,
the heights of all stacks (i.e., cells containing a non-zero amount of hay) should be the same,
the height of at least one stack must remain the same as it was,
for the stability of the remaining structure all the stacks should form one connected region.
The two stacks are considered adjacent if they share a side in the table. The area is called connected if from any of the stack in the area you can get to any other stack in this area, moving only to adjacent stacks. In this case two adjacent stacks necessarily belong to the same area.

Help Polycarp complete this challenging task or inform that it is impossible.

Input

The first line of the input contains three integers n, m (1 ≤ n, m ≤ 1000) and k (1 ≤ k ≤ 1018) — the number of rows and columns of the rectangular table where heaps of hay are lain and the required total number cubic meters of hay after the reorganization.

Then n lines follow, each containing m positive integers ai, j (1 ≤ ai, j ≤ 109), where ai, j is equal to the number of cubic meters of hay making the hay stack on the i-th row and j-th column of the table.

Output

In the first line print "YES" (without quotes), if Polycarpus can perform the reorganisation and "NO" (without quotes) otherwise. If the answer is "YES" (without quotes), then in next n lines print m numbers — the heights of the remaining hay stacks. All the remaining non-zero values should be equal, represent a connected area and at least one of these values shouldn't be altered.

If there are multiple answers, print any of them.

Sample Input

2 3 35
10 4 9
9 9 7

Sample Output

YES
7 0 7
7 7 7

Hint

题意

给你一个n*m的矩阵，然后给你一个k

这个矩阵里面的数，只能减小，不能增加。

然后你要是的矩阵最后只剩下一个连通块，且连通块里面有一个位置的数没有改变。

连通块的权值和恰好等于k

让你输出一个解。

题解：

把所有数，从大到小排序，然后用并查集去维护

只要当前这个连通块的大小大于等于k/a[i][j]就好了

然后输出的时候用bfs去输出，去维护这个连通块的大小

然后就完了……

代码

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1e6+7;
int a[1003][1003],p[maxn],num[maxn],n,m,vis[1003][1003];
long long k;
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int fi(int x)
{
    return p[x]==x?x:p[x]=fi(p[x]);
}
void uni(int x,int y)
{
    int p1=fi(x),p2=fi(y);
    if(p1==p2)return;
    p[p1]=p2;
    num[p2]+=num[p1];
    num[p1]=0;
}
struct node
{
    int x,y,z;
    node(int x1,int y1,int z1){x=x1,y=y1,z=z1;}
};
bool cmp(node a,node b)
{
    return a.x>b.x;
}
vector<node>Q;
void solve(int x,int y,int z,int v)
{
    queue<node>Q;
    Q.push(node(x,y,0));
    vis[x][y]=1;z--;
    while(!Q.empty())
    {
        node now = Q.front();
        Q.pop();
        for(int i=0;i<4;i++)
        {
            int xx=now.x+dx[i];
            int yy=now.y+dy[i];
            if(z==0)continue;
            if(xx<=0||xx>n)continue;
            if(yy<=0||yy>m)continue;
            if(vis[xx][yy])continue;
            if(a[xx][yy]<v)continue;
            vis[xx][yy]=1,z--;
            Q.push(node(xx,yy,0));
        }
    }
    for(int i=1;i<=n;i++,cout<<endl)
        for(int j=1;j<=m;j++)
            if(vis[i][j])printf("%d ",v);
            else printf("0 ");
}
int main()
{
    scanf("%d%d%lld",&n,&m,&k);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            scanf("%d",&a[i][j]),Q.push_back(node(a[i][j],i,j));
    for(int i=0;i<maxn;i++)p[i]=i,num[i]=1;
    sort(Q.begin(),Q.end(),cmp);
    for(int i=0;i<Q.size();i++)
    {
        int v = Q[i].x;if(v==0)break;
        int x = Q[i].y;
        int y = Q[i].z;
        for(int j=0;j<4;j++)
        {
            int xx = x+dx[j];
            int yy = y+dy[j];
            if(a[xx][yy]>=v)uni((xx-1)*m+yy,(x-1)*m+y);
        }
        long long Num = k/v;
        if(k%v)continue;
        int fa=fi((x-1)*m+y);
        if(Num<=num[fa])
        {
            printf("YES\n");
            solve(x,y,Num,v);
            return 0;
        }
    }
    printf("NO\n");
}

这个题目就是把无序化的bfs变为 有序化的。怎么有序化？

可以发现，枚举一个节点的值为基准时，他的联通部分权值比他小的点是无用的！所以只需知道比他权值大的且和他联通的点有多少个就行了。

如果把所有点按权值由高到低排序，那么我们就可以用并查集维护了。每次枚举一个点时，判断与他相邻的点是否比他大，如果比他大就并查集unite一下。

很不错的题目。

最后注意一下并查集的初始化和getid的计算。如果getid充分利用了(0,m*n)的话，初始化还好。如果没有充分利用，初始化就应该考虑到多出来的一些点！

 

#include<bits/stdc++.h>
#define rep(i, j, k) for (int i=j; i<k; i++)
#define ll long long 
#define dprintf if (debug) printf
using namespace std; 
const int maxn = 1005;
const int debug = 0;
int n, m, cnt;
ll k, a[maxn][maxn];
int vis[maxn][maxn], par[maxn*maxn],high[maxn*maxn];
ll num[maxn*maxn];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
struct Node{
	int x, y;
	ll w;
}st[maxn * maxn], ans[maxn * maxn];

queue<Node> Q;
int findfather(int x)
{
    return par[x]=par[x]==x?x:findfather(par[x]);
}
 
bool unite(int a, int b)
{
    int fa=findfather(a), fb=findfather(b);
    if(fa==fb)
        return false;
    if(high[fa]>high[fb]){
        par[fb]=fa;
        num[fa] += num[fb];
    }
    else
    {
        par[fa]=fb;
    	num[fb] += num[fa];
        if(high[fa]==high[fb])
            ++high[fb];
    }
    return true;
}

//初始化



int bfs(Node now){
	ll goal = k/a[now.x][now.y]; ll val = a[now.x][now.y];
	if (goal > m*n) return 0;
	ll cnt = 1;
	ans[0] = {now.x, now.y};
	while (!Q.empty()) Q.pop();
	memset(vis, 0, sizeof(vis));
	Q.push(now); vis[now.x][now.y] = 1;
	while (!Q.empty()){
		if (cnt == goal) break;
	    now = Q.front(); Q.pop();
		dprintf("bfs %d %d\n", now.x, now.y);
	    int x = now.x; int y = now.y;
		rep(i, 0, 4){
			int nx = x + dx[i]; int ny = y + dy[i];
			if (nx<=0 || nx>n || ny<=0 || ny>m || a[nx][ny] < val || vis[nx][ny]) continue;
			vis[nx][ny] = 1;
			Q.push({nx, ny, a[nx][ny]});
			ans[cnt++] = {nx, ny};
			if (cnt == goal) break;
		}
	}
	//dprintf("cnt = %d\n", cnt);
	if (cnt == goal){
		rep(i, 0, cnt){
			int x = ans[i].x; int y = ans[i].y;
			a[x][y] = -1;
		}
		puts("YES");
		for (int i=1; i<=n; i++){
			for (int j=1; j<=m; j++){
				if (a[i][j] != -1)
					printf("0 ");
				else
					printf("%lld ", val);
			}
			puts("");
		}
		return 1;
	}
	return 0;
}

bool cmp(Node n1, Node n2){
	return n1.w > n2.w;
}
int id(int x, int y){///!!!
	return (x-1) * m + y-1;
}
int main(){
	scanf("%d%d%lld", &n, &m, &k);
	for (int i=1; i<=n; i++){
		for (int j=1; j<=m; j++){
			scanf("%lld", &a[i][j]);
			st[cnt++] = {i, j, a[i][j]};
		}
	}
	rep(i, 0, cnt){
		par[i] = i;
		num[i] = 1;
	}
	sort(st, st+cnt, cmp);
	rep(i, 0, cnt){
		int x = st[i].x; int y = st[i].y; ll w = st[i].w;
		dprintf("\n\n x = %d y = %d w = %lld\n", x, y, st[i].w);
		rep(j, 0, 4){
			int nx = x + dx[j]; int ny = y + dy[j];
			if (nx <=0 || nx > n || ny <=0 || ny>m) continue;
			if (a[nx][ny] >= w) {
				dprintf("unite %d %d %d %d\n", x, y, nx, ny);
				
				unite(id(x, y), id(nx, ny));
				dprintf("numfa = %lld\n", num[findfather(id(x, y))]);
			}
		}
		if (k%w) continue;
		if (num[findfather(id(x, y))] >= k/w){
			bfs(st[i]);
			return 0;
		}
		//dprintf("k = %lld, w = %lld, k/w = %lld\n", k, w, k/w);
	}
	puts("NO");
	return 0;
}