1/25力扣每日一题959. 由斜杠划分区域

如题~

在由 1 x 1 方格组成的 N x N 网格 grid 中，每个 1 x 1 方块由 /、\ 或空格构成。这些字符会将方块划分为一些共边的区域。
（请注意，反斜杠字符是转义的，因此 \ 用 “\” 表示。）。
返回区域的数目。

示例 1：
输入：
[
" /",
"/ "
]
输出：2
解释：2x2 网格如下：

示例 2：
输入：
[
" /",
" "
]
输出：1
解释：2x2 网格如下：

示例 3：
输入：
[
“\/”,
“/\”
]
输出：4
解释：（回想一下，因为 \ 字符是转义的，所以 “\/” 表示 /，而 “/\” 表示 /\。）
2x2 网格如下：

代码直接列上吧，这力扣又是不做人的一天、、
完全看不懂之后，通过看题解，勉强搞明白了题解

将每个大方块分成0,1,2,3四个小方块
从正上方编号为0, 其余顺时针编号
当字符为’’,可以想象一下，正方形被斜劈开 0-1连通, 2-3连通
当字符为’/’, 0-3连通, 1-2连通
当字符为’ '，也就是没有的时候, 0-1-2-3连通
相邻的大方块之间也需要连通
左右相邻的需要连通1(左)-3(右)
上下相邻的需要连通2(上)-0(下)
最终返回大的并查集的连通块个数 也就是有多少个树

/*
这道题本来开始没看懂，后来看的解析教程 

才看懂的，然后还不会写。。。。。 

这是看的题解
*/ 
void swap(int* a, int* b) {
    int tmp = *a;
    *a = *b, *b = tmp;//首先定义交换类型函数 ,将a，b交换 
}

struct DisjointSetUnion {//①定义并查集 这个结构体，ps：下面有具体啥是结构体struct 
    int *f, *size;//size是长度，一个相连的有多长
    int n, setCount;//setcount是指分开部分的总数
};

void initDSU(struct DisjointSetUnion* obj, int n) {//定义函数过程中，用结构体给了obj
    obj->f = malloc(sizeof(int) * n);//这里obj中的f是上面的*f
    obj->size = malloc(sizeof(int) * n);//size是上面的*size
    obj->n = n;
    obj->setCount = n;
    for (int i = 0; i < n; i++) {
        obj->f[i] = i;
        obj->size[i] = 1;
    }
}

int find(struct DisjointSetUnion* obj, int x) {
    return obj->f[x] == x ? x : (obj->f[x] = find(obj, obj->f[x]));//找到他们的根节点，压缩路径
}

int unionSet(struct DisjointSetUnion* obj, int x, int y) {//这里开始权值压缩，减少长度
    int fx = find(obj, x), fy = find(obj, y);//fx，和fy是他们的长度
    if (fx == fy) {
        return false;
    }//长度相等的话都一样
    if (obj->size[fx] < obj->size[fy]) {
        swap(&fx, &fy);//交换fx和fy
    }
    obj->size[fx] += obj->size[fy];
    obj->f[fy] = fx;
    obj->setCount--;
    return true;//把他们连接起来。分离的部分 - 1
}

struct HashTable {//建立哈希表
    int value;
    UT_hash_handle hh;
};

int regionsBySlashes(char** grid, int gridSize) {
    int n = gridSize;
    struct DisjointSetUnion* uf = malloc(sizeof(struct DisjointSetUnion));
    initDSU(uf, n * n * 4);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int idx = i * n + j;//开始联通方块
            
            if (grid[i][j] == '/') {
                unionSet(uf, idx * 4, idx * 4 + 3);
                unionSet(uf, idx * 4 + 1, idx * 4 + 2);
            } else if (grid[i][j] == '\\') {
                unionSet(uf, idx * 4, idx * 4 + 1);
                unionSet(uf, idx * 4 + 2, idx * 4 + 3);
            } else {
                unionSet(uf, idx * 4, idx * 4 + 1);
                unionSet(uf, idx * 4 + 1, idx * 4 + 2);
                unionSet(uf, idx * 4 + 2, idx * 4 + 3);
            }
            if (i < n - 1) {
                int bottom = idx + n;
                unionSet(uf, idx * 4 + 2, bottom * 4);
            }
            if (j < n - 1) {
                int right = idx + 1;
                unionSet(uf, idx * 4 + 1, right * 4 + 3);
            }
        }
    }

    struct HashTable* fathers = NULL;//这里哈希表那部分就搞不太懂，本来以为没必要的
    for (int i = 0; i < n * n * 4; i++) {
        int fa = find(uf, i);
        struct HashTable* tmp;
        HASH_FIND_INT(fathers, &fa, tmp);
        if (tmp == NULL) {
            tmp = malloc(sizeof(struct HashTable));
            tmp->value = fa;
            HASH_ADD_INT(fathers, value, tmp);
        }
    }
    return HASH_COUNT(fathers);
}