53. Maximum Subarray

coderbean · coderbean · commit 2c52d4772393 · 2019-07-11T12:18:41.000+08:00
diff --git a/.gitignore b/.gitignore
@@ -24,6 +24,9 @@ out/
 target/
 .idea/
 .DS_Store
+.classpath
+.project
+.settings/
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
diff --git a/markdown/53. Maximum Subarray.md b/markdown/53. Maximum Subarray.md
@@ -0,0 +1,38 @@
+### [53\. Maximum Subarray](https://leetcode.com/problems/maximum-subarray/)
+
+Difficulty: **Easy**
+
+
+Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
+
+**Example:**
+
+```
+Input: [-2,1,-3,4,-1,2,1,-5,4],
+Output: 6
+Explanation: [4,-1,2,1] has the largest sum = 6.
+```
+
+**Follow up:**
+
+If you have figured out the O(_n_) solution, try coding another solution using the divide and conquer approach, which is more subtle.
+
+
+#### Solution
+
+Language: **Java** 参考
+
+```java
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int[] dp = new int[nums.length]; // 表示以 index 为结尾的，最大子序列和的值
+        dp[0] = nums[0];
+        int maxSum = dp[0];
+        for (int i = 1; i < nums.length; i++) {
+            dp[i] = dp[i - 1] > 0 ? dp[i - 1] + nums[i] : nums[i];
+            maxSum = dp[i] > maxSum ? dp[i] : maxSum;
+        }
+        return maxSum;
+    }
+}
+```
diff --git a/src/main/java/leetcode/_51_/Main.java b/src/main/java/leetcode/_51_/Main.java
@@ -0,0 +1,14 @@
+package leetcode._51_;
+
+/**
+ * Created by zhangbo54 on 2019-03-04.
+ */
+public class Main {
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
+        int i = solution.maxSubArray(nums);
+        System.out.println(i);
+    }
+}
+
diff --git a/src/main/java/leetcode/_51_/Solution.java b/src/main/java/leetcode/_51_/Solution.java
@@ -0,0 +1,14 @@
+package leetcode._51_;
+
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int[] dp = new int[nums.length]; // 表示以 index 为结尾的，最大子序列和的值
+        dp[0] = nums[0];
+        int maxSum = dp[0];
+        for (int i = 1; i < nums.length; i++) {
+            dp[i] = dp[i - 1] > 0 ? dp[i - 1] + nums[i] : nums[i];
+            maxSum = dp[i] > maxSum ? dp[i] : maxSum;
+        }
+        return maxSum;
+    }
+}
diff --git a/src/main/java/leetcode/_51_/solution.md b/src/main/java/leetcode/_51_/solution.md
@@ -0,0 +1,38 @@
+### [53\. Maximum Subarray](https://leetcode.com/problems/maximum-subarray/)
+
+Difficulty: **Easy**
+
+
+Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
+
+**Example:**
+
+```
+Input: [-2,1,-3,4,-1,2,1,-5,4],
+Output: 6
+Explanation: [4,-1,2,1] has the largest sum = 6.
+```
+
+**Follow up:**
+
+If you have figured out the O(_n_) solution, try coding another solution using the divide and conquer approach, which is more subtle.
+
+
+#### Solution
+
+Language: **Java** 参考
+
+```java
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int[] dp = new int[nums.length]; // 表示以 index 为结尾的，最大子序列和的值
+        dp[0] = nums[0];
+        int maxSum = dp[0];
+        for (int i = 1; i < nums.length; i++) {
+            dp[i] = dp[i - 1] > 0 ? dp[i - 1] + nums[i] : nums[i];
+            maxSum = dp[i] > maxSum ? dp[i] : maxSum;
+        }
+        return maxSum;
+    }
+}
+```
