vault backup: 2022-06-27 11:19:16

CS notes/pages/Kadane's Algorithm.md

@@ -17,6 +17,7 @@ tag:#coding_problem tag:#Kadane_s_algorithm  -tag:#template_remove_me
 ```
  
 - [[Leetcode Best-Time-To-Buy-And-Sell-Stock]]
+- [[Leetcode Maximum-Difference-Between-Increasing-Elements]]
 - [[Leetcode Maxinum-subarray]]
  
 

CS notes/pages/Leetcode Maximum-Difference-Between-Increasing-Elements.md

@@ -0,0 +1,96 @@
+# Leetcode Maximum-Difference-Between-Increasing-Elements
+
+#### 2022-06-27 11:09
+
+> ##### Algorithms:
+> #algorithm #Kadane_s_algorithm 
+> ##### Difficulty:
+> #coding_problem #difficulty-easy 
+> ##### Additional tags:
+> #leetcode
+> ##### Revisions:
+> Initial encounter: 2022-06-27
+
+##### Related topics:
+```expander
+tag:#Kadane_s_algorithm 
+```
+ 
+- [[Kadane's Algorithm]]
+- [[Leetcode Best-Time-To-Buy-And-Sell-Stock]]
+- [[Leetcode Maxinum-subarray]]
+ 
+
+##### Links:
+- [Link to problem](https://leetcode.com/problems/maximum-difference-between-increasing-elements/)
+___
+### Problem
+Given a **0-indexed** integer array `nums` of size `n`, find the **maximum difference** between `nums[i]` and `nums[j]` (i.e., `nums[j] - nums[i]`), such that `0 <= i < j < n` and `nums[i] < nums[j]`.
+
+Return _the **maximum difference**._ If no such `i` and `j` exists, return `-1`.
+
+#### Examples
+Example 1:
+
+```
+Input: nums = [7,1,5,4]
+Output: 4
+Explanation:
+The maximum difference occurs with i = 1 and j = 2, nums[j] - nums[i] = 5 - 1 = 4.
+Note that with i = 1 and j = 0, the difference nums[j] - nums[i] = 7 - 1 = 6, but i > j, so it is not valid.
+```
+
+Example 2:
+
+```
+Input: nums = [9,4,3,2]
+Output: -1
+Explanation:
+There is no i and j such that i < j and nums[i] < nums[j].
+```
+
+Example 3:
+
+```
+Input: nums = [1,5,2,10]
+Output: 9
+Explanation:
+The maximum difference occurs with i = 0 and j = 3, nums[j] - nums[i] = 10 - 1 = 9.
+```
+ 
+
+#### Constraints
+
+-   n == nums.length
+-   2 <= n <= 1000
+-   1 <= nums[i] <= 109
+
+### Thoughts
+
+Since 0 <= i < j <=n, this can be completed using kadane's algo in one pass.
+> [!summary]
+> This is a #Kadane_s_algorithm 
+
+### Solution
+
+```cpp
+class Solution {
+public:
+  int maximumDifference(vector<int>& nums) {
+    // Kadane's algorithm, since 0 <= i < j < n, and it can be done using one loop.
+    int minNum = nums[0];
+    int maxNum = 0;
+    
+    for (int i : nums) {
+      minNum = min(minNum, i);
+      maxNum = max(maxNum, i - minNum);
+    }
+    
+    if (maxNum == 0) {
+      return -1;
+    } else {
+      return maxNum;
+    }
+  }
+};
+```