jooncco.github.io

[Leetcode] 42. Trapping Rain Water explained

2022-09-18T00:00:00+00:00

Problem

42. Trapping Rain Water

Approach

Find water levels of each index.
The answer is

\[\sum\_{k=0}^{n-1} max ( 0 , waterLevel[k] - height[k] )\]

How can we find water levels?

We keep (height,index) in a stack.
For i = [0, … n-1] do:

While stack is not empty and stack.top.height \(\le\) height[i], update water levels in range (stack.top.index,i) to stack.top.height and stack.pop().
If stack is not empty and stack.top.height \(\gt\) height[i], update water levels in range (stack.top.index,i) to height[i]. Do not stack.pop().

After above process, sum up water volumes.

Code

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        Stack<Integer[]> walls = new Stack<>();
        int[] waterLevels = new int[n];
        // find water levels.
        for (int i = 0; i < n; ++i) {
            if (height[i] > 0) {
                while (!walls.isEmpty() && walls.peek()[0] <= height[i]) {
                    Integer[] wall= walls.pop();
                    for (int j=i-1; j > wall[1]; --j) waterLevels[j]= wall[0];
                }
                if (!walls.isEmpty() && walls.peek()[0] > height[i]) {
                    Integer[] wall= walls.peek();
                    for (int j=i-1; j > wall[1]; --j) waterLevels[j]= height[i];
                }
                walls.push(new Integer[]{height[i], i});
            }
        }

        // sum up water volumes.
        int ans= 0;
        for (int i = 0; i < n; ++i) ans += Math.max(0, waterLevels[i] - height[i]);
        return ans;
    }
}

Complexity

Time: \(O(n)\)
Space: \(O(n)\)

[Leetcode] 948. Bag of Tokens explained

2022-09-12T00:00:00+00:00

Problem

948. Bag of Tokens

Approach

Sort the tokens array in ascending order.
Keep left and right indices, which denotes allowed tokens available with initialPower.

left \(\leftarrow\) 0
right \(\leftarrow\) n-1

While left <= right:

Find maximum score we can make with tokens in [left, right] and update maximumScore.
Subtract tokens[l] from initialPower and add tokens[r] to initialPower.
Increment left by 1, and decrement right by 1.

Return maxScore value in the end.

Sorting apparently takes \(O(n{\log}n)\).
The indices left and right covers all n tokens, and each time there is a computation with n-complexity.
Thie makes time complexity \(O(n^2)\).

Code

class Solution {
    public int bagOfTokensScore(int[] tokens, int initialPower) {
        Arrays.sort(tokens);
        int n= tokens.length, l= 0, r= n-1;
        int maxScore= 0;
        while (l <= r) {
            if (tokens[l] > initialPower) break;
            int idx= l, score= 0, power= initialPower;
            while (idx <= r && tokens[idx] <= power) {
                power -= tokens[idx++];
                ++score;
            }
            maxScore= Math.max(maxScore, score);

            initialPower += (tokens[r]-tokens[l]);
            ++l; --r;
        }
        return maxScore;
    }
}

Complexity

Time: \(O(n{\log}n + n^2)\)
Space: \(O(1)\)

[Leetcode] 188. Best Time to Buy and Sell Stock IV explained

2022-09-11T00:00:00+00:00

Problem

188. Best Time to Buy and Sell Stock IV

Approach

This is a typical dynamic programming problem.

Before we get into main point, suppose we have unlimited chance of transaction (k \(= \infty\). k \(= \frac{k}{2}\) is large enough).
Then, we may perform transaction whenever we discover price higher than yesterday, and that becomes our maximum profit.
Please note the quickSolve method in solution.

Now let’s get into our main discussion.

We define a recursive helper function findMaxProfit, which finds maximum profit with k transactions in interval [0, endIdx], inclusive.

private int findMaxProfit(final int[] prices, int endIdx, int k) {
    if (endIdx == -1 || k == 0) return 0;

    int maxProfit= 0;
    for (int i=0; i < endIdx; ++i) {
        if (prices[i] < prices[endIdx]) {
            int spotProfit= prices[endIdx] - prices[i];
            maxProfit= Math.max(maxProfit, findMaxProfit(prices, i-1, k-1) + spotProfit);
        } else {
            maxProfit= Math.max(maxProfit, findMaxProfit(prices, i, k));
        }
    }
    return maxProfit;
}

But that’s not good enough.
We compute maxProfit value over and over, which is known as overlapping subproblems in dp.

Below is the optimal version of findMaxProfit, using memoization.

private int findMaxProfit(final int[] prices, int endIdx, int k) {
        if (endIdx == -1 || k == 0) return 0;

        if (cache[endIdx][k] != -1) return cache[endIdx][k];
        cache[endIdx][k]= 0;
        for (int i=0; i < endIdx; ++i) {
            if (prices[i] < prices[endIdx]) {
                int spotProfit= prices[endIdx] - prices[i];
                cache[endIdx][k]= Math.max(cache[endIdx][k], findMaxProfit(prices, i-1, k-1) + spotProfit);
            } else {
                cache[endIdx][k]= Math.max(cache[endIdx][k], findMaxProfit(prices, i, k));
            }
        }
        return cache[endIdx][k];
    }

We now can simply return findMaxProfit(prices, n-1, k).

Code

/**
 * author: jooncco
 * written: 2022. 9. 11. Tue. 02:04:14 [UTC+9]
 **/

class Solution {
    private int n;
    private int[][] cache;

    public int maxProfit(int k, int[] prices) {
        n= prices.length;
        if (k >= n/2) return quickSolve(prices, k);

        cache= new int[n+1][k+1];
        for (int[] row : cache) Arrays.fill(row, -1);
        return findMaxProfit(prices, n-1, k);
    }

    private int findMaxProfit(final int[] prices, int endIdx, int k) {
        if (endIdx == -1 || k == 0) return 0;

        if (cache[endIdx][k] != -1) return cache[endIdx][k];
        cache[endIdx][k]= 0;
        for (int i=0; i < endIdx; ++i) {
            if (prices[i] < prices[endIdx]) {
                int spotProfit= prices[endIdx] - prices[i];
                cache[endIdx][k]= Math.max(cache[endIdx][k], findMaxProfit(prices, i-1, k-1) + spotProfit);
            } else {
                cache[endIdx][k]= Math.max(cache[endIdx][k], findMaxProfit(prices, i, k));
            }
        }
        return cache[endIdx][k];
    }

    private int quickSolve(final int[] prices, int k) {
        int maxProfit= 0;
        for (int i=1; i < n; ++i) {
            if (prices[i] > prices[i-1]) maxProfit += prices[i] - prices[i-1];
        }
        return maxProfit;
    }
}

Complexity

Time: \(O(n^2)\)
Space: \(O(n{\cdot}k)\)

[Leetcode] 94. Binary Tree Inorder Traversal explained

2022-09-08T00:00:00+00:00

Problem

94. Binary Tree Inorder Traversal

Approach

Recursive approach is trivial.
We can implement inorder traversal using Stack.

curNode <- root
while true:
    if curNode is null:
        if stack is empty:
            break;
        tmpNode <- stack.pop();
        add tmpNode.val to result
        curNode <- tmpNode.right;
    else:
        if curNode is not null:
            push curNode into stack
        else:
            curNode <- curNode.left;

Code

Recursive approach

/**
 * author: jooncco
 * written: 2022. 9. 8. Tue. 11:34:14 [UTC+9]
 **/

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        inorder(result, root);
        return result;
    }

    private void inorder(List<Integer> arr, TreeNode node) {
        if (node == null) return;

        inorder(arr, node.left);
        arr.add(node.val);
        inorder(arr, node.right);
    }
}

Iterative approach

/**
 * author: jooncco
 * written: 2022. 9. 8. Tue. 13:36:14 [UTC+9]
 **/

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> result= new LinkedList<>();

        TreeNode curNode = root;
        while (true) {
            if (curNode == null) {
                if (stack.isEmpty()) break;
                result.add(stack.peek().val);
                curNode= stack.pop().right;
            } else {
                if (curNode.left != null) {
                    stack.push(curNode);
                    curNode= curNode.left;
                } else {
                    result.add(curNode.val);
                    curNode= curNode.right;
                }
            }
        }
        return result;
    }
}

Complexity

Time: \(O(n)\)
Space: \(O(n)\)

[Codeforces] 1490C. Sum of Cubes explained

2022-09-06T00:00:00+00:00

Problem

1490C. Sum of Cubes

Approach

Transpose \(a^3\).
It becomes finding value b which is \(b = \sqrt[3]{x-a^3}\).
And it can be solved with brute force.
Took some time for me to find a way to tell wether b is integer or not.

Code

/**
 * author: jooncco
 * written: 2022. 9. 6. Tue. 00:05:14 [UTC+9]
 **/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class Main {
    private final static FastScanner sc= new FastScanner();
    private static final Long mx= 1000000000000L;

    public static void main(String[] args) {
        Set<Long> cubes= new HashSet<>();
        preCalc(cubes);

        long t,x; t= sc.nextLong();
        while (t-- > 0) {
            x= sc.nextLong();
            boolean yes= false;
            for (long a= 1; a*a*a <= x; ++a) {
                if (cubes.contains(x - a*a*a)) {
                    yes= true;
                    break;
                }
            }
            System.out.println(yes ? "YES":"NO");
        }
    }

    private static void preCalc(Set<Long> cubes) {
        for (long i=1; i*i*i <= mx; ++i) {
            cubes.add(i*i*i);
        }
    }

}

class FastScanner {
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st=new StringTokenizer("");
    String next() {
        while (!st.hasMoreTokens()) {
            try {
                st=new StringTokenizer(br.readLine());
            } catch (IOException e) {}
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }
    long nextLong() {
        return Long.parseLong(next());
    }
}

Complexity

Time: \(O(\sqrt[3]x)\)
Space: \(O(1)\)

[Leetcode] 814. Binary Tree Pruning explained

2022-09-06T00:00:00+00:00

Problem

814. Binary Tree Pruning

Approach

For each tree node, repeat below process.

Prune left child.
Prune right child.
If left and right child is null and this node doesn’t have value 1, return null (prunning).

Code

/**
 * author: jooncco
 * written: 2022. 9. 6. Tue. 13:14:14 [UTC+9]
 **/

class Solution {
    private final int TARGET_VALUE = 1;

    public TreeNode pruneTree(TreeNode root) {
        if (root == null) return null;

        root.left= pruneTree(root.left);
        root.right= pruneTree(root.right);
        if (root.left == null && root.right == null && root.val != TARGET_VALUE) return null;
        return root;
    }
}

Complexity

Time: \(O(n)\)
Space: \(O(n)\)

[LeetCode] 2212. Maximum Points in an Archery Competition explained

2022-03-20T00:00:00+00:00

Problem

2212. Maximum Points in an Archery Competition

Approach

Note that we have fairly short range of points { 0, 1, ... 11 }.
Total number of subsets is \(2^{12} = 4096\), and each of them can be Bob’s choice as long as he has enough arrows.

Brute force all the cases using bitmask, and find the maximum total point of Bob’s satisfying certain condition:

int maxPoint= 0, maxMask;
for (int mask=0; mask < (1<<12); ++mask) {
    if (totalPoint(mask) > maxPoint &&
        arrowsNeeded(mask, aliceArrows) <= numArrows) {
        maxPoint= totalPoint(mask);
        maxMask= mask;
    }
}

Helper functions:

private:
    int totalPoint(int mask) {
        int point= 0;
        for (int i=0; i < 12; ++i) {
            if (mask & (1<<i)) point += i;
        }
        return point;
    }

    int arrowsNeeded(int mask, vi &aliceArrows) {
        int arrows= 0;
        for (int i=0; i < 12; ++i) {
            if (mask & (1<<i)) {
                arrows += aliceArrows[i]+1;
            }
        }
        return arrows;
    }

Now that you have the maxMask, construct the answer array:

vi ret(12,0);
int cnt= numArrows;
for (int i=1; i < 12; ++i) {
    if (maxMask & (1<<i)) {
        ret[i]= aliceArrows[i]+1;
        cnt -= ret[i];
    }
}
ret[0]= cnt;

Code

typedef vector<int> vi;

class Solution {
private:
    int totalPoint(int mask) {
        int point= 0;
        for (int i=0; i < 12; ++i) {
            if (mask & (1<<i)) point += i;
        }
        return point;
    }

    int arrowsNeeded(int mask, vi &aliceArrows) {
        int arrows= 0;
        for (int i=0; i < 12; ++i) {
            if (mask & (1<<i)) {
                arrows += aliceArrows[i]+1;
            }
        }
        return arrows;
    }

public:
    vi maximumBobPoints(int numArrows, vi &aliceArrows) {
        int maxPoint= 0, maxMask;
        for (int mask=0; mask < (1<<12); ++mask) {
            if (totalPoint(mask) > maxPoint &&
                arrowsNeeded(mask, aliceArrows) <= numArrows) {
                maxPoint= totalPoint(mask);
                maxMask= mask;
            }
        }
        vi ret(12,0);
        int cnt= numArrows;
        for (int i=1; i < 12; ++i) {
            if (maxMask & (1<<i)) {
                ret[i]= aliceArrows[i]+1;
                cnt -= ret[i];
            }
        }
        ret[0]= cnt;
        return ret;
    }
};

Complexity

Time: \(O(1)\)
Space: \(O(1)\)

[LeetCode] 2203. Minimum Weighted Subgraph With the Required Paths explained

2022-03-14T00:00:00+00:00

Problem

2203. Minimum Weighted Subgraph With the Required Paths

Approach

The shortest path of target subgraph falls into 3 forms:

src1 -> src2 -> dest
src2 -> src1 -> dest
src1 -> dest, src2 -> dest (without sharing edges)

In every case, there always exists a vertex which two routes first join.
So we can generalize the process of finding shortest path as following:

Find the shortest path from src1->pivot
Find the shortest path from src2->pivot
Find the shortest path from pivot->dest
Add 1, 2, and 3.

But how do we know which vertex is a pivot?

Run dijkstra 3 times with start node src1, src2, and dest(with inversed graph for this one). And then we simply linear search all the vertices, assuming current vertex is a pivot.

Each calculation takes \(O(1)\), thanks to precalculated shortest distances.

Note
use type long long to avoid integer overflow.

Code

#define f first
#define s second
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef deque<int> di;
typedef deque<ll> dl;
typedef priority_queue<int, vi, less<int> > maxHeap;
typedef priority_queue<int, vi, greater<int> > minHeap;

class Solution {
private:
    int N;
    ll INF= 1e12;
    vector<pii> adj[100010], adjInv[100010];

    vl dijkstra(int src, bool isInv) {
        vl dist(N,INF);
        dist[src]= 0;
        priority_queue<pll, vector<pll>, greater<pll>> pq;
        pq.push({ 0, src });
        while (!pq.empty()) {
            ll from= pq.top().s, curDist= pq.top().f;
            pq.pop();
            if (curDist > dist[from]) continue;

            for (pii &edge : (isInv ? adjInv[from] : adj[from])) {
                ll to= edge.f, cost= dist[from]+edge.s;
                if (cost < dist[to]) {
                    dist[to]= cost;
                    pq.push({ cost, to });
                }
            }
        }
        return dist;
    }

public:
    ll minimumWeight(int n, vector<vi> &edges, int src1, int src2, int dest) {
        N= n;
        for (int i=0; i < n; ++i) {
            adj[i].clear();
            adjInv[i].clear();
        }
        for (auto &edge : edges) {
            adj[edge[0]].push_back({ edge[1], edge[2] });
            adjInv[edge[1]].push_back({ edge[0], edge[2] });
        }

        vl d1= dijkstra(src1, false);
        vl d2= dijkstra(src2, false);
        vl d3= dijkstra(dest, true);
        ll ret= +INF;
        for (int i=0; i < n; ++i) {
            ret= min(ret, d1[i]+d2[i]+d3[i]);
        }
        return ret == INF ? -1 : ret;
    }
};

Complexity

Time: \(O(n + \vert{E}\vert\log{n})\)
Space: \(O(n)\)

[LeetCode] 309. Best Time to Buy and Sell Stock with Cooldown explained

2022-03-06T00:00:00+00:00

Problem

309. Best Time to Buy and Sell Stock with Cooldown

Approach

There exists 3 states, and that can be expressed like this:

Hence, we can use dynamic programming approach to this problem, representing state transfers.

holding[i] = max( holding[i-1] , notHolding[i-1] - prices[i])
notHolding[i] = max( notHolding[i-1] , cooldown[i-1] )
cooldown[i] = holding[i-1] + prices[i]

Initializing base case shouldn’t be difficult,

holding[0] = -prices[0]
notHolding[0] = 0
cooldown[0] = \(-\infty\)

The ultimate answer is \(\max(cooldown[n-1], notHolding[n-1])\).

Note
We can optimize space complexity into \(O(1)\). Implementation below does that.

Code

typedef vector<int> vi;

class Solution {
private:
    const int NEG_INF= -1e7;
public:
    int maxProfit(vi &prices) {
        int n= prices.size(), holding= -prices[0], notHolding= 0, cooldown= NEG_INF;
        for (int i=1; i < n; ++i) {
            int prevHolding= holding;
            holding= max(holding, notHolding-prices[i]);
            notHolding= max(notHolding, cooldown);
            cooldown= prevHolding+prices[i];
        }
        return max(cooldown, notHolding);
    }
};

Complexity

Time: \(O(n)\)
Space: \(O(n)\)

[LeetCode] 714. Best Time to Buy and Sell Stock with Transaction Fee explained

2022-03-06T00:00:00+00:00

Problem

714. Best Time to Buy and Sell Stock with Transaction Fee

Approach

Solution 1: DP

There exists 2 states, and those can be expressed as:

Hence, we can use dynamic programming approach to this problem, representing state transfers.

holding[i] = max( holding[i-1] , notHolding[i-1] - prices[i])
notHolding[i] = max( notHolding[i-1] , holding[i-1] + prices[i] - fee )

Initializing base case shouldn’t be difficult,

holding[0] = -prices[0]
notHolding[0] = 0

The ultimate answer is \(\max(holding[n-1], notHolding[n-1])\).

Note
We can optimize space complexity into \(O(1)\). Implementation below does that.

Solution 2: DP & Greedy

Example test cases tell us many things.

From left to right, update those values with following definitions.

i: current index
curMin: minimum price so far
curMaxProfit: maximum profit so far

Say i=4, then curMin becomes 1 and curMaxProfit = 8 - 1 - 2(fee) = 5.
Here we need to decide wether to buy price[4] or not and it is always optimal to buy it when:
\(curMaxProfit + P - prices[i] - fee \gt P - curMin - fee\)
\(curMaxProfit + \bcancel{P} - prices[i] - \cancel{fee} \gt \bcancel{P} - curMin - \cancel{fee}\)
\(curMaxProfit \gt prices[i] - curMin\)
where P denotes some huge price in the future.

Thus, we can pick prices to buy in a greedy way, by checking the above condition.
From left to right,

if \(curMaxProfit \gt prices[i] - curMin\), then ans += curMaxProfit. prices[i] is a new curMin now.
else if prices[i] < curMin, update curMin value.
else update curMaxProfit value

Code

Solution 1: DP

typedef vector<int> vi;

class Solution {
public:
    int maxProfit(vi &prices, int fee) {
        int n= prices.size(), holding= -prices[0], notHolding= 0;
        for (int i=1; i < n; ++i) {
            int prevHolding= holding;
            holding= max(prevHolding, notHolding-prices[i]);
            notHolding= max(notHolding, prevHolding+prices[i]-fee);
        }
        return max(holding, notHolding);
    }
};

Solution 2: DP & Greedy

typedef vector<int> vi;

class Solution {
public:
    int maxProfit(vi &prices, int fee) {
        int n= prices.size(), curMin= prices[0], curMaxProfit= 0, ans= 0;
        for (int i=1; i < n; ++i) {
            if (curMin + curMaxProfit > prices[i]) {
                ans += curMaxProfit;
                curMin= prices[i];
                curMaxProfit= 0;
            }
            else if (prices[i] < curMin) curMin= prices[i];
            else curMaxProfit= max(curMaxProfit, prices[i]-curMin-fee);
        }
        ans += curMaxProfit;
        return ans;
    }
};