Solve #310

Author: aylei

src/lib.rs

@@ -230,3 +230,5 @@ mod n0304_range_sum_query_2d_immutable;
 mod n1009_pancake_sorting;
 mod n0306_additive_number;
 mod n0307_range_sum_query_mutable;
+mod n0309_best_time_to_buy_and_sell_stock_with_cooldown;
+mod n0310_minimum_height_trees;

src/n0309_best_time_to_buy_and_sell_stock_with_cooldown.rs

@@ -0,0 +1,76 @@
+/**
+ * [309] Best Time to Buy and Sell Stock with Cooldown
+ *
+ * Say you have an array for which the i^th element is the price of a given stock on day i.
+ *
+ * Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times) with the following restrictions:
+ *
+ *
+ * 	You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+ * 	After you sell your stock, you cannot buy stock on next day. (ie, cooldown 1 day)
+ *
+ *
+ * Example:
+ *
+ *
+ * Input: [1,2,3,0,2]
+ * Output: 3
+ * Explanation: transactions = [buy, sell, cooldown, buy, sell]
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+/*
+ dp[i]: max profit with selling at day i
+ dp2[i]: max profit till day i
+
+ dp[i] = max(dp[i-1] + p[i] - p[i-1], dp2[i-2], dp2[i-3] + p[i] - p[i-1])
+ */
+impl Solution {
+    pub fn max_profit(prices: Vec<i32>) -> i32 {
+        if prices.len() < 2 { return 0 }
+        if prices.len() == 2 {
+            return i32::max(0, prices[1] - prices[0]);
+        }
+        let mut dp = vec![0; prices.len()];
+        let mut dp2 = vec![0; prices.len()];
+        let mut max = 0;
+        dp[0] = 0;
+        dp2[0] = 0;
+        dp[1] = prices[1] - prices[0];
+        dp2[1] = i32::max(dp2[0], dp[1]);
+        dp[2] = i32::max(prices[2] - prices[1], prices[2]-prices[0]);
+        dp2[2] = i32::max(dp2[1], dp[2]);
+        for i in 3..prices.len() {
+            dp[i] = i32::max(dp[i-1]+prices[i]-prices[i-1],
+                             i32::max(
+                                 dp2[i-2],
+                                 dp2[i-3]+prices[i]-prices[i-1]
+                             )
+            );
+            dp2[i] = i32::max(dp2[i-1], dp[i]);
+        }
+        let mut temp = 0;
+        for &m in dp.iter() {
+            if m > temp {
+                temp = m;
+            }
+        }
+        temp
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_309() {
+        assert_eq!(Solution::max_profit(vec![1,2,3,0,2]), 3);
+        assert_eq!(Solution::max_profit(vec![4,2,7,1,11]), 10);
+    }
+}

src/n0310_minimum_height_trees.rs

@@ -0,0 +1,98 @@
+/**
+ * [310] Minimum Height Trees
+ *
+ * For an undirected graph with tree characteristics, we can choose any node as the root. The result graph is then a rooted tree. Among all possible rooted trees, those with minimum height are called minimum height trees (MHTs). Given such a graph, write a function to find all the MHTs and return a list of their root labels.
+ *
+ * Format<br />
+ * The graph contains n nodes which are labeled from 0 to n - 1. You will be given the number n and a list of undirected edges (each edge is a pair of labels).
+ *
+ * You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.
+ *
+ * Example 1 :
+ *
+ *
+ * Input: n = 4, edges = [[1, 0], [1, 2], [1, 3]]
+ *
+ *         0
+ *         |
+ *         1
+ *        / \
+ *       2   3
+ *
+ * Output: [1]
+ *
+ *
+ * Example 2 :
+ *
+ *
+ * Input: n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]
+ *
+ *      0  1  2
+ *       \ | /
+ *         3
+ *         |
+ *         4
+ *         |
+ *         5
+ *
+ * Output: [3, 4]
+ *
+ * Note:
+ *
+ *
+ * 	According to the <a href="https://en.wikipedia.org/wiki/Tree_(graph_theory)" target="_blank">definition of tree on Wikipedia</a>: &ldquo;a tree is an undirected graph in which any two vertices are connected by exactly one path. In other words, any connected graph without simple cycles is a tree.&rdquo;
+ * 	The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+use std::mem;
+impl Solution {
+    pub fn find_min_height_trees(n: i32, edges: Vec<Vec<i32>>) -> Vec<i32> {
+        let n = n as usize;
+        let mut matrix: Vec<Vec<usize>> = vec![vec![]; n];
+        for edge in edges.iter() {
+            matrix[edge[0] as usize].push(edge[1] as usize);
+            matrix[edge[1] as usize].push(edge[0] as usize);
+        }
+        let mut count = n;
+        let mut la: Vec<usize> = vec![];
+        let mut lb: Vec<usize> = vec![];
+        for i in 0..n {
+            if matrix[i].len() <= 1 {
+                la.push(i);
+            }
+        }
+        while count > 2 {
+            count -= la.len();
+            for &i in la.iter() {
+                let j = matrix[i][0];
+                let idx = matrix[j].iter().position(|&r| r == i).unwrap();
+                matrix[j].remove(idx);
+                if matrix[j].len() == 1 {
+                    lb.push(j);
+                }
+            }
+            la.clear();
+            mem::swap(&mut la, &mut lb);
+        }
+        la.into_iter().map(|i| i as i32).collect()
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_310() {
+        assert_eq!(Solution::find_min_height_trees(4, vec![vec![1, 0], vec![1, 2], vec![1, 3]]), vec![1]);
+        assert_eq!(Solution::find_min_height_trees(6, vec![vec![0, 3], vec![1, 3], vec![2, 3], vec![4, 3], vec![5, 4]]), vec![3, 4]);
+        assert_eq!(Solution::find_min_height_trees(1, vec![]), vec![0]);
+    }
+}