leetcode之分治总结

169. Majority Element

题目描述：给定一个数组，求该数组中出现超过一半的数字。

解题思路：Moore Voting

代码如下：

class Solution {
public:
    int majorityElement(vector<int>& nums) 
    {
        int candidate=nums[0];
        int ret=1;
        for(int j=1;j<nums.size();j++)
        {
            if(nums[j]==candidate)
            {
                ret++;
            }
            else
            {
                ret--;
            }
            if(ret<=0)
            {
                candidate=nums[j];
                ret=1;
            }
        }
        return candidate;
    }
};

229. Majority Element II
题目描述：寻找数组中元素个数超过三分之一的元素。

思路：Moore Voting，求出现最多的两个数字，然后看看是否超过三分之一，代码如下。

代码：

class Solution {
public:
    vector<int> majorityElement(vector<int>& nums) 
    {
        vector<int> res;
        int m = 0, n = 0, cm = 0, cn = 0;
        for (auto &a : nums) 
        {
            if (a == m) ++cm;
            else if (a ==n) ++cn;
            else if (cm == 0) m = a, cm = 1;
            else if (cn == 0) n = a, cn = 1;
            else --cm, --cn;
        }
        cm = cn = 0;
        for (auto &a : nums) 
        {
            if (a == m) ++cm;
            else if (a == n) ++cn;
        }
        if (cm > nums.size() / 3) res.push_back(m);
        if (cn > nums.size() / 3) res.push_back(n);
        return res;
    }
};

241. Different Ways to Add Parentheses
题目描述：给定一个字符串，然后添加括号后，求所有的可能结果。

Example 1

Input: "2-1-1".

((2-1)-1) = 0
(2-(1-1)) = 2

Output: [0, 2]

Example 2

Input: "2*3-4*5"

(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

Output: [-34, -14, -10, -10, 10]

解题思路：首先统计所有的运算符，分治分别求两边的结果即可。

代码：

class Solution {
public:
    vector<int> diffWaysToCompute(string input) 
    {
        return dfs(input);
        
    }
    vector<int> dfs(string input)
    {
        vector<int> index;
        vector<int> ret;
        for(int i=0;i<input.size();i++)
        {
            if(input[i]=='+'||input[i]=='-'||input[i]=='*')
            {
                index.push_back(i);
            }
        }
        if(index.size()==0)
        {
            int num;
            stringstream ss(input);
            ss>>num;
            ret.push_back(num);
            return ret;
        }
        for(int i=0;i<index.size();i++)
        {
            char ch=input[index[i]];
            vector<int> a=dfs(input.substr(0,index[i]));
            vector<int> b=dfs(input.substr(index[i]+1));
            for(int i=0;i<a.size();i++)
            {
                for(int j=0;j<b.size();j++)
                {
                    if(ch=='+')
                    {
                        ret.push_back(a[i]+b[j]);
                    }
                    if(ch=='-')
                    {
                        ret.push_back(a[i]-b[j]);
                    }
                    if(ch=='*')
                    {
                        ret.push_back(a[i]*b[j]);
                    }
                }
            }
        }
        return ret;
    }
};

215. Kth Largest Element in an Array

题目描述：给定一个数组，返回第K大的元素

解题思路：discuss给出四种解题思路；思路，排序，最大堆，快排的思想，优先队列；

代码一：快速排序的思想

class Solution {
public:
    int partition(vector<int>& nums, int left, int right)
    {
        int pivot=nums[left];
        int l=left+1;
        int r=right;
        while(l<=r)
        {
            while(l<=r&&nums[l]>=pivot)
            {
                l++;
            }
            while(l<=r&&nums[r]<=pivot)
            {
                r--;
            }
            if(l<r)
            {
                swap(nums[l],nums[r]);
            }
        }
        swap(nums[left],nums[r]);
        return r;
    }
    int findKthLargest(vector<int>& nums, int k) 
    {
        int left=0;
        int right=nums.size()-1;
        while(true)
        {
            int pos=partition(nums,left,right);
            if(pos==k-1)
            {
                return nums[pos];
            }
            if(pos<k-1)
            {
                left=pos+1;
            }
            else
            {
                right=pos-1;
            }
        }
        
    }
};

思路2:堆排序，采用优先队列

代码如下：

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int> pq(nums.begin(), nums.end());
        for (int i = 0; i < k - 1; i++)
            pq.pop(); 
        return pq.top();
    }
}; 

74. Search a 2D Matrix

题目描述：给定一个排好序的二维数组，判断元素是否存在。

[
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]

如果给定3，返回真

解题思路：二分查找

代码：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) 
    {
        if(matrix.size()==0||matrix[0].size()==0)
        {
            return false;
        }
        int l=0;
        int r=matrix.size()*matrix[0].size()-1;
        while(l+1<r)
        {
            int m=l+(r-l)/2;
            int temp=matrix[m/matrix[0].size()][m%matrix[0].size()];
            if(temp==target)
            {
                return true;
            }
            else
            {
                if(temp>target)
                {
                    r=m-1;
                }
                else
                {
                    l=m+1;
                }
            }
        }
        if(matrix[l/matrix[0].size()][l%matrix[0].size()]==target||matrix[r/matrix[0].size()][r%matrix[0].size()]==target)
        {
            return true;
        }
        return false;
        
    }
};

240. Search a 2D Matrix II
题目描述：

Consider the following matrix:

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

Given target = 5, return true.

Given target = 20, return false.

思路：二分查找

代码：

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) 
    {
        int n=matrix.size();
        if(n==0)
        {
            return false;
        }
        int m=matrix[0].size();
        if(m==0)
        {
            return false;
        }
        int row=0;
        int col=m-1;
        while(row<n&&row>=0&&col<m&&col>=0)
        {
            if(matrix[row][col]==target)
            {
                return true;
            }
            if(matrix[row][col]>target)
            {
                col--;
            }
            if(matrix[row][col]<target)
            {
                row++;
            }
        }
        return false;
        
    }
};