Merge branch 'master' of https://github.com/fishercoder1534/Leetcode

# Conflicts:
#	README.md

Author: ankitprahladsoni

README.md

@@ -0,0 +1,48 @@
+package com.fishercoder.solutions;
+
+import java.util.Arrays;
+
+/**
+ * 1029. Two City Scheduling
+ *
+ * There are 2N people a company is planning to interview.
+ * The cost of flying the i-th person to city A is costs[i][0], and the cost of flying the i-th person to city B is costs[i][1].
+ * Return the minimum cost to fly every person to a city such that exactly N people arrive in each city.
+ *
+ * Example 1:
+ *
+ * Input: [[10,20],[30,200],[400,50],[30,20]]
+ * Output: 110
+ * Explanation:
+ * The first person goes to city A for a cost of 10.
+ * The second person goes to city A for a cost of 30.
+ * The third person goes to city B for a cost of 50.
+ * The fourth person goes to city B for a cost of 20.
+ *
+ * The total minimum cost is 10 + 30 + 50 + 20 = 110 to have half the people interviewing in each city.
+ *
+ * Note:
+ *
+ * 1 <= costs.length <= 100
+ * It is guaranteed that costs.length is even.
+ * 1 <= costs[i][0], costs[i][1] <= 1000
+ * */
+public class _1029 {
+    public static class Solution1 {
+        /**credit: https://leetcode.com/problems/two-city-scheduling/discuss/280173/Java-4-lines-intuitive-solution
+         * and
+         * https://leetcode.com/problems/two-city-scheduling/discuss/278771/Java-sort-solution*/
+        public int twoCitySchedCost(int[][] costs) {
+            Arrays.sort(costs, (a, b) -> (a[0] - a[1] - (b[0] - b[1])));
+            int cost = 0;
+            for (int i = 0; i < costs.length; i++) {
+                if (i < costs.length / 2) {
+                    cost += costs[i][0];
+                } else {
+                    cost += costs[i][1];
+                }
+            }
+            return cost;
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+/**
+ * 1038. Binary Search Tree to Greater Sum Tree
+ *
+ * Given the root of a binary search tree with distinct values,
+ * modify it so that every node has a new value equal to the sum of the values of the original tree that are greater than or equal to node.val.
+ * As a reminder, a binary search tree is a tree that satisfies these constraints:
+ *
+ * The left subtree of a node contains only nodes with keys less than the node's key.
+ * The right subtree of a node contains only nodes with keys greater than the node's key.
+ * Both the left and right subtrees must also be binary search trees.
+ *
+ *
+ * Example 1:
+ *                            4(30)
+ *                          /    \
+ *                       1(36)   6(21)
+ *                     /   \     /    \
+ *                 0(36)  2(35) 5(26) 7(15)
+ *                          \          \
+ *                        3(33)        8(8)
+ *
+ * Input: [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
+ * Output: [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
+ *
+ *
+ * Note:
+ *
+ * The number of nodes in the tree is between 1 and 100.
+ * Each node will have value between 0 and 100.
+ * The given tree is a binary search tree.*/
+public class _1038 {
+    public static class Solution1 {
+        /**credit: https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/discuss/286725/JavaC%2B%2BPython-Revered-Inorder-Traversal*/
+        int greaterSum = 0;
+
+        public TreeNode bstToGst(TreeNode root) {
+            if (root.right != null) {
+                bstToGst(root.right);
+            }
+            greaterSum = root.val = greaterSum + root.val;
+            if (root.left != null) {
+                bstToGst(root.left);
+            }
+            return root;
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.fishercoder.solutions;
+
+import java.util.Arrays;
+
+/**
+ * 1051. Height Checker
+ *
+ * Students are asked to stand in non-decreasing order of heights for an annual photo.
+ * Return the minimum number of students not standing in the right positions.
+ * (This is the number of students that must move in order for all students to be standing in non-decreasing order of height.)
+ *
+ * Example 1:
+ * Input: [1,1,4,2,1,3]
+ * Output: 3
+ * Explanation:
+ * Students with heights 4, 3 and the last 1 are not standing in the right positions.
+ *
+ * Note:
+ *
+ * 1 <= heights.length <= 100
+ * 1 <= heights[i] <= 100
+ * */
+public class _1051 {
+    public static class Solution1 {
+        public int heightChecker(int[] heights) {
+            int[] originals = Arrays.copyOf(heights, heights.length);
+            Arrays.sort(heights);
+            int count = 0;
+            for (int i = 0; i < originals.length; i++) {
+                if (heights[i] != originals[i]) {
+                    count++;
+                }
+            }
+            return count;
+        }
+    }
+}

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

@@ -1,22 +1,22 @@
 package com.fishercoder.solutions;
 
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 /**
+ * 500. Keyboard Row
+ *
  * Given a List of words, return the words that can be typed using letters of alphabet on only one row's of American keyboard like the image below.
- * <p>
- * <p>
+ *
  * American keyboard
- * <p>
- * <p>
+ *
  * Example 1:
  * Input: ["Hello", "Alaska", "Dad", "Peace"]
  * Output: ["Alaska", "Dad"]
+ *
  * Note:
  * You may use one character in the keyboard more than once.
  * You may assume the input string will only contain letters of alphabet.

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

@@ -9,7 +9,6 @@
 import java.util.Map;
 import java.util.Queue;
 
-
 /**
  * 501. Find Mode in Binary Search Tree
  * Given a binary search tree with duplicates. You have to find all the mode(s) in given binary tree.

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

@@ -29,23 +29,27 @@
  */
 public class _502 {
 
-    /**credit: https://discuss.leetcode.com/topic/77768/very-simple-greedy-java-solution-using-two-priorityqueues*/
-    public int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {
-        PriorityQueue<int[]> capitalHeap = new PriorityQueue<>((a, b) -> a[0] - b[0]);
-        PriorityQueue<int[]> profitHeap = new PriorityQueue<>((a,b) -> b[1] - a[1]);
-        for (int i = 0; i < Profits.length; i++) {
-            capitalHeap.add(new int[]{Capital[i], Profits[i]});
-        }
-        while (k-- > 0) {
-            while (!capitalHeap.isEmpty() && capitalHeap.peek()[0] <= W) {
-                profitHeap.add(capitalHeap.poll());
+    public static class Solution1 {
+        /**
+         * credit: https://discuss.leetcode.com/topic/77768/very-simple-greedy-java-solution-using-two-priorityqueues
+         */
+        public int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {
+            PriorityQueue<int[]> capitalHeap = new PriorityQueue<>((a, b) -> a[0] - b[0]);
+            PriorityQueue<int[]> profitHeap = new PriorityQueue<>((a, b) -> b[1] - a[1]);
+            for (int i = 0; i < Profits.length; i++) {
+                capitalHeap.add(new int[]{Capital[i], Profits[i]});
             }
-            if (profitHeap.isEmpty()) {
-                break;
+            while (k-- > 0) {
+                while (!capitalHeap.isEmpty() && capitalHeap.peek()[0] <= W) {
+                    profitHeap.add(capitalHeap.poll());
+                }
+                if (profitHeap.isEmpty()) {
+                    break;
+                }
+                W += profitHeap.poll()[1];
             }
-            W += profitHeap.poll()[1];
+            return W;
         }
-        return W;
     }
 
 }

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

@@ -3,6 +3,8 @@
 import java.util.Stack;
 
 /**
+ * 503. Next Greater Element II
+ *
  * Given a circular array (the next element of the last element is the first element of the array),
  * print the Next Greater Number for every element.
  * The Next Greater Number of a number x is the first greater number to its traversing-order next in the array,
@@ -18,45 +20,53 @@
  */
 public class _503 {
 
-    //Credit: https://discuss.leetcode.com/topic/77881/typical-ways-to-solve-circular-array-problems-java-solution
-    //Note: we store INDEX into the stack, reversely, the larger index put at the bottom of the stack, the smaller index at the top
-    public int[] nextGreaterElements(int[] nums) {
-        if (nums == null || nums.length == 0) {
-            return nums;
-        }
-        int len = nums.length;
-        Stack<Integer> stack = new Stack<>();
-        for (int i = len - 1; i >= 0; i--) {
-            stack.push(i);
-            //push all indexes into the stack reversely
-        }
-        int[] result = new int[len];
-        for (int i = len - 1; i >= 0; i--) {
-            result[i] = -1;
-            //initialize it to be -1 in case we cannot find its next greater element in the array
-            while (!stack.isEmpty() && (nums[stack.peek()] <= nums[i])) {
-                stack.pop();
+    public static class Solution1 {
+        /**
+         * Credit: https://discuss.leetcode.com/topic/77881/typical-ways-to-solve-circular-array-problems-java-solution
+         * Note: we store INDEX into the stack, reversely, the larger index put at the bottom of the stack, the smaller index at the top
+         */
+        public int[] nextGreaterElements(int[] nums) {
+            if (nums == null || nums.length == 0) {
+                return nums;
+            }
+            int len = nums.length;
+            Stack<Integer> stack = new Stack<>();
+            for (int i = len - 1; i >= 0; i--) {
+                stack.push(i);
+                //push all indexes into the stack reversely
             }
-            if (!stack.isEmpty()) {
-                result[i] = nums[stack.peek()];
+            int[] result = new int[len];
+            for (int i = len - 1; i >= 0; i--) {
+                result[i] = -1;
+                //initialize it to be -1 in case we cannot find its next greater element in the array
+                while (!stack.isEmpty() && (nums[stack.peek()] <= nums[i])) {
+                    stack.pop();
+                }
+                if (!stack.isEmpty()) {
+                    result[i] = nums[stack.peek()];
+                }
+                stack.push(i);
             }
-            stack.push(i);
+            return result;
         }
-        return result;
     }
 
-    //credit: https://leetcode.com/articles/next-greater-element-ii/
-    public int[] nextGreaterElements_editorial_solution(int[] nums) {
-        int[] result = new int[nums.length];
-        Stack<Integer> stack = new Stack<>();
-        for (int i = nums.length * 2 - 1; i >= 0; i--) {
-            while (!stack.isEmpty() && nums[stack.peek()] <= nums[i % nums.length]) {
-                stack.pop();
+    public static class Solution2 {
+        /**
+         * credit: https://leetcode.com/articles/next-greater-element-ii/
+         */
+        public int[] nextGreaterElements(int[] nums) {
+            int[] result = new int[nums.length];
+            Stack<Integer> stack = new Stack<>();
+            for (int i = nums.length * 2 - 1; i >= 0; i--) {
+                while (!stack.isEmpty() && nums[stack.peek()] <= nums[i % nums.length]) {
+                    stack.pop();
+                }
+                result[i % nums.length] = stack.isEmpty() ? -1 : nums[stack.peek()];
+                stack.push(i % nums.length);
             }
-            result[i % nums.length] = stack.isEmpty() ? -1 : nums[stack.peek()];
-            stack.push(i % nums.length);
+            return result;
         }
-        return result;
     }
 
 }

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

@@ -1,11 +1,13 @@
 package com.fishercoder.solutions;
 
 /**
+ * 504. Base 7
+ *
  * Given an integer, return its base 7 string representation.
-
  Example 1:
  Input: 100
  Output: "202"
+
  Example 2:
  Input: -7
  Output: "-10"
@@ -14,7 +16,9 @@
  */
 public class _504 {
 
-    public String convertToBase7(int num) {
-        return String.valueOf(Integer.toString(num, 7));
+    public static class Solution1 {
+        public String convertToBase7(int num) {
+            return String.valueOf(Integer.toString(num, 7));
+        }
     }
 }