update

Author: realdennis

src/best-time-to-buy-and-sell-stock-with-cooldown-optimize.ts

@@ -0,0 +1,23 @@
+export {};
+
+// O(n) time, O(1) space
+function maxProfit(prices: number[]): number {
+  const N = prices.length;
+
+  let hold = -prices[0];
+  let release = Number.MIN_SAFE_INTEGER;
+  let idle = 0;
+
+  if (N < 2) return 0;
+
+  for (let i = 1; i < N; i++) {
+    const lastHold = hold;
+    const lastRelease = release;
+    const lastIdle = idle;
+    hold = Math.max(lastHold, lastIdle - prices[i]);
+    release = lastHold + prices[i];
+    idle = Math.max(lastIdle, lastRelease);
+  }
+
+  return Math.max(release, idle);
+}

src/best-time-to-buy-and-sell-stock-with-cooldown.ts

@@ -0,0 +1,52 @@
+export {};
+
+/**
+For each day we have three different multi universe, which we 
+    1. just sell in this day
+    2. just buy in this day
+    3. just do noop this day
+
+So how come we deal with each relation? 
+
+As the desc, we are 
+    1. not allowed to buy after we sell (cooldown)
+    2. not allowed hold multiple shares
+
+
+So now we had three state:
+    1. HOLD -> you had one share in your hand
+    2. RELEASE -> you just sell that share (so I mean you need to at hold state in previous day)
+    3. IDLE -> you do nothing, and you don't have the share in your hand.
+
+The state machine be like
+
+    HOLD[i] = IDLE[i-1] - prices[i] vs HOLD[i-1]; // best buy point
+
+    RELEASE[i] = HOLD[i-1] + prices[i];
+
+    IDLE[i] = IDLE[i-1] vs RELEASE[i-1]
+
+ */
+
+// O(n) time, O(n) space, for O(1) space, check the `best-time-to-buy-and-sell-stock-with-cooldown-optimize`
+function maxProfit(prices: number[]): number {
+  const N = prices.length;
+
+  const hold = Array.from({ length: N }, () => 0);
+  const release = Array.from({ length: N }, () => 0);
+  const idle = Array.from({ length: N }, () => 0);
+
+  if (N < 2) return 0;
+
+  hold[0] = -prices[0];
+  release[0] = Number.MIN_SAFE_INTEGER;
+  idle[0] = 0;
+
+  for (let i = 1; i < N; i++) {
+    hold[i] = Math.max(hold[i - 1], idle[i - 1] - prices[i]);
+    release[i] = hold[i - 1] + prices[i];
+    idle[i] = Math.max(idle[i - 1], release[i - 1]);
+  }
+
+  return Math.max(release[N - 1], idle[N - 1]);
+}

src/best-time-to-buy-and-sell-stock-with-transaction-fee.ts

@@ -0,0 +1,24 @@
+export {};
+function maxProfit(prices: number[], fee: number): number {
+  const N = prices.length;
+
+  let hold = -prices[0];
+  let release = Number.MIN_SAFE_INTEGER;
+  let idle = 0;
+
+  for (let i = 1; i < N; i++) {
+    const lastHold = hold,
+      lastRelease = release,
+      lastIdle = idle;
+
+    hold = Math.max(
+      lastRelease - prices[i],
+      lastIdle - prices[i],
+      lastHold /*may not engage in multiple*/
+    );
+    release = lastHold + prices[i] - fee;
+    idle = Math.max(lastRelease, lastIdle);
+  }
+
+  return Math.max(release, idle);
+}

src/maximum-subarray-sum.ts

@@ -0,0 +1,12 @@
+function maxSubArray(nums: number[]): number {
+  const N = nums.length;
+  let maxSum = 0;
+  let ret = Number.MIN_SAFE_INTEGER;
+
+  for (let i = 0; i < N; i++) {
+    if (maxSum < 0) maxSum = 0;
+    maxSum += nums[i];
+    ret = Math.max(ret, maxSum);
+  }
+  return ret;
+}

src/move-zeros.ts

@@ -3,16 +3,18 @@
  */
 function moveZeroes(nums: number[]): void {
   const N = nums.length;
-  let pos1 = 0;
-  let pos0 = -1;
 
-  while (pos1 < N) {
-    if (nums[pos1] === 0) {
-      pos0 = Math.max(pos0, pos1) + 1;
-      while (pos0 < N && nums[pos0] === 0) pos0++;
-      if (pos0 === N) break;
-      [nums[pos1], nums[pos0]] = [nums[pos0], nums[pos1]];
+  let ptr1 = 0,
+    ptr2 = 0;
+  while (true) {
+    while (ptr2 < N && nums[ptr2] === 0) ptr2++;
+    if (ptr2 === N) break;
+
+    if (ptr1 !== ptr2) {
+      // prevent redundant swap
+      [nums[ptr1], nums[ptr2]] = [nums[ptr2], nums[ptr1]]; // swap
     }
-    pos1++;
+    ptr1++;
+    ptr2++;
   }
 }

src/two-sum-ii-input-array-is-sorted.ts

@@ -0,0 +1,13 @@
+function twoSum(numbers: number[], target: number): number[] {
+  const N = numbers.length;
+  let lo = 0,
+    hi = N - 1;
+
+  // exactly one solution
+  while (numbers[lo] + numbers[hi] !== target) {
+    if (numbers[lo] + numbers[hi] > target) hi--;
+    else lo++;
+  }
+
+  return [lo + 1, hi + 1];
+}