分治策略(1)——算法导论(3)
1. 从一个股价的问题说起
假如你获得了一种可以预测未来某公司股价的能力。下图是你预测的股价情况，那么你会在哪一天买入，哪一天卖出呢？
你可能认为可以在这17天当中的股价最低的那天（第7天）买入，然后在之后的股价最高的那天（第11天）卖出；或者反过来在整段时间内股价最高的那天卖出，然后在之前的股价最低的那天买入。如果这种策略是可行的，那么确定最大收益将非常简单。但这种策略不是经常奏效的。比如下图的这种情况：
很容易看出在第2天买入，第3天卖出，将获得最大的收益。但第二天并非最低（事实上股价最低是第4天），第3天也并非股价最高（股价最高是第1天）。
2. 暴力方法(穷举法 Exhaustive method)求解
我们最容易想到的方法应该是暴力求解方法（事实上在条件允许的时候，暴力破解方法不失为是一种好方法）。分析该方法可发现，n天中我们需要尝试的组合将有
种，而处理每对日期的时间至少是常量时间，因此，这种方法的运行时间是θ(n²)。下面给出这种算法的Java实现代码：
public static void main(String[] args) {
int[] priceArray = new int[] { //
100, 113, 110, 85, //
105, 102, 86, 63, //
81, 101, 94, 106, //
101, 79, 94, 90, //
97 };
int maxDifference = Integer.MIN_VALUE;
int startDay = -1;
int endDay = -1;
for (int i = 0; i < priceArray.length; i++) {
int startPrice = priceArray[i];
for (int j = i + 1; j < priceArray.length; j++) {
int endPrice = priceArray[j];
int difference = endPrice - startPrice;
if (difference > maxDifference) {
maxDifference = difference;
startDay = i;
endDay = j;
}
}
}
System.out.println("第" + startDay + "天买入,第" + endDay + "天卖出可获得最大差价：" + maxDifference);
}
运行结果：第7天买入,第11天卖出可获得最大差价：43
3. 最大子数组问题
穷举法(Exhaustive method)虽简单，但往往不是最优方法。那有没有更好的方法呢？
我们从一个稍微不同的角度来看待输入的数据。我们的目的是寻找一段时间，使得第一天到最后一天的股价净变化最大。因此我们不再从每日价格的角度去看待输入的数据，而是考察每日价格的变化。如果把每日价格的变化集合到数组array，如下图，那么该问题就变成了：在array中找出一个子数组（即最大子数组），使得子数组的所有元素之和最大。
乍一看，这种问题的转化并没有给我们带来什么好处。如果采用暴力破解方法对于一段n天的时间，我们仍然要检查
次，运算时间仍为θ(n²)。
接下来，我们寻找求最大子数组的更高效方法。需要提前说明的是，最大子数组有些时候可能有多个；只有当数组内包含负元素时，讨论最大子数组问题才有意义，因为对于非负数组，整个数组必然是最大子数组。
4. 采用分治法(Divide and Conquer)求解最大子数组
在第一篇中我们已经接触过分治策略，它需要考虑以下三步：
① 分解：分解意味着我们要将数组分为两个规模尽量相等的子数组。也就是说，如果数组a[low~high]为将要求解的数组，我们要将a[low~high]分为a1[low~mid]，a2[mid~high]，其中mid = (high – low) / 2。
② 解决：解决意味着我们要递归的解决子数组的求解。这里需要注意的是，最大子数组所处的位置可能有以下三种情况：在a1中；在a2中；跨越中点。
③ 合并：通过比较以上三种情况求出的最大子数组，得出真正的最大子数组。
下面给出分治法(Divide and Conquer)的Java实现代码：
/**
* 分治法
*
* @param args
*/
public static void main(String[] args) {
int[] differenceArray = new int[] { //
13, -3, -25, -20, //
-3, -16, -23, 18, //
20, -7, 12, -5, //
-22, 15, -4, 7, //
};
Result result = findMaxSubarray(differenceArray, 0, differenceArray.length - 1);
System.out.println("第" + result.startDay + "天买入,第" + result.endDay + "天卖出可获得最大差价：" + result.maxDifference);
}
/**
* 找出最大子数组
*
* @param array
* @return
*/
private static Result findMaxSubarray(int array[], int low, int high) {
if (low == high) {
Result result = new Result();
result.startDay = low;
result.endDay = low;
result.maxDifference = array[low];
return result;
} else {
Result leftResult = findMaxSubarray(array, low, (high + low) / 2);
Result rightResult = findMaxSubarray(array, (high + low) / 2 + 1, high);
Result crossingMiddleResult = findMaxSubarrayCrossingMiddle(array, low, high);
int maxDifference = Math.max(Math.max(leftResult.maxDifference, rightResult.maxDifference),
crossingMiddleResult.maxDifference);
if (maxDifference == leftResult.maxDifference) {
return leftResult;
} else if (maxDifference == rightResult.maxDifference) {
return rightResult;
} else {
return crossingMiddleResult;
}
}
}
/**
* 找出跨越中点的最大子数组
*
*/
private static Result findMaxSubarrayCrossingMiddle(int[] array, int low, int high) {
Result result = new Result();
int maxLeftSum = Integer.MIN_VALUE;
int maxRightSum = Integer.MIN_VALUE;
int sum = 0;
int mid = (high + low) / 2;
for (int i = mid; i >= 0; i--) {
sum += array[i];
if (sum > maxLeftSum) {
maxLeftSum = sum;
result.startDay = i;
}
}
sum = 0;
for (int i = mid; i < array.length; i++) {
sum += array[i];
if (sum > maxRightSum) {
maxRightSum = sum;
result.endDay = i;
}
}
result.maxDifference = maxLeftSum + maxRightSum;
return result;
}
static class Result {
public int startDay;
public int endDay;
public int maxDifference;
}
结果为：第7天买入,第11天卖出，可获得最大差价：43
下面我们建立一个递归式来描述递归过程的运算时间。
① 对于low = high的基本情况(base case)，花费常量时间θ(1)。
② 对于low ≠ hight的递归情况(recursive case)，两次递归花费2T(n / 2)时间，findMaxSubarrayCrossingMiddle方法花费时间θ(n)，其余花费常量时间θ(1)，因此一共花费2T(n / 2) + θ(1)。即：
解得T(n) = θ(nlgn)。在n较大时，该方法将打败穷举法(Exhaustive method)。
5. 另一种时间为线性的方法
我们考虑这么一种方法：从数组的最左边开始向右扩展，记录扩展过程中的最大子数组。若已知array[0~j]的最大子数组，基于如下方法将解扩展为array[0~j+1]的最大子数组：array[0~j+1]的最大子数组要么是array[0~j]的最大子数组，要么是array[i~j+1]（0≤i≤j+1）。在已知array[0~j]的最大子数组的情况下，可以在线性时间内找出形如array[i~j+1]的最大子数组。
ps：以上内容均摘自《算法导论》中文译本。本人只是提取出文中个人认为比较重要的点 加入了一些个人理解仅供参考。