add 997

Author: fishercoder1534

README.md

@@ -27,6 +27,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
+|997|[Find the Town Judge](https://leetcode.com/problems/find-the-town-judge/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_997.java) | O(n) | O(n) | |Easy| 
 |994|[Rotting Oranges](https://leetcode.com/problems/rotting-oranges/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_994.java) | O(m*2*n*2) | O(m*n) | |Easy| BFS
 |993|[Cousins in Binary Tree](https://leetcode.com/problems/cousins-in-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_993.java) | O(n) | O(m) (m is length of the nodes that has the max number of nodes on the same level) | |Easy| Tree, BFS
 |989|[Add to Array-Form of Integer](https://leetcode.com/problems/add-to-array-form-of-integer/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_989.java) | O(max(N, logk)) | O(max(N, logk)) | |Easy| Array

src/main/java/com/fishercoder/solutions/_997.java

@@ -0,0 +1,67 @@
+package com.fishercoder.solutions;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * 997. Find the Town Judge
+ *
+ * In a town, there are N people labelled from 1 to N.
+ * There is a rumor that one of these people is secretly the town judge.
+ *
+ * If the town judge exists, then:
+ *
+ * The town judge trusts nobody.
+ * Everybody (except for the town judge) trusts the town judge.
+ * There is exactly one person that satisfies properties 1 and 2.
+ * You are given trust, an array of pairs trust[i] = [a, b] representing that the person labelled a trusts the person labelled b.
+ *
+ * If the town judge exists and can be identified, return the label of the town judge.
+ * Otherwise, return -1.
+ *
+ * Example 1:
+ * Input: N = 2, trust = [[1,2]]
+ * Output: 2
+ *
+ * Example 2:
+ * Input: N = 3, trust = [[1,3],[2,3]]
+ * Output: 3
+ *
+ * Example 3:
+ * Input: N = 3, trust = [[1,3],[2,3],[3,1]]
+ * Output: -1
+ *
+ * Example 4:
+ * Input: N = 3, trust = [[1,2],[2,3]]
+ * Output: -1
+ *
+ * Example 5:
+ * Input: N = 4, trust = [[1,3],[1,4],[2,3],[2,4],[4,3]]
+ * Output: 3
+ *
+ * Note:
+ * 1 <= N <= 1000
+ * trust.length <= 10000
+ * trust[i] are all different
+ * trust[i][0] != trust[i][1]
+ * 1 <= trust[i][0], trust[i][1] <= N
+ */
+public class _997 {
+  public static class Solution1 {
+    public int findJudge(int N, int[][] trust) {
+      int[] trustPoints = new int[N];
+      Set<Integer> trustOthers = new HashSet<>();
+      for (int[] eachTrust : trust) {
+        trustPoints[eachTrust[1] - 1]++;
+        trustOthers.add(eachTrust[0]);
+      }
+      int judge = -1;
+      for (int i = 0; i < trustPoints.length; i++) {
+        if (trustPoints[i] == N - 1 && !trustOthers.contains(i + 1)) {
+            judge = i + 1;
+        }
+      }
+      return judge;
+    }
+  }
+}

src/test/java/com/fishercoder/_997Test.java

@@ -0,0 +1,53 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._997;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _997Test {
+  private static _997.Solution1 solution1;
+  private static int[][] trust;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _997.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    trust = new int[][] {{1, 2}};
+    assertEquals(2, solution1.findJudge(2, trust));
+  }
+
+  @Test
+  public void test2() {
+    trust = new int[][] {{1, 3}, {2, 3}};
+    assertEquals(3, solution1.findJudge(3, trust));
+  }
+
+  @Test
+  public void test3() {
+    trust = new int[][] {{1, 2}, {2, 3}, {3, 1}};
+    assertEquals(-1, solution1.findJudge(3, trust));
+  }
+
+  @Test
+  public void test4() {
+    trust = new int[][] {{1, 2}, {2, 3}};
+    assertEquals(-1, solution1.findJudge(3, trust));
+  }
+
+  @Test
+  public void test5() {
+    trust = new int[][] {{1, 3}, {1, 4}, {2, 3}, {2, 4}, {4, 3}};
+    assertEquals(3, solution1.findJudge(4, trust));
+  }
+
+  @Test
+  public void test6() {
+    trust = new int[][] {{1, 3}, {2, 3}, {3, 1}};
+    assertEquals(-1, solution1.findJudge(3, trust));
+  }
+}