分治法-leetcode

分治策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

215. Kth Largest Element in an Array

找到无序数组中第K大的数
思路一：快排
思路二：堆
这里采用的可以是内建数据结构：priority_queue或者是自己写一个堆排序https://leetcode.com/problems/kth-largest-element-in-an-array/?tab=Solutions
priority_queue int q; 默认大根堆
priority_queue int, vector int,greater int minHeap;小根堆
模板声明带有三个参数，priority_queue（Type, Container, Functional）。Type 为数据类型， Container 为保存数据的容器，Functional 为元素比较方式。Container 必须是用数组实现的容器，比如 vector, deque 但不能用 list。STL里面默认用的是 vector. 比较方式默认用 operator< , 所以如果你把后面俩个参数缺省的话，优先队列就是大顶堆，队头元素最大。

class Solution {
public:
    int partion(vector<int>& nums, int low, int high) {
        int flag = nums[high];
        int i = low - 1;
        for (int j = low; j < high; ++j){
            if (nums[j] <= flag) {
                ++i;
                swap(nums[i], nums[j]);
            }
        }
        //注意这里交换的是nums[high]不是flag
        swap(nums[i+1], nums[high]);
        return i+1;
    }
    int quickSortK(vector<int>& nums, int k, int low, int high) {
        if(low >= high) return nums[low];  
        int midPos = partion(nums, low, high);
        if ((nums.size() - midPos) == k) return nums[midPos];
        else if  ((nums.size() - midPos) > k) return quickSortK(nums, k, midPos + 1, high);
        else return quickSortK(nums, k, low, midPos - 1);
    }
    int findKthLargest(vector<int>& nums, int k) {
   /*  //利用priority，也可以自己写一个堆排序  
       priority_queue<int, vector<int>,greater<int> > minHeap;
       for (int i = 0; i < k; ++i) minHeap.push(nums[i]);
       for (int i = k; i < nums.size(); ++i) {
           if (nums[i] > minHeap.top()) {
               minHeap.pop();
               minHeap.push(nums[i]);
           }
       }
       return minHeap.top();*/
       return quickSortK(nums, k, 0, nums.size()-1);
    }
};

241. Different Ways to Add Parentheses

Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, - and *.
Input: “2-1-1”. Output: [0,2]

思路：循环或者动态规划（这里循环的过程有很多重复的地方，所以可以记录下来避免重复计算）动态规划解法：

class Solution {
public:
    unordered_map<string, vector<int>> dpMap;
    vector<int> diffWaysToCompute(string input) {
        vector<int> ret;
        for(int i = 0; i < input.size(); i ++)
        {
            if (input[i] == '+' || input[i] == '-' || input[i] == '*')
            {   
                vector<int> left, right;

                string leftStr = input.substr(0, i);
                if (dpMap.find(leftStr) != dpMap.end()) left = dpMap[leftStr];
                else left = diffWaysToCompute(leftStr);

                string rightStr = input.substr(i+1);
                if (dpMap.find(rightStr) != dpMap.end()) right = dpMap[rightStr];
                else right = diffWaysToCompute(rightStr);

                for(int j = 0; j < left.size(); j ++)
                {
                    for(int k = 0; k < right.size(); k ++)
                    {
                        if(input[i] == '+')
                            ret.push_back(left[j] + right[k]);
                        else if(input[i] == '-')
                            ret.push_back(left[j] - right[k]);
                        else
                            ret.push_back(left[j] * right[k]);
                    }
                }
            }
        }
        //only number without 
        if (ret.empty()) ret.push_back(atoi(input.c_str()));
        dpMap[input] = ret;
        return ret;
    }
};

240. Search a 2D Matrix II

在一个二维数组中查找某个值
思路一：二分查找，每次去掉左上角或者右下角

class Solution {
public:
    bool help(vector<vector<int>>& matrix, int target, int llow, int lhigh, int rlow, int rhigh) {
        if (llow > lhigh || rlow > rhigh) return false;
        if(rlow == rhigh && llow == lhigh) return matrix[llow][rlow] == target;
        int lmid = (llow + lhigh) / 2;
        int rmid = (rlow + rhigh) / 2;
        if (matrix[lmid][rmid] == target) 
            return true;
        else if (matrix[lmid][rmid] > target) 
            return help(matrix, target, llow, lmid - 1, rlow, rhigh)||help(matrix, target, llow, lhigh, rlow, rmid-1);
        else 
            return help(matrix, target, lmid+1, lhigh, rlow, rhigh)||help(matrix, target, llow, lhigh, rmid+1, rhigh);
    }
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if (matrix.empty()) return false;
        int lineNum = matrix.size();
        int colNum = matrix[0].size(); 
        return help(matrix, target, 0, lineNum-1, 0, colNum-1);

    }
};

更高效的写法：从右上角入手，每次去掉一行或者一列
一个是注意i和j代表什么，别弄反了；另外一个是注意边界条件，是否等于0。

class Solution {
public:

    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if (matrix.empty()) return false;
        int lineNum = matrix.size();
        int colNum = matrix[0].size(); 
        int i = 0;
        int j = colNum - 1;
        while (i < lineNum && j >= 0)
        {
            if (matrix[i][j] == target) return true;
            else if (matrix[i][j] > target) --j;
            else ++i;
        }
        return false;
    }
};