feat: update solutions to lc problems: No.0547,0684

yanglbme · yanglbme · commit 34e3e805e965 · 2021-09-10T20:22:43.000+08:00
diff --git a/solution/0500-0599/0547.Number of Provinces/README.md b/solution/0500-0599/0547.Number of Provinces/README.md
@@ -236,37 +236,27 @@ class Solution {
 public:
     vector<int> p;
 
-    int findCircleNum(vector<vector<int>> &isConnected) {
+    int findCircleNum(vector<vector<int>>& isConnected) {
         int n = isConnected.size();
         p.resize(n);
-        for (int i = 0; i < n; ++i)
-        {
-            p[i] = i;
-        }
+        for (int i = 0; i < n; ++i) p[i] = i;
         for (int i = 0; i < n; ++i)
         {
             for (int j = 0; j < n; ++j)
             {
-                if (isConnected[i][j])
-                {
-                    p[find(i)] = find(j);
-                }
+                if (i != j && isConnected[i][j] == 1) p[find(i)] = find(j);
             }
         }
         int cnt = 0;
         for (int i = 0; i < n; ++i)
         {
-            if (i == find(i))
-                ++cnt;
+            if (i == find(i)) ++cnt;
         }
         return cnt;
     }
 
     int find(int x) {
-        if (p[x] != x)
-        {
-            p[x] = find(p[x]);
-        }
+        if (p[x] != x) p[x] = find(p[x]);
         return p[x];
     }
 };
diff --git a/solution/0500-0599/0547.Number of Provinces/README_EN.md b/solution/0500-0599/0547.Number of Provinces/README_EN.md
@@ -152,37 +152,27 @@ class Solution {
 public:
     vector<int> p;
 
-    int findCircleNum(vector<vector<int>> &isConnected) {
+    int findCircleNum(vector<vector<int>>& isConnected) {
         int n = isConnected.size();
         p.resize(n);
-        for (int i = 0; i < n; ++i)
-        {
-            p[i] = i;
-        }
+        for (int i = 0; i < n; ++i) p[i] = i;
         for (int i = 0; i < n; ++i)
         {
             for (int j = 0; j < n; ++j)
             {
-                if (isConnected[i][j])
-                {
-                    p[find(i)] = find(j);
-                }
+                if (i != j && isConnected[i][j] == 1) p[find(i)] = find(j);
             }
         }
         int cnt = 0;
         for (int i = 0; i < n; ++i)
         {
-            if (i == find(i))
-                ++cnt;
+            if (i == find(i)) ++cnt;
         }
         return cnt;
     }
 
     int find(int x) {
-        if (p[x] != x)
-        {
-            p[x] = find(p[x]);
-        }
+        if (p[x] != x) p[x] = find(p[x]);
         return p[x];
     }
 };
diff --git a/solution/0500-0599/0547.Number of Provinces/Solution.cpp b/solution/0500-0599/0547.Number of Provinces/Solution.cpp
@@ -2,37 +2,27 @@ class Solution {
 public:
     vector<int> p;
 
-    int findCircleNum(vector<vector<int>> &isConnected) {
+    int findCircleNum(vector<vector<int>>& isConnected) {
         int n = isConnected.size();
         p.resize(n);
-        for (int i = 0; i < n; ++i)
-        {
-            p[i] = i;
-        }
+        for (int i = 0; i < n; ++i) p[i] = i;
         for (int i = 0; i < n; ++i)
         {
             for (int j = 0; j < n; ++j)
             {
-                if (isConnected[i][j])
-                {
-                    p[find(i)] = find(j);
-                }
+                if (i != j && isConnected[i][j] == 1) p[find(i)] = find(j);
             }
         }
         int cnt = 0;
         for (int i = 0; i < n; ++i)
         {
-            if (i == find(i))
-                ++cnt;
+            if (i == find(i)) ++cnt;
         }
         return cnt;
     }
 
     int find(int x) {
-        if (p[x] != x)
-        {
-            p[x] = find(p[x]);
-        }
+        if (p[x] != x) p[x] = find(p[x]);
         return p[x];
     }
 };
diff --git a/solution/0600-0699/0684.Redundant Connection/README.md b/solution/0600-0699/0684.Redundant Connection/README.md
@@ -118,13 +118,13 @@ d[find(a)] = distance
 ```python
 class Solution:
     def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
-        p = [i for i in range(1010)]
+        p = list(range(1010))
 
         def find(x):
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
-
+        
         for a, b in edges:
             if find(a) == find(b):
                 return [a, b]
@@ -170,28 +170,19 @@ class Solution {
 public:
     vector<int> p;
 
-    vector<int> findRedundantConnection(vector<vector<int>> &edges) {
+    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
         p.resize(1010);
-        for (int i = 0; i < p.size(); ++i)
-        {
-            p[i] = i;
-        }
+        for (int i = 0; i < p.size(); ++i) p[i] = i;
         for (auto e : edges)
         {
-            if (find(e[0]) == find(e[1]))
-            {
-                return e;
-            }
+            if (find(e[0]) == find(e[1])) return e;
             p[find(e[0])] = find(e[1]);
         }
         return {};
     }
 
     int find(int x) {
-        if (p[x] != x)
-        {
-            p[x] = find(p[x]);
-        }
+        if (p[x] != x) p[x] = find(p[x]);
         return p[x];
     }
 };
diff --git a/solution/0600-0699/0684.Redundant Connection/README_EN.md b/solution/0600-0699/0684.Redundant Connection/README_EN.md
@@ -87,13 +87,13 @@ We have overhauled the problem description + test cases and specified clearly th
 ```python
 class Solution:
     def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
-        p = [i for i in range(1010)]
+        p = list(range(1010))
 
         def find(x):
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
-
+        
         for a, b in edges:
             if find(a) == find(b):
                 return [a, b]
@@ -137,28 +137,19 @@ class Solution {
 public:
     vector<int> p;
 
-    vector<int> findRedundantConnection(vector<vector<int>> &edges) {
+    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
         p.resize(1010);
-        for (int i = 0; i < p.size(); ++i)
-        {
-            p[i] = i;
-        }
+        for (int i = 0; i < p.size(); ++i) p[i] = i;
         for (auto e : edges)
         {
-            if (find(e[0]) == find(e[1]))
-            {
-                return e;
-            }
+            if (find(e[0]) == find(e[1])) return e;
             p[find(e[0])] = find(e[1]);
         }
         return {};
     }
 
     int find(int x) {
-        if (p[x] != x)
-        {
-            p[x] = find(p[x]);
-        }
+        if (p[x] != x) p[x] = find(p[x]);
         return p[x];
     }
 };
diff --git a/solution/0600-0699/0684.Redundant Connection/Solution.cpp b/solution/0600-0699/0684.Redundant Connection/Solution.cpp
@@ -2,28 +2,19 @@ class Solution {
 public:
     vector<int> p;
 
-    vector<int> findRedundantConnection(vector<vector<int>> &edges) {
+    vector<int> findRedundantConnection(vector<vector<int>>& edges) {
         p.resize(1010);
-        for (int i = 0; i < p.size(); ++i)
-        {
-            p[i] = i;
-        }
+        for (int i = 0; i < p.size(); ++i) p[i] = i;
         for (auto e : edges)
         {
-            if (find(e[0]) == find(e[1]))
-            {
-                return e;
-            }
+            if (find(e[0]) == find(e[1])) return e;
             p[find(e[0])] = find(e[1]);
         }
         return {};
     }
 
     int find(int x) {
-        if (p[x] != x)
-        {
-            p[x] = find(p[x]);
-        }
+        if (p[x] != x) p[x] = find(p[x]);
         return p[x];
     }
 };
diff --git a/solution/0600-0699/0684.Redundant Connection/Solution.py b/solution/0600-0699/0684.Redundant Connection/Solution.py
@@ -1,6 +1,6 @@
 class Solution:
     def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
-        p = [i for i in range(1010)]
+        p = list(range(1010))
 
         def find(x):
             if p[x] != x:

Original file line number	Diff line number	Diff line change
`@@ -236,37 +236,27 @@ class Solution {`
`236`	`236`	`public:`
`237`	`237`	`vector<int> p;`
`238`	`238`
`239`		`- int findCircleNum(vector<vector<int>> &isConnected) {`
	`239`	`+ int findCircleNum(vector<vector<int>>& isConnected) {`
`240`	`240`	`int n = isConnected.size();`
`241`	`241`	`p.resize(n);`
`242`		`- for (int i = 0; i < n; ++i)`
`243`		`- {`
`244`		`- p[i] = i;`
`245`		`- }`
	`242`	`+ for (int i = 0; i < n; ++i) p[i] = i;`
`246`	`243`	`for (int i = 0; i < n; ++i)`
`247`	`244`	`{`
`248`	`245`	`for (int j = 0; j < n; ++j)`
`249`	`246`	`{`
`250`		`- if (isConnected[i][j])`
`251`		`- {`
`252`		`- p[find(i)] = find(j);`
`253`		`- }`
	`247`	`+ if (i != j && isConnected[i][j] == 1) p[find(i)] = find(j);`
`254`	`248`	`}`
`255`	`249`	`}`
`256`	`250`	`int cnt = 0;`
`257`	`251`	`for (int i = 0; i < n; ++i)`
`258`	`252`	`{`
`259`		`- if (i == find(i))`
`260`		`- ++cnt;`
	`253`	`+ if (i == find(i)) ++cnt;`
`261`	`254`	`}`
`262`	`255`	`return cnt;`
`263`	`256`	`}`
`264`	`257`
`265`	`258`	`int find(int x) {`
`266`		`- if (p[x] != x)`
`267`		`- {`
`268`		`- p[x] = find(p[x]);`
`269`		`- }`
	`259`	`+ if (p[x] != x) p[x] = find(p[x]);`
`270`	`260`	`return p[x];`
`271`	`261`	`}`
`272`	`262`	`};`
Original file line number	Diff line number	Diff line change
`@@ -152,37 +152,27 @@ class Solution {`
`152`	`152`	`public:`
`153`	`153`	`vector<int> p;`
`154`	`154`
`155`		`- int findCircleNum(vector<vector<int>> &isConnected) {`
	`155`	`+ int findCircleNum(vector<vector<int>>& isConnected) {`
`156`	`156`	`int n = isConnected.size();`
`157`	`157`	`p.resize(n);`
`158`		`- for (int i = 0; i < n; ++i)`
`159`		`- {`
`160`		`- p[i] = i;`
`161`		`- }`
	`158`	`+ for (int i = 0; i < n; ++i) p[i] = i;`
`162`	`159`	`for (int i = 0; i < n; ++i)`
`163`	`160`	`{`
`164`	`161`	`for (int j = 0; j < n; ++j)`
`165`	`162`	`{`
`166`		`- if (isConnected[i][j])`
`167`		`- {`
`168`		`- p[find(i)] = find(j);`
`169`		`- }`
	`163`	`+ if (i != j && isConnected[i][j] == 1) p[find(i)] = find(j);`
`170`	`164`	`}`
`171`	`165`	`}`
`172`	`166`	`int cnt = 0;`
`173`	`167`	`for (int i = 0; i < n; ++i)`
`174`	`168`	`{`
`175`		`- if (i == find(i))`
`176`		`- ++cnt;`
	`169`	`+ if (i == find(i)) ++cnt;`
`177`	`170`	`}`
`178`	`171`	`return cnt;`
`179`	`172`	`}`
`180`	`173`
`181`	`174`	`int find(int x) {`
`182`		`- if (p[x] != x)`
`183`		`- {`
`184`		`- p[x] = find(p[x]);`
`185`		`- }`
	`175`	`+ if (p[x] != x) p[x] = find(p[x]);`
`186`	`176`	`return p[x];`
`187`	`177`	`}`
`188`	`178`	`};`
Original file line number	Diff line number	Diff line change
`@@ -2,37 +2,27 @@ class Solution {`
`2`	`2`	`public:`
`3`	`3`	`vector<int> p;`
`4`	`4`
`5`		`- int findCircleNum(vector<vector<int>> &isConnected) {`
	`5`	`+ int findCircleNum(vector<vector<int>>& isConnected) {`
`6`	`6`	`int n = isConnected.size();`
`7`	`7`	`p.resize(n);`
`8`		`- for (int i = 0; i < n; ++i)`
`9`		`- {`
`10`		`- p[i] = i;`
`11`		`- }`
	`8`	`+ for (int i = 0; i < n; ++i) p[i] = i;`
`12`	`9`	`for (int i = 0; i < n; ++i)`
`13`	`10`	`{`
`14`	`11`	`for (int j = 0; j < n; ++j)`
`15`	`12`	`{`
`16`		`- if (isConnected[i][j])`
`17`		`- {`
`18`		`- p[find(i)] = find(j);`
`19`		`- }`
	`13`	`+ if (i != j && isConnected[i][j] == 1) p[find(i)] = find(j);`
`20`	`14`	`}`
`21`	`15`	`}`
`22`	`16`	`int cnt = 0;`
`23`	`17`	`for (int i = 0; i < n; ++i)`
`24`	`18`	`{`
`25`		`- if (i == find(i))`
`26`		`- ++cnt;`
	`19`	`+ if (i == find(i)) ++cnt;`
`27`	`20`	`}`
`28`	`21`	`return cnt;`
`29`	`22`	`}`
`30`	`23`
`31`	`24`	`int find(int x) {`
`32`		`- if (p[x] != x)`
`33`		`- {`
`34`		`- p[x] = find(p[x]);`
`35`		`- }`
	`25`	`+ if (p[x] != x) p[x] = find(p[x]);`
`36`	`26`	`return p[x];`
`37`	`27`	`}`
`38`	`28`	`};`