【LeetCode】分治法 divide and conquer （共17題）

鏈接：https://leetcode.com/tag/divide-and-conquer/

 

【4】Median of Two Sorted Arrays 

【23】Merge k Sorted Lists 

 

【53】Maximum Subarray (2019年1月23日， 谷歌tag復習)

最大子段和。

題解：

follow up 是divide and conquer

If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle. 

 

【169】Majority Element 

 

【215】Kth Largest Element in an Array (2018年12月11日，wiggle sort 專題，需要復習)

用 O(n) 的時間復雜度找到數組中第 K 大的元素。重復元素也計入 K。

題解：本題可以用 heap 解答，時間復雜度是 O(nlogK)。其實還可以用 quick select 解答（也就是快排的partition(2-way partition)），平均復雜度是 O(n)，最壞是 O(n^2)。為了搞平均，一開始要把數組 random_shuffle 一下，盡可能避免 worst case。 

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        random_shuffle(nums.begin(), nums.end());
        const int n = nums.size();
        int start(0), end(n-1), index(n-k);        
        while (start < end) {
            int idx = partition(nums, start, end);
            if (idx < index) {
                start = idx + 1;
            } else if (idx > index) {
                end = idx - 1;
            } else {
                return nums[idx];
            }
        }
        return nums[start];
    }
    int partition(vector<int>& nums, int start, int end) {
        int pivot = start;
        while (start < end) {
            while (nums[start] <= nums[pivot]) {
                start++;
            }
            while (nums[end] > nums[pivot]) {
                end--;
            }
            if (start > end) {break;}
            swap(nums[start], nums[end]);
        }
        swap(nums[end], nums[pivot]);
        return end;
    }

};

 

【218】The Skyline Problem 

【240】Search a 2D Matrix II 

【241】Different Ways to Add Parentheses （2018年11月15日，算法群）

給了一個字符串算式，里面含有 “+”，“-”，“*” 這三種運算符，可以在算式的任何一個地方加括號，整個算式能加的括號數不限。問這個算式所有可能的答案。

Example 1:
Input: "2-1-1"
Output: [0, 2]
Explanation: 
((2-1)-1) = 0 
(2-(1-1)) = 2

Example 2:
Input: "2*3-4*5"
Output: [-34, -14, -10, -10, 10]
Explanation: 
(2*(3-(4*5))) = -34 
((2*3)-(4*5)) = -14 
((2*(3-4))*5) = -10 
(2*((3-4)*5)) = -10 
(((2*3)-4)*5) = 10

 題解：我們可以在任意地方加括號，每個運算符的兩邊都可以加個括號看成是一個子問題，先把子問題的所有解求出來，然后把兩個子問題的解集合做笛卡爾積，形成大問題的解集合。

審題很重要，我一度以為如果運算符是 ‘-’ 的話，那么后面的算式的 加號要變成減號，減號要變成加號，這個題意里面是沒有的。

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {
        return calPart(input);
    }
    vector<int> calPart(string s) {
        const int n = s.size();
        if (record.find(s) != record.end()) {return record[s];}
        //純數字的情況
        if (s.find("+") == string::npos && s.find("-") == string::npos && s.find("*") == string::npos) {
            vector<int> ret{stoi(s)};
            return ret;
        }
        //含有運算符的情況
        vector<int> res;
        for (int i = 0; i < n; ++i) {
            if (!isdigit(s[i])) {
                string front = s.substr(0, i), back = s.substr(i+1);
                vector<int> resFront = calPart(front), resBack = calPart(back);
                for (auto f : resFront) {
                    for (auto b : resBack) {
                        int tempres = 0;
                        if (s[i] == '+') {
                            tempres = f + b;
                        } else if (s[i] == '-') {
                            tempres = f - b;
                        } else if (s[i] == '*') {
                            tempres = f * b;
                        }
                        res.push_back(tempres);
                    }
                }
            }
        }
        //sort(res.begin(), res.end());
        record[s] = res;
        return res;
    }
    unordered_map<string, vector<int>> record;
};

 

【282】Expression Add Operators (2019年3月16日，dfs，打卡題)

Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or *between the digits so they evaluate to the target value.

 

Example 1:
Input: num = "123", target = 6
Output: ["1+2+3", "1*2*3"] 

Example 2:
Input: num = "232", target = 8
Output: ["2*3+2", "2+3*2"]

Example 3:
Input: num = "105", target = 5
Output: ["1*0+5","10-5"]

Example 4:
Input: num = "00", target = 0
Output: ["0+0", "0-0", "0*0"]

Example 5:
Input: num = "3456237490", target = 9191
Output: []

 

題解：如果本題只有加號和減號，那么就是一個直接的dfs。但是本題還有一個乘號，乘號的可以提前優先級運算。所以我們需要保存最后一個單項式的值。

比如說我們已經計算了 1 + 2 - 3 ___  5 要填寫 3 和 5 之間的符號的時候， 如果我們想填個乘號，那么，我們需要最后一項 -3，所以我們用一個變量保存當前表達式的最后一個參數，作為 dfs 的參數。

class Solution {
public:
    vector<string> addOperators(string num, int target) {
        vector<string> res;
        string temp;
        dfs(num, temp, res, (long)target, 0, 0LL, 0LL);
        return res;
    }
    void dfs(const string num, string temp, vector<string>& res, long target, int start, long curRes, long lastVal) {
        if (start == num.size()) {
            if (target == curRes) {res.push_back(temp);}
            return;
        }
        for (int i = start; i < num.size(); ++i) {
            string strCur = num.substr(start, i - start + 1);
            if (strCur.size() > 1 && strCur[0] == '0') {break;} //leading zeros
            long iCur = stol(strCur);
            if (start == 0) {
                dfs(num, strCur, res, target, i+1, iCur, iCur);
            } else {
                dfs(num, temp + "+" + strCur, res, target, i + 1, curRes + iCur, iCur);
                dfs(num, temp + "-" + strCur, res, target, i + 1, curRes - iCur, -iCur);
                dfs(num, temp + "*" + strCur, res, target, i + 1, curRes - lastVal + lastVal * iCur, lastVal * iCur);
            }
        }
    }
};

 

【312】Burst Balloons 

 

【315】Count of Smaller Numbers After Self (2019年2月12日，歸並排序)

給了一個數組，要求返回一個數組，返回數組中的元素是原數組中每個元素右邊比它小的個數。

Input: [5,2,6,1]

Output: [2,1,1,0] 

Explanation:

To the right of 5 there are 2 smaller elements (2 and 1).

To the right of 2 there is only 1 smaller element (1).

To the right of 6 there is 1 smaller element (1).

To the right of 1 there is 0 smaller element.

題解：這個題可以用線段數，樹狀數組，分治法來解。下面說一下分治法怎么解。

在每一輪中，我們可以把整個數組分成左右兩半，利用歸並排序的思想，把左區間和右區間變的有序之后，這樣我們就可以把左區間內的任意一個元素nums[i]，在右區間內用 lower_bound 找到有多少個元素小於它，然后把這個值加到res[i]上。

一共需要三個數組：nums, sorted, count。原來的數據存在nums, 歸並排序后的數組存在sortedNums, count[i]對應的是nums[i]的 number of smaller elements to the right.

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums) {
        const int n = nums.size();
        vector<int> sorted(nums.begin(), nums.end()), res(n, 0);
        if (n == 0) {return res;}
        mergesort(nums, sorted, 0, n-1, res);
        return res;
    }
    void mergesort(vector<int>& nums, vector<int>& sorted, int begin, int end, vector<int>& res) {
        if (begin == end) { return; }
        int mid = (begin + end) / 2;
        mergesort(nums, sorted, begin, mid, res);
        mergesort(nums, sorted, mid + 1, end, res);
        for (int i = begin; i <= mid; ++i) {
            int value = nums[i];
            auto iter = lower_bound(sorted.begin() + mid + 1, sorted.begin() + end + 1, value);
            res[i] += distance(sorted.begin() + mid + 1, iter);
        }
        //merge
        vector<int> arr1(sorted.begin() + begin, sorted.begin() + mid + 1), 
                    arr2(sorted.begin() + mid + 1, sorted.begin() + end + 1);
        int p1 = 0, p2 = 0;
        for (int idx = begin; idx <= end; ++idx) {
            if (p1 == arr1.size()) {
                sorted[idx] = arr2[p2++];
            } else if (p2 == arr2.size()) {
                sorted[idx] = arr1[p1++];
            } else {
                if (arr1[p1] < arr2[p2]) {
                    sorted[idx] = arr1[p1++];
                } else {
                    sorted[idx] = arr2[p2++];
                }
            }
        }
    }
};

 

【327】Count of Range Sum （2019年2月14日，谷歌tag，歸並排序）

給了一個數組nums，和一個范圍 [lower, upper]，返回有多少個子數組的和在這個范圍之內。

題解：

【426】Convert Binary Search Tree to Sorted Doubly Linked List 

 

【493】Reverse Pairs (2019年2月19日，歸並排序)

給定一個數組，求它的逆序對個數。本題的逆序對的定義和別的題不同：if i < j and nums[i] > 2*nums[j].

題解：我們這個題目同315，用分治法解題。我們把這整個數組分成兩個區間，然后分別對這兩個左右區間做歸並排序。然后對右邊區間的每一個元素 nums[j], target = nums[j] * 2。然后用 upper_bound() 求出左區間內第一個比 target 大的元素，從這個元素開始 到左區間結束，這些元素都能和 target 組成逆序對。所以把這些元素加到結果上。

class Solution {
public:
    typedef long long LL;
    int reversePairs(vector<int>& nums) {
        if (nums.empty()) {return 0;}
        int n = nums.size();
        vector<LL> arr(n);
        for (int i = 0; i < n; ++i) {
            arr[i] = nums[i];
        }
        divideAndConquer(arr, 0, n-1);
        return res;
    }
    int res = 0;
    void divideAndConquer(vector<LL>& nums, int start, int end) {
        if (start == end) {return;}
        int mid = start + (end - start) / 2;
        divideAndConquer(nums, start, mid);
        divideAndConquer(nums, mid + 1, end);
        for (int j = mid + 1; j <= end; ++j) {
            LL target = nums[j] * 2;
            auto iter = upper_bound(nums.begin() + start, nums.begin() + mid + 1, target);
            res += distance(iter, nums.begin() + mid + 1);
        }
        // print(nums, start, end);
        inplace_merge(nums.begin() + start, nums.begin() + mid + 1, nums.begin() + end + 1);
        // print(nums, start, end);
    }
    void print(vector<LL>& nums, int start, int end) {
        for (int i = start; i <= end; ++i) {
            printf("%lld ", nums[i]);
        }
        printf("\n");
    }
};

  

【514】Freedom Trail 

【903】Valid Permutations for DI Sequence 

【932】Beautiful Array