add 851

Author: fishercoder1534

Diff for: paginated_contents/algorithms/1st_thousand/README.md

@@ -78,6 +78,7 @@
 | 859 | [Buddy Strings](https://leetcode.com/problems/buddy-strings/)                                                                                                                                 | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_859.java)                                                                  |                                                                               | Easy                             |
 | 856 | [Score of Parentheses](https://leetcode.com/problems/score-of-parentheses/)                                                                                                                   | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_856.java)                                                                  |                                                                               | Medium                           | Stack, String                                                        
 | 852 | [Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/)                                                                                               | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_852.java)                                                                  |                                                                               | Easy                             |
+| 851 | [Loud and Rich](https://leetcode.com/problems/loud-and-rich/)                                                                                               | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_851.java)                                                                  |                                                                               | Medium                           |Topological Sort
 | 849 | [Maximize Distance to Closest Person](https://leetcode.com/problems/maximize-distance-to-closest-person/)                                                                                     | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_849.java)                                                                  |                                                                               | Easy                             |
 | 848 | [Shifting Letters](https://leetcode.com/problems/shifting-letters/)                                                                                                                           | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_848.java)                                                                  |                                                                               | Medium                           | Array, String                                                        
 | 844 | [Backspace String Compare](https://leetcode.com/problems/backspace-string-compare/)                                                                                                           | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_844.java)                                                                  |                                                                               | Easy                             |

Diff for: src/main/java/com/fishercoder/solutions/firstthousand/_851.java

@@ -0,0 +1,57 @@
+package com.fishercoder.solutions.firstthousand;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class _851 {
+    public static class Solution1 {
+        /**
+         * My completely original solution. Practice does make perfect!
+         * Topological sort template does work well for this:
+         * 1. make variable names as descriptive as possible to help sort out your logic;
+         * 2. initializing an array of size n for topological sort problems of n nodes is pretty handy;
+         * 3. it's either indegree or outdegree, and each time, we process it, we decrement the degree by one, in this case, we also check the quietness;
+         * 4. overwrite the value for quiet[v] each time it needs to be updated so that next time around, it's not going to use outdated quietness value
+         */
+        public int[] loudAndRich(int[][] richer, int[] quiet) {
+            List<Integer>[] adjList = new ArrayList[quiet.length];
+            for (int i = 0; i < quiet.length; i++) {
+                adjList[i] = new ArrayList<>();
+            }
+            int[] indegree = new int[quiet.length];
+            if (richer.length != 0 && richer[0].length != 0) {
+                for (int[] rich : richer) {
+                    indegree[rich[1]]++;
+                    adjList[rich[0]].add(rich[1]);
+                }
+            }
+            Queue<Integer> q = new LinkedList<>();
+            int[] result = new int[quiet.length];
+            for (int i = 0; i < quiet.length; i++) {
+                if (indegree[i] == 0) {
+                    q.offer(i);
+                }
+                result[i] = i;
+            }
+            while (!q.isEmpty()) {
+                int curr = q.poll();
+                for (int v : adjList[curr]) {
+                    int quietnessForLessRichPerson = quiet[v];
+                    int quietnessForRicherPerson = quiet[result[curr]];
+                    if (quietnessForRicherPerson < quietnessForLessRichPerson) {
+                        result[v] = result[curr];
+                        //remember to update the quietness value for this node as well
+                        quiet[v] = quiet[curr];
+                    }
+                    indegree[v]--;
+                    if (indegree[v] == 0) {
+                        q.offer(v);
+                    }
+                }
+            }
+            return result;
+        }
+    }
+}

Diff for: src/test/java/com/fishercoder/firstthousand/_851Test.java

@@ -0,0 +1,47 @@
+package com.fishercoder.firstthousand;
+
+import com.fishercoder.solutions.firstthousand._851;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class _851Test {
+    private static _851.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _851.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertArrayEquals(new int[]{5, 5, 2, 5, 4, 5, 6, 7},
+                solution1.loudAndRich(new int[][]{
+                        {1, 0}, {2, 1}, {3, 1}, {3, 7}, {4, 3}, {5, 3}, {6, 3}
+                }, new int[]{3, 2, 5, 4, 6, 1, 7, 0}));
+    }
+
+    @Test
+    public void test2() {
+        assertArrayEquals(new int[]{0}, solution1.loudAndRich(new int[][]{{}}, new int[]{0}));
+    }
+
+    @Test
+    public void test3() {
+        assertArrayEquals(new int[]{0, 1}, solution1.loudAndRich(new int[][]{{}}, new int[]{0, 1}));
+    }
+
+    @Test
+    public void test4() {
+        assertArrayEquals(new int[]{0, 1}, solution1.loudAndRich(new int[][]{{}}, new int[]{1, 0}));
+    }
+
+    @Test
+    public void test5() {
+        assertArrayEquals(new int[]{0, 1, 0}, solution1.loudAndRich(new int[][]{
+                {0, 2}, {1, 2}
+        }, new int[]{0, 1, 2}));
+    }
+
+}