Add maximum subarray solution (rust-lang#209)

Author: imp2002

README.md

@@ -34,9 +34,10 @@ These are for demonstration purposes only.
 - [x] [Longest common subsequence](./src/dynamic_programming/longest_common_subsequence.rs)
 - [ ] Longest increasing subsequence
 - [x] [K-Means Clustering](./src/general/kmeans.rs)
-- [ ] Coin Change
+- [x] [Coin Change](./src/dynamic_programming/coin_change.rs)
 - [ ] Rod cut
 - [x] [Egg Dropping Puzzle](./src/dynamic_programming/egg_dropping.rs)
+- [x] [Maximum Subarray](./src/dynamic_programming/maximum_subarray.rs) 
 
 ## [Data Structures](./src/data_structures)
 

src/dynamic_programming/maximum_subarray.rs

@@ -0,0 +1,62 @@
+/// ## maximum subarray via Dynamic Programming
+
+/// maximum_subarray(array) find the subarray (containing at least one number) which has the largest sum
+/// and return its sum.
+///
+/// A subarray is a contiguous part of an array.
+///
+/// Arguments:
+///     * `array` - an integer array
+/// Complexity
+///     - time complexity: O(array.length),
+///     - space complexity: O(array.length),
+pub fn maximum_subarray(array: &[i32]) -> i32 {
+    let mut dp = vec![0; array.len()];
+    dp[0] = array[0];
+    let mut result = dp[0];
+
+    for i in 1..array.len() {
+        if dp[i - 1] > 0 {
+            dp[i] = dp[i - 1] + array[i];
+        } else {
+            dp[i] = array[i];
+        }
+        result = result.max(dp[i]);
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn non_negative() {
+        //the maximum value: 1 + 0 + 5 + 8 = 14
+        let array = vec![1, 0, 5, 8];
+        assert_eq!(maximum_subarray(&array), 14);
+    }
+
+    #[test]
+    fn negative() {
+        //the maximum value: -1
+        let array = vec![-3, -1, -8, -2];
+        assert_eq!(maximum_subarray(&array), -1);
+    }
+
+    #[test]
+    fn normal() {
+        //the maximum value: 3 + (-2) + 5 = 6
+        let array = vec![-4, 3, -2, 5, -8];
+        assert_eq!(maximum_subarray(&array), 6);
+    }
+
+    #[test]
+    fn single_element() {
+        let array = vec![6];
+        assert_eq!(maximum_subarray(&array), 6);
+        let array = vec![-6];
+        assert_eq!(maximum_subarray(&array), -6);
+    }
+}

src/dynamic_programming/mod.rs

@@ -4,6 +4,7 @@ mod egg_dropping;
 mod fibonacci;
 mod knapsack;
 mod longest_common_subsequence;
+mod maximum_subarray;
 
 pub use self::coin_change::coin_change;
 pub use self::edit_distance::{edit_distance, edit_distance_se};
@@ -12,3 +13,4 @@ pub use self::fibonacci::fibonacci;
 pub use self::fibonacci::recursive_fibonacci;
 pub use self::knapsack::knapsack;
 pub use self::longest_common_subsequence::longest_common_subsequence;
+pub use self::maximum_subarray::maximum_subarray;