算法分析——分治

算法分析——分治

1、分治算法

1.1 基本概念

在计算机科学中，分治法是构建基于多项分支递归的一种很重要的算法范式。字面上的解释是「分而治之」，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法（快速排序、归并排序）、傅立叶变换（快速傅立叶变换）。

1.2 分治法适用情况

（1）该问题的规模缩小到一定的程度就可以容易地解决；

（2）该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质；

（3）利用该问题分解出的子问题的解可以合并为该问题的解；

（4）该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题；

其中第三条是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划。

第四条涉及到分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好（可以参考下面第三个题目）。

1.3 分治法一般步骤

• Step1 : 将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；
• Step2 : 若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题;
• Step3 : 将各个子问题的解合并为原问题的解;

2、Leetcode题目

2.1 Leetcode169 : 多数元素

题目描述：给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例1：

输入: [3,2,3]
输出: 3

示例2：

输入: [2,2,1,1,1,2,2]
输出: 2

题目分析：这道题还是比较简单的，有很多种解法。比如，方法一：由于众数出现的频率大于n/2,所以在排序之后众数必存在于下标[n/2]处。因此可以将原数组排序，然后输出位于n/2位置的数，该数即为众数。方法二：哈希表，通过使用哈希映射得到每个值出现的次数。但是我们需要用分治的方法去求解这个问题。

我们直到如果数 a 是数组 nums 的众数，如果我们将 nums 分成两部分，那么 a 必定是至少一部分的众数。这样以来，我们就可以使用分治法解决这个问题：将数组分成左右两部分，分别求出左半部分的众数 a1 以及右半部分的众数 a2，随后在 a1 和 a2 中选出正确的众数。

代码：

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        return majorityElementRec(nums, 0, nums.size() - 1);
    }

    int count(vector<int>& nums, int target, int low, int height) {
        int c = 0;
        for (int i = low; i <= height; ++i)
            if (nums[i] == target)
                c++;
        return c;
    }

    int majorityElementRec(vector<int>& nums, int low, int height) {
        if (low == height)
            return nums[low];
        int mid = low + (height - low) / 2;

        int left = majorityElementRec(nums, low, mid);
        int right = majorityElementRec(nums, mid + 1, height);
        
        //计算区间内的众数，返回
        if (count(nums, left, low, height) > (height - low + 1) / 2)
            return left;
        if (count(nums, right, low, height) > (height - low + 1) / 2)
            return right;
        return -1;
    }
};

2.2 Leetcode53 : 最大子序和

题目描述：给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例：

输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

题目分析：

代码：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
    	return maxSub(nums, 0, nums.size()-1);
    }

    int maxSub(std::vector<int>& Array, int low, int height){
    	if(height == low){
    		//只有一个元素是，返回值
    		return Array[low];
    	}

		int mid = low + (height - low) / 2;
		int left = maxSub(Array, low, mid);
		int right = maxSub(Array, mid+1, height);

		//左边子数组，从右往左计算
		int leftMaxValue = Array[mid];
		int temp = 0;

		for(int i = mid; i >= low; i--){
			temp += Array[i];
			leftMaxValue = max(temp, leftMaxValue);
		}

		//右边子数组，从左往右计算
		int rightMaxValue = Array[mid+1];
		temp = 0;

		for(int j = mid+1; j <= height; j++){
			temp += Array[j];
			rightMaxValue = max(temp, rightMaxValue);
		}
        int value = max(left, right);
		return max(value, rightMaxValue+leftMaxValue);
    }
};

2.3 Leetcode50 : pow(x, n)

题目描述：实现 pow(x, n) ，即计算 x 的 n 次幂函数。

示例1：

输入: 2.00000, 10
输出: 1024.00000

示例2：

输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25

题目分析：

代码：

class Solution {
public:
    double myPow(double x, int n) {
    	if(n == 0){
    		return 1;
    	}else if(n > 0){
            return multiplyDivide(x, 0, n-1);
    	}else{
         	//int型最大值为2147483647。此处不能再用abs(n)
            if(n == -2147483648)
                return multiplyDivide(1/x, 0, 2147483647);
            return multiplyDivide(1/x, 0, abs(n)-1);
    	}
    }

    double multiplyDivide(double value, int low, int height){
    	if(height == low){
    		return value;
    	}

    	int mid = low + (height - low) / 2;
    	double left = multiplyDivide(value, low, mid);

        //注意，因此左右两边的值都是相同的，在归并的时候差别仅在于当n为奇数的时候，左右两边需要归并的value个数相差为1。
        //因此直接将左边归并的值给右边即可，不需要再重复计算。
    	double right;
    	if(height % 2 == 0){
    		right = left / value;
    	}else{
    		right = left;
    	}

    	//double right = multiplyDivide(value, mid+1, height);

    	return left * right;
    }
};