665_Non-decreasing_Array

qiyuangong · qiyuangong · commit 3bc837e73968 · 2019-07-07T22:45:46.000+08:00
diff --git a/README.md b/README.md
@@ -166,6 +166,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 617 | [Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/617_Merge_Two_Binary_Trees.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/617_Merge_Two_Binary_Trees.java) | Traverse both trees Recursion & Iterative (stack) |
 | 628 | [Maximum Product of Three Numbers](https://leetcode.com/problems/maximum-product-of-three-numbers/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/628_Maximum_Product_of_Three_Numbers.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/628_Maximum_Product_of_Three_Numbers.java) | Actually, we should only care about min1, min2 and max1-max3, to find these five elements, we can use 1. Brute force, O(n^3) and O(1)<br>2. Sort, O(nlogn) and O(1)<br>3. Single scan with 5 elements keep, O(n) and O(1) |
 | 654 | [Maximum Binary Tree](https://leetcode.com/problems/maximum-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/654_Maximum_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/654_Maximum_Binary_Tree.java) | 1. Divide and conquer, recursive, O(n^2)<br>2. Monotonic stack, O(n) |
+| 665 | [Non-decreasing Array](https://leetcode.com/problems/non-decreasing-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/665_Non-decreasing_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/665_Non-decreasing_Array.java) | 1. Find the broken index, then check this point, O(n) and O(1)<br>2. Replace broken point with correct value, then check if there are more than 1 broken point, O(n) and O(1) |
 | 671 | [Second Minimum Node In a Binary Tree](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/671_Second_Minimum_Node_In_a_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/671_Second_Minimum_Node_In_a_Binary_Tree.java) | Note that min value is root: 1. Get all values then find result, O(n) and O(n)<br>2. BFS or DFS traverse the tree, then find the reslut, O(n) and O(n)|
 | 674 | [Longest Continuous Increasing Subsequence](https://leetcode.com/problems/longest-continuous-increasing-subsequence/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/674_Longest_Continuous_Increasing_Subsequence.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/674_Longest_Continuous_Increasing_Subsequence.java) | Scan nums once, check nums[i] < nums[i+1], if not reset count, O(n) and O(1) |
 | 680 | [Valid Palindrome II](https://leetcode.com/problems/valid-palindrome-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/680_Valid_Palindrome_II.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/680_Valid_Palindrome_II.java) | Recursively check s[left == end, when not equal delete left or right. |
diff --git a/java/665_Non-decreasing_Array.java b/java/665_Non-decreasing_Array.java
@@ -0,0 +1,29 @@
+class Solution {
+    /* public boolean checkPossibility(int[] nums) {
+        int pos = -1;
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] > nums[i + 1]) {
+                // More than two broken points
+                if (pos != -1) return false;
+                pos = i;
+            }
+        }
+        if (pos == -1 || pos == 0 || pos == nums.length - 2) return true;
+        // Remove pos or pos + 1
+        return (nums[pos - 1] <= nums[pos + 1] || nums[pos] <= nums[pos + 2]);
+    } */
+
+    public boolean checkPossibility(int[] nums) {
+        int brokenPoint = 0;
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] > nums[i + 1]) {
+                brokenPoint++;
+                if (brokenPoint >= 2) return false;
+                // Remove i or remove i + 1
+                if (i - 1 < 0 || nums[i - 1] <= nums[i + 1]) nums[i] = nums[i + 1];
+                else nums[i + 1] = nums[i];
+            }
+        }
+        return true;
+    }
+}
diff --git a/python/665_Non-decreasing_Array.py b/python/665_Non-decreasing_Array.py
@@ -0,0 +1,38 @@
+class Solution(object):
+    # def checkPossibility(self, nums):
+    #     """
+    #     :type nums: List[int]
+    #     :rtype: bool
+    #     """
+    #     pos = None
+    #     # Check if there are more than 2 broken point
+    #     # record first index
+    #     for i in range(len(nums) - 1):
+    #         if nums[i] > nums[i + 1]:
+    #             if pos is not None:
+    #                 return False
+    #             pos = i
+    #     if pos is None or pos == 0 or pos == len(nums) - 2:
+    #         return True
+    #     # Remove pos or remove pos + 1
+    #     return (nums[pos - 1] <= nums[pos + 1] or nums[pos] <= nums[pos + 2])
+
+    def checkPossibility(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        """
+        # https://leetcode.com/problems/non-decreasing-array/discuss/106826/JavaC%2B%2B-Simple-greedy-like-solution-with-explanation
+        broken_num = 0
+        for i in range(len(nums) - 1):
+            if (nums[i] > nums[i + 1]):
+                broken_num += 1
+                if broken_num >= 2:
+                    return False
+                if (i - 1 < 0 or nums[i - 1] <= nums[i + 1]):
+                    # Remove i
+                    nums[i] = nums[i + 1]
+                else:
+                    # Remove i + 1
+                    nums[i + 1] = nums[i]
+        return True
