hihocoder [Offer收割]编程练习赛12 [1495] ---- 矩形分割

原题连接

矩形分割

算法分析：

解决该题要用到“并查集”的思想。

这里有一篇不错的博客介绍并查集： 并查集(Union-Find)算法介绍

记 int total=N*M,这里会有 total 个方块，由于一道对角线(''或者'/')会把一块方块分割为左右两部分，因此，咱们把任意一块方块看作左右两个部分。对于左部分，从左到右从上到下依次编号为 0~total-1；对于右部分，从作到右从上到下依次编号为 total~2*total-1;用一个 int parent[20000] (由于1<=N,M<=100; 全部最多有10000个方块，也就是最多有20000个半部分) 的数组来记录一个部分所属于的集合编号。初始化 parent[i]=i;

C++算法实现

#include<iostream>
using namespace std;


int find(int parent[], int i) {
    int p = parent[i];
    if (p != i) {
        parent[i] = find(parent, p);//若是当前节点的编组号不是自身，那么递归查询到当前编组的根节点，并修改当前节点的编组号为该编组的根节点
    }
    return parent[i];//返回当前节点的编组号
}

void unit(int parent[], int i, int j)//合并两个编组
{
    int pi = find(parent, i);
    int pj = find(parent, j);
    if (pi != pj)
    {
        if (pi < pj) {//将编组号小的根节点做为根，另外一个编组挂接到该编组上
            parent[pj] = pi;
        }
        else {
            parent[pi] = pj;
        }
    }
}


int main(int argc, char* argv[])
{

    int N, M, index, total;
    char wall[101][101];//墙面数据
    int parent[20000];//parent[0~total-1] 为左半部分的并查集信息，parent[total~2*total-1]为右半部分的并查集信息

    cin >> N >> M;


    cin.getline(wall[0], 101);// N 和 M 独占一行，后面的换行符没有从输入缓冲中去除掉，会影响 cin.getline()函数的结果，所以调用一次 cin.getline(wall[0],101)来去除掉该换行符
    for (int i = 0; i < N; i++) {
        cin.getline(wall[i], 101);
    }

    total = N*M;//正方形数量
    for (int i = 0; i < total; i++) {//初始化并查集
        parent[i] = i;
        parent[total + i] = total + i;
    }
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            index = i*M + j;//正方形(i,j)左半部分在 parent 中所对应的下标
            switch (wall[i][j]) {
            case ' ':
                if (i > 0) {//若是该正方形上方还有正方形，则将该正方形和上方正方形所属于的组进行合并
                    switch (wall[i - 1][j]) {
                    case ' ':
                    case '\\':
                        unit(parent, index, index - M);//index-M 为当前正方形上方的正方形左半部分在 parent[] 中的下标
                        break;
                    case '/':
                        unit(parent, index, total + index - M);//total+index-M 为当前正方形上方的正方形右半部分在 parent[] 中的下标
                        break;
                    default:
                        return -1;
                        break;
                    }
                }
                if (j > 0) {
                    //当前正方形左面还有正方形，则合并当前正方形左半部分和左面正方形的右半部分
                    unit(parent, index, total + index - 1);
                }
                unit(parent, total + index, index);//由于当前正方形没有被分割，因此当前正方形的左右两半部分一定属于同一个组，合并之
                //另外因为当前正方形内容为空格，因此当前正方形右边的正方形和下边的正方形必然会跟当前正方形相链接，在后续的处理步骤中天然会合并它们，因此无需考虑当前正方形右面正方形和下面正方形的内容
                break;
            case '\\':
                
                //当前正方形的左半部分有可能跟左面正方形的右半部分、下面正方形的左半部分或右半部分相接；对应if(j>0)和if(i<N-1)的状况
                if (j > 0) {
                    unit(parent, index, total + index - 1);
                }
                if (i<N - 1) {
                    switch (wall[i + 1][j]) {
                    case ' ':
                    case '/':
                        unit(parent, index, index + M);
                        break;
                    case '\\':
                        unit(parent, index, total + index + M);
                        break;
                    default:
                        return -1;
                        break;
                    }
                }
                //当前正方形的右半部分可能跟上面正方形的左半部分或右半部分、右面正方形的左半部分相链接；对应if(i>0)和if(j<M-1)的状况
                if (i>0) {
                    switch (wall[i - 1][j]) {
                    case ' ':
                    case '\\':
                        unit(parent, total + index, index - M);
                        break;
                    case '/':
                        unit(parent, total + index, total + index - M);
                        break;
                    default:
                        return -1;
                        break;
                    }
                }
                if (j < M - 1) {
                    unit(parent, total + index, index + 1);
                }
                break;
            case '/':
                //当前正方形的左半部分可能跟上面正方形的左半部分或右半部分、左面正方形的右半部分相链接；对应 if(i>0) 和 if(j>0) 的情形
                if (i > 0) {
                    switch (wall[i - 1][j]) {
                    case ' ':
                    case '\\':
                        unit(parent, index, index - M);
                        break;
                    case '/':
                        unit(parent, index, total + index - M);
                        break;
                    default:
                        return -1;
                        break;
                    }
                }
                if (j > 0) {
                    unit(parent, index, total + index - 1);
                }

                //当前正方形的右半部分可能跟右面正方形的左半部分、下面正方形的左半部分或右半部分相链接；对应 if(j<M-1) 和  if(i<N-1) 的状况
                if (j < M - 1) {
                    unit(parent, total + index, index + 1);
                }
                if (i < N - 1) {
                    switch (wall[i + 1][j]) {
                    case ' ':
                    case '/':
                        unit(parent, total + index, index + M);
                        break;
                    case '\\':
                        unit(parent, total + index, total + index + M);
                        break;
                    default:
                        return -1;
                        break;
                    }
                }
                break;
            default:
                return -1;
                break;
            }
        }
    }

    int ceil = total << 1;
    int count = 0;
    for (int i = 0; i < ceil; i++) {
        if (parent[i] == i) {//若是 parent[i]==i ，那么 i 为其所在的编组的根节点
            count++;
        }
    }
    cout << count;
    return 0;
}