LeetCode练习-分治法

一、Pow(x,n)

描述：

Implement pow(x, n).

思路：二分法， pow(x, n/2) * pow(x, n/2) * pow(x, n%2)

double myPow(double x, int n);
double power(double x, int n);
int main()
{
	int a, n;
	cin >> a >> n;
	cout << myPow(a, n) << endl;
}
double myPow(double x, int n)
{
    if (n < 0) 
		return 1.0 / power(x, -n);
    else 
		return power(x, n);
}

double power(double x, int n) {
    if (n == 0) return 1;
    double v = power(x, n / 2);
    if (n % 2 == 0) return v * v;
    else return v * v * x;
}

double power(double x, int n)//运行时间长，很慢
{
	if(n == 0)
		return 1;
	else if(n == 1)
		return x;
	else
	{
		double v = power(x, n/2);
		return v * v * power(x, n%2);//此处又有递归，所以时间长
	}
}

二、Sqrt(x)

描述：

Implement int sqrt(int x).
Compute and return the square root of x.

思路：二分查找

注：注意相乘溢出问题！！！

/*Sqrt(x, n),开x的n次方*/
double Sqrt(double x);
int Sqrt(int x);
void main()
{
	int x;
	while(cin >> x)
		cout << Sqrt(x) << endl;
}
int Sqrt(int x)
{
	if(x==1)
		return 1;
	int i=0, j=x, mid = (i+j)/2;

	while(i!=mid)
	{
		if(x/mid0.00001 || s<-0.00001)
	{
		if(s > 0.00001)
			j = mid;
		else
			i = mid;
		mid = (i+j)/2;
		temp = mid * mid;//可能会溢出
		s = temp - x;
	}
	return mid;
}

三、permutations

题目描述
Given a collection of numbers, return all possible permutations.
For example,
[1,2,3]have the following permutations:
[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2], and[3,2,1].

思路：递归，插入

例如：

1

21，12（上边每个序列有两个插入位置，即1前和1后）

321，231，213，312，132，123（上边每个序列有三个插入位置，把3插入，并存储）

......

class Solution {
public:
    vector > permute(vector &num) {
        vector > result;

        int i, j;
        if(num.size() == 1){
            result.push_back(num);
            return result;
        }
        else{
            int curr = num[num.size()-1];
            num.pop_back();
            vector > result_pre;
            result_pre = permute(num);

            for(i=0; i temp = result_pre[i];

                for(j=0; j<=temp.size(); ++j){
                    temp.insert(temp.begin()+j,1,curr);
                    result.push_back(temp);

                    temp.clear();
                    temp = result_pre[i];
                }
            }
            return result;
        }
    }
};

四、permutations-ii

题目描述
Given a collection of numbers that might contain duplicates, return all possible unique permutations.
For example,
[1,1,2]have the following unique permutations:
[1,1,2],[1,2,1], and[2,1,1].

思路：如第三题，在第三题的基础上加入了排序、去重！

class Solution {
public:
    vector > permuteUnique(vector &num){
        vector > result;
        int i, j;
        if(num.size() == 1){
            result.push_back(num);
            return result;
        }
        else{
            int curr = num[num.size()-1];
            num.pop_back();
            vector > result_pre;
            result_pre = permuteUnique(num);
            for(i=0; i temp = result_pre[i];
                for(j=0; j<=temp.size(); ++j){
                    temp.insert(temp.begin()+j, 1, curr);
                    result.push_back(temp);

                    temp.clear();
                    temp = result_pre[i];
                }
            }
            sort(result.begin(), result.end());//排序
            result.erase(unique(result.begin(), result.end()), result.end());//去重
            return result;
        }
    }
};

五、restore-ip-addresses

题目描述
Given a string containing only digits, restore it by returning all possible valid IP address combinations.
For example:
Given"25525511135",
return["255.255.11.135", "255.255.111.35"]. (Order does not matter)

（参考：http://www.cnblogs.com/grandyang/p/4305572.html）

思路：这道题要求是复原IP地址，IP地址对我们并不陌生，就算我们不是学CS的，只要我们是广大网友之一，就应该对其并不陌生。IP地址由32位二进制数组成，为便于使用，常以XXX.XXX.XXX.XXX形式表现，每组XXX代表小于或等于255的10进制数。所以说IP地址总共有四段，每一段可能有一位，两位或者三位，范围是[0, 255]，题目明确指出输入字符串只含有数字，所以当某段是三位时，我们要判断其是否越界（>255)，还有一点很重要的是，当只有一位时，0可以成某一段，如果有两位或三位时，像 00， 01， 001， 011， 000等都是不合法的，所以我们还是需要有一个判定函数来判断某个字符串是否合法。这道题其实也可以看做是字符串的分段问题，在输入字符串中加入三个点，将字符串分为四段，每一段必须合法，求所有可能的情况。根据目前刷了这么多题，得出了两个经验，一是只要遇到字符串的子序列或配准问题首先考虑动态规划DP，二是只要遇到需要求出所有可能情况首先考虑用递归。这道题并非是求字符串的子序列或配准问题，更符合第二种情况，所以我们要用递归来解。我们用k来表示当前还需要分的段数，如果k = 0，则表示三个点已经加入完成，四段已经形成，若这时字符串刚好为空，则将当前分好的结果保存。若k != 0, 则对于每一段，我们分别用一位，两位，三位来尝试，分别判断其合不合法，如果合法，则调用递归继续分剩下的字符串，最终和求出所有合法组合，代码如下：

class Solution {
public:
    vector restoreIpAddresses(string s) {
            vector res;
            restore(s, 4, "", res);
            return res;
    }
    void restore(string s, int k, string out, vector &res) {
        if (k == 0) {//out中已经包括了四端
            if (s.empty()) //只用在s为空的时候，即输出out（IP地址）包括了s中所有字符时，才把out 加入输出向量中！
                res.push_back(out);
        }
        else {
            for (int i = 1; i <= 3; ++i) {
                if (s.size() >= i && isValid(s.substr(0, i))) {
                    if (k == 1) //第四段
                        restore(s.substr(i), k - 1, out + s.substr(0, i), res);
                    else 
                        restore(s.substr(i), k - 1, out + s.substr(0, i) + ".", res);
                }
            }
        }
    }
    bool isValid(string s) {//判断字符串s是否为有效字符串
        if (s.empty() || s.size() > 3 || (s.size() > 1 && s[0] == '0')) 
            return false;
        int res = atoi(s.c_str());
        return res <= 255 && res >= 0;
    }
};