Solution is Added

Author: anjha1

0665.non-decreasing-array/NonDecreasingArray.java

@@ -0,0 +1,15 @@
+class NonDecreasingArray {
+    public boolean checkPossibility(int[] nums) {
+        int cnt = 0;
+        for (int i = 1; i < nums.length && cnt < 2; i++) {
+            if (nums[i] >= nums[i - 1]) continue;
+            cnt++;
+            if (i - 2 >= 0 && nums[i - 2] > nums[i]) {
+                nums[i] = nums[i - 1];
+            } else {
+                nums[i - 1] = nums[i];
+            }
+        }
+        return cnt <= 1;
+    }
+}

0665.non-decreasing-array/README.md

@@ -0,0 +1 @@
+# [665. Non-decreasing Array](https://leetcode.com/problems/non-decreasing-array/)

0667.beautiful-arrangement-ii/BeautifulArrangementIi.java

@@ -0,0 +1,13 @@
+class BeautifulArrangementIi {
+    public int[] constructArray(int n, int k) {
+        int[] ret = new int[n];
+        ret[0] = 1;
+        for (int i = 1, interval = k; i <= k; i++, interval--) {
+            ret[i] = i % 2 == 1 ? ret[i - 1] + interval : ret[i - 1] - interval;
+        }
+        for (int i = k + 1; i < n; i++) {
+            ret[i] = i + 1;
+        }
+        return ret;
+    }
+}

0667.beautiful-arrangement-ii/README.md

@@ -0,0 +1 @@
+# [667. Beautiful Arrangement II](https://leetcode.com/problems/beautiful-arrangement-ii/)

0669.trim-a-binary-search-tree/README.md

@@ -0,0 +1,2 @@
+# [669. Trim a Binary Search Tree](https://leetcode.com/problems/trim-a-binary-search-tree/)
+

0669.trim-a-binary-search-tree/TrimABinarySearchTree.java

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class TrimABinarySearchTree {
+    public TreeNode trimBST(TreeNode root, int low, int high) {
+        if (root == null) return root;
+        if (root.val > high) return trimBST(root.left, low, high);
+        if (root.val < low) return trimBST(root.right, low, high);
+        root.left = trimBST(root.left, low, high);
+        root.right = trimBST(root.right, low, high);
+        return root;
+    }
+}

0671.second-minimum-node-in-a-binary-tree/README.md

@@ -0,0 +1,2 @@
+# [671. Second Minimum Node In a Binary Tree](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/)
+

0671.second-minimum-node-in-a-binary-tree/SecondMinimumNodeInABinaryTree.java

@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class SecondMinimumNodeInABinaryTree {
+    public int findSecondMinimumValue(TreeNode root) {
+        if (root == null) return -1;
+        if (root.left == null && root.right == null) return -1;
+        int leftVal = root.left != null ? root.left.val : 0;
+        int rightVal = root.right != null ? root.right.val : 0;
+        if (leftVal == root.val) leftVal= findSecondMinimumValue(root.left);
+        if (rightVal == root.val) rightVal = findSecondMinimumValue(root.right);
+        if (leftVal != -1 && rightVal != -1) return Math.min(leftVal, rightVal);
+        if (leftVal != -1) return leftVal;
+        return rightVal;
+    }
+}

0677.map-sum-pairs/MapSumPairs.java

@@ -0,0 +1,57 @@
+class MapSum {
+    private class Node {
+        Node[] childs = new Node[26];
+        int value;
+    }
+
+    private Node root = new Node();
+
+    private int indexForChar(char c) {
+        return c - 'a';
+    }
+
+    public MapSum() {
+
+    }
+
+    private void insert(String key, Node node, int val) {
+        if (node == null) return;
+        if (key.length() == 0) {
+            node.value = val;
+            return;
+        }
+        int index = indexForChar(key.charAt(0));
+        if (node.childs[index] == null) {
+            node.childs[index] = new Node();
+        }
+        insert(key.substring(1), node.childs[index], val);
+    }
+    
+    public void insert(String key, int val) {
+        insert(key, root, val);
+    }
+
+    private int sum(String prefix, Node node) {
+        if (node == null) return 0;
+        if (prefix.length() != 0) {
+            int index = indexForChar(prefix.charAt(0));
+            return sum(prefix.substring(1), node.childs[index]);
+        }
+        int sum = node.value;
+        for (Node child : node.childs) {
+            sum += sum(prefix, child);
+        }
+        return sum;
+    }
+    
+    public int sum(String prefix) {
+        return sum(prefix, root);
+    }
+}
+
+/**
+ * Your MapSum object will be instantiated and called as such:
+ * MapSum obj = new MapSum();
+ * obj.insert(key,val);
+ * int param_2 = obj.sum(prefix);
+ */

0677.map-sum-pairs/README.md

@@ -0,0 +1,2 @@
+# [677. Map Sum Pairs](https://leetcode.com/problems/map-sum-pairs/)
+

0680.valid-palindrome-ii/README.md

@@ -0,0 +1,2 @@
+# [680. Valid Palindrome II](https://leetcode.com/problems/valid-palindrome-ii/)
+

0680.valid-palindrome-ii/ValidPalindromeIi.java

@@ -0,0 +1,23 @@
+class ValidPalindromeIi {
+    private boolean isPalindrome(String s, int i, int j) {
+        while (i < j) {
+            if (s.charAt(i++) != s.charAt(j--)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean validPalindrome(String s) {
+        int i = 0, j = s.length() - 1;
+        while (i < j) {
+            if (s.charAt(i) != s.charAt(j)) {
+                return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);
+            }
+            i++;
+            j--;
+        }
+
+        return true;
+    }
+}

0684.redundant-connection/README.md

@@ -0,0 +1,2 @@
+# [684. Redundant Connection](https://leetcode.com/problems/redundant-connection/)
+

0684.redundant-connection/RedundantConnection.java

@@ -0,0 +1,46 @@
+class RedundantConnection {
+    private class UF {
+        private int[] id;
+
+        UF(int N) {
+            id = new int[N + 1];
+            for (int i = 0; i < id.length; i++) {
+                id[i] = i;
+            }
+        }
+
+        int find (int p) {
+            return id[p];
+        }
+
+        void union(int u, int v) {
+            int uID = find(u);
+            int vID = find(v);
+            if (uID == vID) {
+                return;
+            }
+            for (int i = 0; i < id.length; i++) {
+                if (id[i] == uID) {
+                    id[i] = vID;
+                }
+            }
+        }
+
+        boolean connect(int u, int v) {
+            return find(u) == find(v);
+        }
+    }
+
+    public int[] findRedundantConnection(int[][] edges) {
+        int N = edges.length;
+        UF uf = new UF(N);
+        for (int[] e : edges) {
+            int u = e[0], v = e[1];
+            if (uf.connect(u, v)) {
+                return e;
+            }
+            uf.union(u, v);
+        }
+        return new int[]{-1, -1};
+    }
+}

0687.longest-univalue-path/LongestUnivaluePath.java

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class LongestUnivaluePath {
+    private int path = 0;
+
+    private int dfs(TreeNode root) {
+        if (root == null) return 0;
+        int left = dfs(root.left);
+        int right = dfs(root.right);
+        int leftPath = root.left != null && root.left.val == root.val ? left + 1 : 0;
+        int rightPath = root.right != null && root.right.val == root.val ? right + 1 : 0;
+        path = Math.max(path, leftPath + rightPath);
+        return Math.max(leftPath, rightPath);
+    }
+
+    public int longestUnivaluePath(TreeNode root) {
+        dfs(root);
+        return path;
+    }
+}

0687.longest-univalue-path/README.md

@@ -0,0 +1,2 @@
+# [687. Longest Univalue Path](https://leetcode.com/problems/longest-univalue-path/)
+

0692.top-k-frequent-words/README.md

@@ -0,0 +1,2 @@
+# [692. Top K Frequent Words](https://leetcode.com/problems/top-k-frequent-words/)
+

0692.top-k-frequent-words/TopKFrequentWords.java

@@ -0,0 +1,33 @@
+import java.util.*;
+
+class TopKFrequentWords {
+    public List<String> topKFrequent(String[] words, int k) {
+        Map<String, Integer> map = new HashMap<>();
+        for (String word : words) {
+            map.put(word, map.getOrDefault(word, 0) + 1);
+        }
+
+        PriorityQueue<Map.Entry<String, Integer>> pq = new PriorityQueue<>(new MyComparator());
+
+        for (Map.Entry<String, Integer> e : map.entrySet()) {
+            pq.offer(e);
+        }
+
+        List<String> res = new LinkedList<>();
+        for (int i = 0; i < k; i++) {
+            res.add(Objects.requireNonNull(pq.poll()).getKey());
+        }
+        return res;
+    }
+}
+
+class MyComparator implements Comparator<Map.Entry<String, Integer>> {
+    public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2){
+        String word1 = e1.getKey();
+        int freq1 = e1.getValue();
+        String word2 = e2.getKey();
+        int freq2 = e2.getValue();
+        if (freq1 != freq2) return freq2-freq1;
+        else return word1.compareTo(word2);
+    }
+}

0693.binary-number-with-alternating-bits/BinaryNumberWithAlternatingBits.java

@@ -0,0 +1,6 @@
+class BinaryNumberWithAlternatingBits {
+    public boolean hasAlternatingBits(int n) {
+        int a = (n ^ (n >> 1));
+        return (a & (a + 1)) == 0;
+    }
+}

0693.binary-number-with-alternating-bits/README.md

@@ -0,0 +1,2 @@
+# [693. Binary Number with Alternating Bits](https://leetcode.com/problems/binary-number-with-alternating-bits/)
+

0695.max-area-of-island/MaxAreaOfIsland.java

@@ -0,0 +1,23 @@
+class MaxAreaOfIsland {
+    private int maxAreaOfIslandHelper(int r, int c, int[][] grid) {
+        if (r < 0 || r == grid.length || c < 0 || c == grid[0].length || grid[r][c] == 0) return 0;
+        grid[r][c] = 0;
+        return 1 + maxAreaOfIslandHelper(r + 1, c, grid)
+                + maxAreaOfIslandHelper(r - 1, c , grid)
+                + maxAreaOfIslandHelper(r, c + 1, grid)
+                + maxAreaOfIslandHelper(r, c - 1, grid);
+    }
+
+    public int maxAreaOfIsland(int[][] grid) {
+        int maxArea = 0;
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1) {
+                    int area = maxAreaOfIslandHelper(i, j, grid);
+                    if (area > maxArea) maxArea = area;
+                }
+            }
+        }
+        return maxArea;
+    }
+}

0695.max-area-of-island/README.md

@@ -0,0 +1,2 @@
+# [695. Max Area of Island](https://leetcode.com/problems/max-area-of-island/)
+