Zeyuan (Faradawn) Yang

ICPC and LLDB GDB

2022-10-09T00:00:00+00:00

Fast Read Cin

ios::sync_with_stdio(false);
cin.tie(NULL);
int tt;
cin >> tt;

LLDB

g++ -g -std=c++17 temp.cpp; ./a.out
lldb a.out (or, target create a.out)
b func1
run
bt
n (step over)
s (step in)

Binary Index Tree, Trie, and KMP

2022-09-23T00:00:00+00:00

Part 1 - Binary Index Tree

query, sum all nodes from idx + 1 to 0, using getParent
update, add diff to nodes from idx + 1 to arr.size, using getNext
Youtube Tutorial and Java Implementation

Part 2 - Trie

Article labuladong trie

Trie: String Split

2022-09-22T00:00:00+00:00

1 - Word Break I (DP)

139. Word Break I. Given a string s and a dictionary of strings wordDict, return true if s can be segmented into a space-separated sequence of one or more dictionary words.

Input: s = "leetcode", wordDict = ["leet","code"]
Output: true
Explanation: Return true because "leetcode" can be segmented as "leet code".

Solution:

dp[i] records whether the word before i can be split.
for each i, check if any substr(j, i) is in dict and dp[j] = 1.

2 - Word Break II (Backtracking)

140. Word Break II. Given a string s and a dictionary of strings wordDict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences in any order.

Input: s = "catsanddog", wordDict = ["cat","cats","and","sand","dog"]
Output: ["cats and dog","cat sand dog"]

Solution:

Backtrack from s[0, …], each time try a dict word with len.
If word matches, continue match s[idx + len, ...].
End with idx == s.length()

3 -

DP: Longest Common Subsequence

2022-09-19T00:00:00+00:00

1 - Longest Common Subarray

Given two integer arrays nums1 and nums2, return the maximum length of a subarray that appears in both arrays.
Input: nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
Output: 3
Explanation: The repeated subarray with maximum length is [3,2,1].
Solution: dp O(n^2)

if(nums1[i] == nums2[j]){
    if(i > 0 and j > 0){
        dp[i][j] = dp[i-1][j-1] + 1;
    }else{
        dp[i][j] = 1;
    }
    if(dp[i][j] > res)
        res = dp[i][j];
}

2 - Longest common subsequence

Input: text1 = "abcde", text2 = "ace" 
Output: 3  
Explanation: The longest common subsequence is "ace" and its length is 3.

Solution: dp is longest common subseq of s1[0, i] and s2[0, j]

if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
    // s1[i-1] 和 s2[j-1] 必然在 lcs 中
    dp[i][j] = 1 + dp[i - 1][j - 1];
} else {
    // s1[i-1] 和 s2[j-1] 至少有一个不在 lcs 中
    dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
}

System: process, thread, and files

2022-09-13T00:00:00+00:00

Part 1: Processes and Threads

Process and threads use the same task_struct

  struct task_struct {
      long			  state;
      struct mm_struct  *mm;
      pid_t			  pid;
      // 指向父进程的指针
      struct task_struct __rcu  *parent;
      // 子进程列表
      struct list_head		children;
      // 存放文件系统信息的指针
      struct fs_struct		*fs;
      // 一个数组，包含该进程打开的文件指针
      struct files_struct		*files;
  };

Threads inherits parent process’s memory and files
- but child process copies parent’s memory and files
- so threads need lock, but processes don’t
Both creation in Linux are fast
- process creation uses copy-on-write, so only copies parent’s memory space when write

Part 2 - Programming Concurrency

1 - Thread counter with mutex

int counter = 0;
mutex mtx;

void incr(int n){
    mtx.lock();
    for(int i = 0; i < n; i++){
        counter ++;
    }
    mtx.unlock();
}

int main(){
    thread threads[5];
    for(int i = 0; i < 5; i++){
        threads[i] = thread(incr, 1000);
    }
    for(int i = 0; i < 5; i++){
        threads[i].join();
    }
    // put this after join threads 
    cout<<"counter is "<< counter<<endl;
}

Segment Tree: Max and Sum

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

Max Segment Tree (Accepted)

class MaxSegTree{
    vector<int> t;
public:
    MaxSegTree(vector<int> &nums){
        int n = nums.size();
        t.resize(4 * n, 0);
        build(nums, 0, 0, n-1);
    }

    void build(vector<int> &nums, int cur, int tl, int tr){
        if(tl == tr){
            t[cur] = nums[tl];
            return;
        }
        int mid = tl + (tr - tl) / 2;
        build(nums, 2*cur+1, tl, mid);
        build(nums, 2*cur+2, mid+1, tr);
        t[cur] = max(t[2*cur+1], t[2*cur+2]);
    }

    // update index to val
    void update(int idx, int val, int cur, int tl, int tr){
        if(tl == tr){
            t[cur] = val;
            return;
        }        
        int mid = tl + (tr - tl) / 2;
        if(idx <= mid){
            update(idx, val, 2*cur+1, tl, mid);
        }else{
            update(idx, val, 2*cur+2, mid+1, tr);
        }
        t[cur] = max(t[2*cur+1], t[2*cur+2]);
    }

    // search from l to r
    int query(int l, int r, int cur, int tl, int tr){
        if(l <= tl and r >= tr){
            return t[cur];
        }else if(l > tr or r < tl){
            return -1;
        }else {
            int mid = tl + (tr - tl) / 2;
            return max(query(l, r, 2*cur+1, tl, mid), query(l, r, 2*cur+2, mid+1, tr));
        }

    }
};

Sum Segment Tree (Solution)

class SegmentTree {
    vector<int> seg; // Segment Tree to be stored in a vector.
public:
    SegmentTree(vector<int>& nums) {
        int n = nums.size();
        seg.resize(4 * n, 0);  // Maximum size of a segment tree for an array of size n is 4n
        buildTree(nums, 0, 0, n - 1); // Build the segment tree
    }
    void buildTree(vector<int>& nums, int pos, int left, int right) {
        if (left == right) {
            seg[pos] = nums[left];
            return;
        }
        int mid = left + (right - left) / 2;
        buildTree(nums, 2 * pos + 1, left, mid);
        buildTree(nums, 2 * pos + 2, mid + 1, right);
        seg[pos] = seg[2 * pos + 1] + seg[2 * pos + 2];
    }
    void updateTree(int pos, int left, int right, int idx, int val) {
        // no overlap
        if (idx < left || idx > right) return;
        
        // total overlap
        if (left == right) {
            if (left == idx) seg[pos] = val;
            return;
        }
        // partial overlap
        int mid = left + (right - left) / 2;
        updateTree(2 * pos + 1, left, mid, idx, val);
        updateTree(2 * pos + 2, mid + 1, right, idx, val);
        seg[pos] = seg[2 * pos + 1] + seg[2 * pos + 2];
    }
    
    int queryTree(int qleft, int qright, int left, int right, int pos) {
        if (qleft <= left && qright >= right) { // total overlap
            return seg[pos];
        }
        if (qleft > right || qright < left)  {  // no overlap
            return 0;
        }
        // partial overlap
        int mid = left + (right - left) / 2;
        return queryTree(qleft, qright, left, mid, 2 * pos + 1) + queryTree(qleft, qright, mid + 1, right, 2 * pos + 2);
    }
};

Segment Tree vector version (TLE)

class SegTree{
    public:
    vector<int> t;

    // input arr, length of input array
    SegTree(vector<int> arr){ 
        t.resize(4 * arr.size(), 0);
        build(arr, 0, 0,  arr.size()-1);
    }

    // input array, cur position, insert elements from tl to tr
    void build(vector<int> arr, int cur, int tl, int tr){
        if(tl == tr){
            t[cur] = arr[tl];
            return;
        }
        int mid = tl + (tr - tl) / 2;
        build(arr, 2 * cur + 1, tl, mid);
        build(arr, 2 * cur + 2, mid + 1, tr);
        t[cur] = t[2 * cur + 1] + t[2 * cur + 2];
    }

    // get the sum from l to r
    int getSum(int l, int r, int cur, int tl, int tr){
        if(l <= tl and r >= tr){
            return t[cur];
        }
        else if(r < tl || l > tr){
            return 0;
        }
        else{
            int mid = tl + (tr - tl) / 2;
            return getSum(l, r, 2*cur+1, tl, mid) + getSum(l, r, 2*cur+2, mid+1, tr);
        }

    }

    // set the idx value to val
    void update(int idx, int val, int cur, int tl, int tr){
        if(tl == tr){
            // cur is index in big tree array, should not equal to tl and tr
            // cout << "Updating cur " << t[cur] << " to " << val << endl;
            t[cur] = val;
            return;
        }

        int mid = tl + (tr - tl) / 2;
        if(idx <= mid){
            update(idx, val, 2*cur+1, tl, mid);
        } 
        else {
            update(idx, val, 2*cur+2, mid+1, tr);
        }

        t[cur] = t[2*cur+1] + t[2*cur+2];
    }
};

Segment Tree Array version (Didn’t test)

class SegTree{
    public:
    int *t;
    int t_len;

    // input arr, length of input array
    SegTree(int *arr, int len){ 
        t_len = 4 * len; // if power of 2, t_len = 2 * len - 1
        t = new int[t_len];
        build(arr, 0, 0, len-1);
    }

    // input array, cur position, insert elements from tl to tr
    void build(int *arr, int cur, int tl, int tr){
        if(tl == tr){
            t[cur] = arr[tl];
            return;
        }
        int mid = tl + (tr - tl) / 2;
        build(arr, 2 * cur + 1, tl, mid);
        build(arr, 2 * cur + 2, mid + 1, tr);
        t[cur] = t[2 * cur + 1] + t[2 * cur + 2];
    }

    // get the sum from l to r
    int getSum(int l, int r, int cur, int tl, int tr){
        if(l <= tl and r >= tr){
            return t[cur];
        }
        else if(r < tl || l > tr){
            return 0;
        }
        else{
            int mid = tl + (tr - tl) / 2;
            return getSum(l, r, 2*cur+1, tl, mid) + getSum(l, r, 2*cur+2, mid+1, tr);
        }

    }

    // set the idx value to val
    void update(int idx, int val, int cur, int tl, int tr){
        if(tl == tr){
            // cur is index in big tree array, should not equal to tl and tr
            // cout << "Updating cur " << t[cur] << " to " << val << endl;
            t[cur] = val;
            return;
        }

        int mid = tl + (tr - tl) / 2;
        if(idx <= mid){
            update(idx, val, 2*cur+1, tl, mid);
        } 
        else {
            update(idx, val, 2*cur+2, mid+1, tr);
        }

        t[cur] = t[2*cur+1] + t[2*cur+2];
    }

    void show(){
        for(int i = 0; i < t_len; i ++){
            cout << t[i] << " ";
        }
        cout << endl;
    }
};

Monotonic queue: Max for sliding window

2022-09-05T00:00:00+00:00

Part 1 - Max in sliding window

Use a monotonic queue O(n)

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        // queue of indecies
        deque<int> q;
        vector<int> res;
        for(int i = 0; i < nums.size(); i++){
            // remove outlated indecies
            while(!q.empty() and q.front() <= i - k){
                q.pop_front();
            }
            // remove the smaller elements
            while(!q.empty() and nums[q.back()] < nums[i]){
                q.pop_back();
            }
            
            q.push_back(i);
            if(i - k + 1 >= 0){
                res.push_back(nums[q.front()]);
            }
        }
        
        return res;
    }
};

Multiset method O(nlogn)

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        multiset<int> s;
        for(int i = 0; i < k; i++){
            s.insert(nums[i]);
        }
        vector<int> res;
        res.push_back(*(s.rbegin()));
        for(int i = k; i < nums.size(); i++){
            s.erase(s.find(nums[i-k]));
            s.insert(nums[i]);
            res.push_back(*(s.rbegin()));
        }
        return res;
    }
};

System design

2022-09-04T00:00:00+00:00

Part 1 - Design an iterator to flatten nestedList

Method 1: use dfs to traverse all the leaf of a M-way tree

Put in vector and build a vector iterator

class NestedIterator {
public:
    vector<int>::iterator it;
    vector<int>::iterator end;
    vector<int>res;
    
    NestedIterator(vector<NestedInteger> &nestedList) {
        for(NestedInteger& list : nestedList){
            dfs(list);
        }
        it = res.begin();
        end = res.end();
    }
    
    void dfs(NestedInteger& root){
        if(root.isInteger()){
            res.push_back(root.getInteger());
        }else{
            for(NestedInteger& list : root.getList()){
                dfs(list);
            }
        }
    }
    
    int next() {
        int a = *it;
        it++;
        return a;
    }
    
    bool hasNext() {
        return it < end;
    }
};

Method 2: remove first integer

Using stack to optimize

class NestedIterator {
public:
    stack<vector<NestedInteger>::iterator>begins;
    stack<vector<NestedInteger>::iterator>ends;
    
    NestedIterator(vector<NestedInteger> &nestedList) {
        begins.push(nestedList.begin());
        ends.push(nestedList.end());
    }
    
    int next() {
        return (begins.top()++)->getInteger();
    }
    
    bool hasNext() {
        while(!begins.empty()){
            if(begins.top() == ends.top()){
                begins.pop();
                ends.pop();
            }else{
                vector<NestedInteger>::iterator x = begins.top();
                if((*x).isInteger()){
                    return true;
                }else{
                    begins.top()++;
                    begins.push((*x).getList().begin());
                    ends.push((*x).getList().end());
                }
            }
        }
        return false;
    }
};

Part 2 - Constant time delete

380. Insert Delete GetRandom O(1)
- Swap the desired element to vector’s end to pop_back
- Use a map to track the index

Part 3 - Bit map for repeated alphabets

class Solution {
public:
    int partitionString(string s) {
        int cnt = 1;
        int bitMap = 0;
        
        for(int i = 0; i < s.length(); i++){
            int n = s[i] - 'a';
            if(bitMap & (1 << n)){
                bitMap = 0;
                cnt ++;
            }
            bitMap = bitMap | (1 << n);
        }   
        return cnt;
    }
};

K Sum

2022-09-03T00:00:00+00:00

1 - Two Sum

Sort
Use a low and high pointer
Use while to skip duplicates

vector<vector<int>> TwoSum(vector<int>& nums, long long target, int idx){
    vector<vector<int>> res;
    int lo = idx;
    int hi = nums.size()-1;
    while(lo < hi){
        long long sum = nums[lo] + nums[hi];
        if(sum < target){
            lo ++;
        }else if(sum > target){
            hi --;
        }else{
            res.push_back({nums[lo], nums[hi]});
            while(lo < hi and nums[lo+1] == nums[lo]) lo++;
            while(hi > lo and nums[hi-1] == nums[hi]) hi--;
            lo ++; hi --;
        }
    }
    return res;
}

2 - K Sum

Recursion to reduce to twoSum case
Remember to skip duplicates during the kSum i loop
Remember to use long long for target

class Solution {
public:
    vector<vector<int>> TwoSum(vector<int>& nums, long long target, int idx){
        vector<vector<int>> res;
        int lo = idx;
        int hi = nums.size()-1;
        while(lo < hi){
            long long sum = nums[lo] + nums[hi];
            if(sum < target){
                lo ++;
            }else if(sum > target){
                hi --;
            }else{
                res.push_back({nums[lo], nums[hi]});
                while(lo < hi and nums[lo+1] == nums[lo]) lo++;
                while(hi > lo and nums[hi-1] == nums[hi]) hi--;
                lo ++; hi --;
            }
        }
        return res;
    }
        
    
    vector<vector<int>> kSum(vector<int>& nums, int n, int idx, long long target){
        if(n == 2){
            return TwoSum(nums, target, idx);
        }else{
            vector<vector<int>> res;
            for(int i = idx; i < nums.size(); i++){
                if(i != idx and nums[i] == nums[i-1])
                    continue;
                vector<vector<int>> sub = kSum(nums, n-1, i+1, target-(long)nums[i]);
                for(auto& vec : sub){
                    vec.push_back(nums[i]);
                    res.push_back(vec);
                }
            }
            return res;
        }
    }
    
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        return kSum(nums, 4, 0, target);
    }
};

Buy-sell Stock

2022-09-02T00:00:00+00:00

1 - Buy-sell once

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int notHave = 0;
        int have = -prices[0];
        for(int i = 1; i < prices.size(); i++){
            notHave = max(notHave, have + prices[i]);
            have = max(have, 0 - prices[i]);
        }
        return notHave;
    }
};

2 - Buy-sell infinite times

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int notHave = 0;
        int have = -prices[0];
        for(int i = 1; i < prices.size(); i++){
            notHave = max(notHave, have + prices[i]);
            have = max(have, notHave - prices[i]);
        }
        return notHave;
    }
};

3 - Buy-sell infinite times with cooldown

309. Best Time to Buy and Sell Stock with Cooldown
- 1 day cooldown to buy again
- need understand why dp[having stock on day i] is dp[i-2][notHave]
- remember start at i = 2

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 1){
            return 0;
        }
        int notHave = 0;
        int have = -prices[0];
        int prev = 0;
        notHave = max(0, have + prices[1]);
        have = max(-prices[1], have);
        for(int i = 2; i < prices.size(); i++){
            int temp = notHave;
            notHave = max(notHave, have + prices[i]);
            have = max(have, prev - prices[i]);
            prev = temp;
        }
        return notHave;
        
    }
};

4 - Buy-sell k_max times

If k_max exceeds half the size, return maxProfitInf
Remember to initialize the base case of i = 0

class Solution {
public:
    int maxProfit(int k_max, vector<int>& prices) {
        if(prices.size() <= 1){
            return 0;
        }
        if(k_max > prices.size()/2){
            return maxProfitInf(prices);
        }
        
        vector<vector<vector<int>>>dp (prices.size(), vector<vector<int>>(k_max+1, vector<int>(2, 0)));
        for(int k = 1; k <= k_max; k++){
            dp[0][k][1] = -prices[0];
        }
        
        for(int i = 1; i < prices.size(); i++){
            for(int k = 1; k <= k_max; k ++){
                dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
                dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]);
            }
               
        }
        return dp[prices.size()-1][k_max][0];
    }
};