Add files via upload

Author: assassint2017

Surrounded Regions/Surrounded_Regions.cpp

@@ -0,0 +1,145 @@
+// 解题思路依然使用并查集，特殊点在于使用了一个虚拟的父亲节点将所有边界上、以及边界上的邻居点都串起来了
+
+// Runtime: 24 ms, faster than 98.26% of C++ online submissions for Surrounded Regions.
+// Memory Usage: 14.4 MB, less than 34.94% of C++ online submissions for Surrounded Regions.
+
+class Solution 
+{
+public:
+    void solve(vector<vector<char>>& board) 
+    {
+        // 边界条件处理
+        rows = board.size();
+        
+        if (rows == 0)
+        {
+            return ;
+        }
+        
+        cols = board[0].size();
+        
+        if (cols == 0)
+        {
+            return ;
+        }
+        
+        // 构建并查集
+        vector<pair<int, int>> unionTree(rows * cols + 1);
+        
+        // 初始化并查集 depth parent
+        for (int i = 0; i < unionTree.size(); i++)
+        {
+            unionTree[i].first = 1;
+            unionTree[i].second = i;
+        }
+        
+        // 构建并查集
+        for (int i = 0; i < rows; i++)
+        {
+            for (int j = 0; j < cols; j++)
+            {
+                if (board[i][j] == 'O')
+                {
+                    int index1 = i * cols + j;
+                    
+                    // 如果目标在边界上
+                    if (i == 0 || i == rows - 1 || j == 0 || j == cols - 1)
+                    {
+                        int index2 = rows * cols;
+                        unionx(index1, index2, unionTree);
+                    }
+        
+                    // 和上边的数据相连
+                    if (i - 1 >= 0 && board[i - 1][j] == 'O')
+                    {    
+                        int index2 = (i - 1) * cols + j;
+                        unionx(index1, index2, unionTree);
+                    }
+                    
+                    // 和左边的数据相连
+                    if (j - 1 >= 0 && board[i][j - 1] == 'O')
+                    {
+                        int index2 = i * cols + (j - 1);
+                        unionx(index1, index2, unionTree);
+                    }
+                    
+                }
+            }
+        }
+        
+        // 根据构建好的并查集来翻转数据
+        for (int i = 0; i < rows; i++)
+        {
+            for (int j = 0; j < cols; j++)
+            {
+                if (board[i][j] == 'O')
+                {
+                    if (findParent(i * cols + j, unionTree) != findParent(rows * cols, unionTree))
+                    {
+                        board[i][j] = 'X';
+                    }
+                }
+            }
+        }
+    }
+    
+private:
+    
+    // 所能接受的最大查询路径长度
+    int maxPathLength = 3;
+    int rows;
+    int cols;
+    
+    // 合并函数
+    void unionx(int index1, int index2, vector<pair<int, int>>& unionTree)
+    {
+        int parent1 = findParent(index1, unionTree);
+        int parent2 = findParent(index2, unionTree);
+
+        if (parent1 == parent2)
+        {
+            return ;
+        }
+
+        // 将高度较低的树向高度较高的树进行合并
+        if (unionTree[parent1].first > unionTree[parent2].first)
+        {
+            unionTree[parent2].second = parent1;
+        }
+        else
+        {
+            unionTree[parent1].second = parent2;
+
+            if (unionTree[parent1].first == unionTree[parent2].first)
+            {
+                unionTree[parent2].first++;
+            }
+        }
+    }
+    
+    // 查找父亲节点
+    // 如果需要进一步加速就要使用路径压缩算法
+    int findParent(int index, vector<pair<int, int>>& unionTree)
+    {
+        int initIndex = index;
+        int pathLength = 0;
+
+        while (unionTree[index].second != index && unionTree[index].second != -1)
+        {
+            pathLength++;
+            index = unionTree[index].second;
+        }
+
+        if (pathLength > maxPathLength)
+        {
+            while (initIndex != index)
+            {
+                int temp = initIndex;
+                initIndex = unionTree[initIndex].second;
+                unionTree[temp].second = index;
+            }
+        }
+
+        return index;
+    }
+};

Surrounded Regions/Surrounded_Regions.py

@@ -0,0 +1,80 @@
+# Runtime: 256 ms, faster than 11.29% of Python3 online submissions for Surrounded Regions.
+# Memory Usage: 18.4 MB, less than 17.83% of Python3 online submissions for Surrounded Regionws.
+
+class Solution:
+    def __init__(self):
+        self.unionTree = None
+        self.maxPathLength = 3
+
+    def solve(self, grid: List[List[str]]) -> None:
+        """
+        Do not return anything, modify board in-place instead.
+        """
+
+        rows = len(grid)
+
+        if rows is 0:
+            return 0
+        
+        cols = len(grid[0])
+        if cols is 0:
+            return 0
+        
+        self.unionTree = [[1, index] for index in range(rows * cols + 1)]
+
+        for i in range(rows):
+            for j in range(cols):
+                if grid[i][j] == 'O':
+                     
+                    index1 = i * cols + j
+
+                    if (i == 0 or i == rows - 1 or j == 0 or j == cols - 1):
+                        index2 = rows * cols
+                        self.union(index1, index2)
+
+                    if i - 1 >= 0 and grid[i - 1][j] == '1':
+                        index2 = (i - 1) * cols + j
+                        self.union(index1, index2)
+                    
+                    if j - 1 >= 0 and grid[i][j - 1] == '1'":
+                        index2 = i * cols + (j - 1)
+                        self.union(index1, index2)
+                    
+
+        for i in range(rows):
+            for j in range(cols):
+                if grid[i][j] == 'O':
+                    if self.findParent(i * cols + j) != self.findParent(rows * cols):
+                        grid[i][j] = 'X'
+    
+    
+    def union(self, index1, index2):
+        parent1 = self.findParent(index1)
+        parent2 = self.findParent(index2)
+
+        if parent1 == parent2:
+            return
+        
+        if self.unionTree[parent1][0] > self.unionTree[parent2][0]:
+            self.unionTree[parent2][1] = parent1
+        else:
+            self.unionTree[parent1][1] = parent2
+
+            if self.unionTree[parent1][0] == self.unionTree[parent2][0]:
+                self.unionTree[parent2][0] += 1
+    
+    def findParent(self, index):
+        int initIndex = index
+        pathLength = 0
+
+        while self.unionTree[index][1] != index:
+            pathLength += 1
+            index = self.unionTree[index][1]
+        
+        if pathLength > self.maxPathLength:
+            while initIndex != index:
+                temp = initIndex
+                initIndex = self.unionTree[initIndex][1]
+                self.unionTree][temp][1] = index
+        
+        return index