add a solution for 547

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/firstthousand/_547.java

@@ -1,5 +1,10 @@
 package com.fishercoder.solutions.firstthousand;
 
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
 public class _547 {
 
     public static class Solution1 {
@@ -51,4 +56,48 @@ public int find(int[] ids, int i) {
             }
         }
     }
+
+    public static class Solution2 {
+        /**
+         * My original solution:
+         * The tricky part of this problem is you need to figure out the input, it's using i and j to denote vertex A and vertex B, then the 3rd value in each array denotes if there's an edge in between A and B.
+         * Draw it out on a whiteboard to visualize this input, it'll make sense immediately.
+         * Then you can apply the template of using BFS to traverse an un-directed graph to find all connected components.
+         */
+        public int findCircleNum(int[][] isConnected) {
+            List<List<Integer>> graph = new ArrayList<>();
+            int m = isConnected.length;
+            for (int i = 0; i < m; i++) {
+                graph.add(new ArrayList<>());
+            }
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < m; j++) {
+                    if (i != j && isConnected[i][j] == 1) {
+                        graph.get(i).add(j);
+                        graph.get(j).add(i);
+                    }
+                }
+            }
+            boolean[] visited = new boolean[m];
+            int count = 0;
+            for (int i = 0; i < m; i++) {
+                if (!visited[i]) {
+                    count++;
+                    Queue<Integer> queue = new LinkedList<>();
+                    queue.add(i);
+                    while (!queue.isEmpty()) {
+                        int cur = queue.poll();
+                        visited[cur] = true;
+                        for (int next : graph.get(cur)) {
+                            if (!visited[next]) {
+                                visited[next] = true;
+                                queue.add(next);
+                            }
+                        }
+                    }
+                }
+            }
+            return count;
+        }
+    }
 }

src/test/java/com/fishercoder/firstthousand/_547Test.java

@@ -6,68 +6,73 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-/** Created by fishercoder on 1/9/17. */
+/**
+ * Created by fishercoder on 1/9/17.
+ */
 public class _547Test {
-    private _547.Solution1 test;
+    private _547.Solution1 solution1;
+    private _547.Solution2 solution2;
     private static int expected;
     private static int actual;
     private static int[][] isConnected;
 
     @BeforeEach
     public void setup() {
-        test = new _547.Solution1();
+        solution1 = new _547.Solution1();
+        solution2 = new _547.Solution2();
     }
 
     @Test
     public void test1() {
         isConnected =
-                new int[][] {
-                    {1, 1, 0},
-                    {1, 1, 0},
-                    {0, 0, 1},
+                new int[][]{
+                        {1, 1, 0},
+                        {1, 1, 0},
+                        {0, 0, 1},
                 };
         expected = 2;
-        actual = test.findCircleNum(isConnected);
+        actual = solution1.findCircleNum(isConnected);
+        actual = solution2.findCircleNum(isConnected);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test2() {
         isConnected =
-                new int[][] {
-                    {1, 1, 0},
-                    {1, 1, 1},
-                    {0, 1, 1},
+                new int[][]{
+                        {1, 1, 0},
+                        {1, 1, 1},
+                        {0, 1, 1},
                 };
         expected = 1;
-        actual = test.findCircleNum(isConnected);
+        actual = solution1.findCircleNum(isConnected);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test3() {
         isConnected =
-                new int[][] {
-                    {1, 0, 0, 1},
-                    {0, 1, 1, 0},
-                    {0, 1, 1, 1},
-                    {1, 0, 1, 1},
+                new int[][]{
+                        {1, 0, 0, 1},
+                        {0, 1, 1, 0},
+                        {0, 1, 1, 1},
+                        {1, 0, 1, 1},
                 };
         expected = 1;
-        actual = test.findCircleNum(isConnected);
+        actual = solution1.findCircleNum(isConnected);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test4() {
         isConnected =
-                new int[][] {
-                    {1, 0, 0},
-                    {0, 1, 0},
-                    {0, 0, 1},
+                new int[][]{
+                        {1, 0, 0},
+                        {0, 1, 0},
+                        {0, 0, 1},
                 };
         expected = 3;
-        actual = test.findCircleNum(isConnected);
+        actual = solution1.findCircleNum(isConnected);
         assertEquals(expected, actual);
     }
 }