11月27日 剑指offer 数字在排序数组中出现的次数 && Leetcode Valid Parentheses

题目描述
统计一个数字在排序数组中出现的次数。

解析：其实就是实现下lower_bound 和 upper_bound 。

我们只要找到第一个出现的k然后找到最后一个出现的k即可。

我们拿找到第一个k举例子。

因为是有序的，所以肯定使用二分。

那么首先得到mid值。

然后分三种情况

1）如果data[mid] == k ，那么里面分2种情况，
（1）如果（mid>0&&data[mid-1]!=k） || mid ==0 那么这就是第一个找到k的位置
（2）第二种就是前面还存在等于k的值 那么end = mid-1
2）如果dat[mid]>k，那么 end = mid-1
3）剩余一种情况就是 data[mid]<k ，那么start = mid +1

代码：

class Solution 
{
public:
    int GetFirstK(vector<int>data, int k, int start, int end)
    {
        if (start>end) return -1;
        int mid = (start + end) >> 1;
        int midData = data[mid];


        if (midData == k)
        {
            if ((mid>0 && data[mid - 1] != k) || mid == 0) return mid; //已经到了最左边的边界
            else end = mid - 1;
        }
        else if (midData>k)
            end = mid - 1;
        else
            start = mid + 1;
        return GetFirstK(data, k, start, end);
    }


    int GetLastK(vector<int>data,int k,int start,int end)
    {
        if(start>end) return -1;
        int mid = (start +end) >>1;
        int midData = data[mid];
        if(midData == k)
        {
            if((mid<end&&data[mid + 1] != k)||mid == end) return mid;
            else start = mid + 1;
        }
        else if(midData > k)
            end = mid - 1;
        else 
            start = mid+1;
        return GetLastK(data,k,start,end);
    }

    int GetNumberOfK(vector<int> data, int k)
    {
        int len = data.size();
        if (len == 0) return 0;
        int start = 0, end = len - 1;
        //cout << start <<" "<< end << endl;
        int first_index = GetFirstK(data, k, start, end);
        //cout << first_index << endl;
        //cout<< GetLastK(data, k , start, end);
        int second_index = GetLastK(data, k, start, end);

        if(first_index>-1 && second_index>-1) return second_index - first_index + 1;
        return 0;
    }
};

Leetcode Valid Parentheses

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

解析：首先回溯把所有的可能性列举出来，然后在利用栈把合法的字符串找出来。

代码：

class Solution {
public:
    void dfs(vector<string>&vec,string s,int cnt,int n,char* ch)
	{
		if(cnt == 2*n) 
		{
			vec.push_back(s);
			return;
		}
		for(int i=0;i<2;i++)
		{
			s.push_back(ch[i]);
			dfs(vec,s,cnt+1,n,ch);
			s.pop_back();
		}
	}


	bool isValid(string str)
	{
		stack<char> st;
		int len = str.length();
		st.push(str[0]);
		for(int i=1;i<len;i++)
		{
			if(st.empty()||str[i]=='(') st.push(str[i]);
			else 
			{
				char top_ch = st.top();
				if(top_ch=='('&&str[i]==')') st.pop();
				else return false;
			}
		}
		return st.empty()?true:false;
	}

	vector<string> generateParenthesis(int n) 
	{
	    vector<string> vec;
	    vector<string> ans;
	    string str = "(";
	    char ch[2] = {'(',')'};
	    int cnt = 1;
	    dfs(vec,str,cnt,n,ch);
	    int len = vec.size();
	    typedef std::vector<string>::const_iterator Iter;
	    Iter it = vec.begin();
	    while(it!=vec.end())
	    {
	    	string temp_str = *it;
	    	if(isValid(temp_str)) ans.push_back(temp_str);
	        ++it;
	    }
	    return ans;
	}
};