add 665

Author: fishercoder1534

README.md

@@ -22,6 +22,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
+|665|[Non-decreasing Array](https://leetcode.com/problems/non-decreasing-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_665.java) | O(n) | O(n) | Easy |
 |664|[Strange Printer](https://leetcode.com/problems/strange-printer/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_664.java) | O(n^3) | O(n^2) | Hard | DP
 |663|[Equal Tree Partition](https://leetcode.com/problems/equal-tree-partition/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_663.java) | O(n) | O(n) | Medium | Tree
 |662|[Maximum Width of Binary Tree](https://leetcode.com/problems/maximum-width-of-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_662.java) | O(n) | O(k) | Medium | BFS, DFS

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

@@ -0,0 +1,85 @@
+package com.fishercoder.solutions;
+
+/**
+ * 665. Non-decreasing Array
+ *
+ *  Given an array with n integers, your task is to check if it could become non-decreasing by modifying at most 1 element.
+
+ We define an array is non-decreasing if array[i] <= array[i + 1] holds for every i (1 <= i < n).
+
+ Example 1:
+
+ Input: [4,2,3]
+ Output: True
+ Explanation: You could modify the first 4 to 1 to get a non-decreasing array.
+
+ Example 2:
+
+ Input: [4,2,1]
+ Output: False
+ Explanation: You can't get a non-decreasing array by modify at most one element.
+
+ Note: The n belongs to [1, 10,000].
+ */
+public class _665 {
+
+    public static class Solution1 {
+        public boolean checkPossibility(int[] nums) {
+            return modifyIMinusOne(nums) || modifyI(nums);
+        }
+
+        private boolean modifyI(int[] nums) {
+            int[] tmp = nums.clone();
+            int len = tmp.length;
+            int modifyTimes = 0;
+            for (int i = 1; i < len; i++) {
+                if (tmp[i] == tmp[i - 1]) {
+                    continue;
+                }
+                if (tmp[i] < tmp[i - 1]) {
+                    modifyTimes++;
+                    if (modifyTimes > 1) {
+                        return false;
+                    }
+                    tmp[i] = tmp[i - 1];
+                }
+            }
+            for (int i = 1; i < len; i++) {
+                if (tmp[i] == tmp[i - 1]) {
+                    continue;
+                }
+                if (tmp[i] < tmp[i - 1]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private boolean modifyIMinusOne(int[] nums) {
+            int[] tmp = nums.clone();
+            int len = tmp.length;
+            int modifyTimes = 0;
+            for (int i = 1; i < len; i++) {
+                if (tmp[i] == tmp[i - 1]) {
+                    continue;
+                }
+                if (tmp[i] < tmp[i - 1]) {
+                    modifyTimes++;
+                    if (modifyTimes > 1) {
+                        return false;
+                    }
+                    tmp[i - 1] = tmp[i];
+                }
+            }
+            for (int i = 1; i < len; i++) {
+                if (tmp[i] == tmp[i - 1]) {
+                    continue;
+                }
+                if (tmp[i] < tmp[i - 1]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}

src/test/java/com/fishercoder/_665Test.java

@@ -0,0 +1,78 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._665;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _665Test {
+    private static _665.Solution1 solution1;
+    private static int[] nums;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _665.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        nums = new int[]{4, 2, 3};
+        assertEquals(true, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test2() {
+        nums = new int[]{4, 2, 1};
+        assertEquals(false, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test3() {
+        nums = new int[]{3, 4, 2, 3};
+        assertEquals(false, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test4() {
+        nums = new int[]{2, 3, 3, 2, 4};
+        assertEquals(true, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test5() {
+        nums = new int[]{2, 3, 3, 2, 2, 4};
+        assertEquals(false, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test6() {
+        nums = new int[]{2, 3, 3, 2, 2, 2, 4};
+        assertEquals(false, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test7() {
+        nums = new int[]{3, 3, 2, 2};
+        assertEquals(false, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test8() {
+        nums = new int[]{-1, 4, 2, 3};
+        assertEquals(true, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test9() {
+        nums = new int[]{1, 2, 4, 5, 3};
+        assertEquals(true, solution1.checkPossibility(nums));
+    }
+
+    @Test
+    public void test10() {
+        nums = new int[]{1, 2, 4, 5, 3, 6};
+        assertEquals(true, solution1.checkPossibility(nums));
+    }
+
+}