标签：star 6.2 暴力求解 索引 ... 时空 买卖 排序 连续
将问题分解为几个规模较小但类似于原问题的子问题，递归求解这些子问题，然后合并这些子问题的解来建立原问题的解
分治模式在每层递归时，都有三个步骤：
1. 分解原问题为若干子问题，这些子问题是原问题的规模较小的实例。
2. 解决这些子问题，递归地求解各个子问题。如果子问题规模足够小，直接求解
3. 合并子问题的解为原问题的解
以归并排序为例，归并排序的操作如下：
分解：分解待排序的n个元素的序列为具有n/2个元素的两个子序列
解决：使用归并排序递归地排序两个子序列
合并：合并两个已排序的子序列以产生已排序的答案
当待排序的序列长度为1时，递归开始回升，在这种情况下不要做任何工作，因为长度为1的序列已排序好了
void mergeArr(int* arr, int startIdx, int mid, int endIdx) { int n1 = mid - startIdx; int n2 = endIdx - mid; // 用两个临时数组，保存要合并数组的值 int* a1 = new int[n1]; int* a2 = new int[n2]; for (int i = 0; i < n1; i++) { a1[i] = arr[startIdx+i]; } for (int i = 0; i < n2; i++) { a2[i] = arr[mid+i]; } // 按照从小到大的顺序，合并两个数组的值 int len = n1 + n2; int i = 0, j = 0; for (int k = startIdx; k < endIdx; k++) { if (j == n2) { arr[k] = a1[i++]; } else if (i == n1 || a1[i] > a2[j]) { arr[k] = a2[j++]; } else { arr[k] = a1[i++]; } } delete[] a1; delete[] a2; } // arr表示待排序的数组，startIdx,endIdx分别表示数组中元素的索引，前闭后开区间 void merge_sort(int* arr, int startIdx, int endIdx) { if (endIdx - startIdx == 1) { return; } // 分解 int mid = (startIdx+endIdx) >> 1; merge_sort(arr, startIdx, mid); merge_sort(arr, mid, endIdx); // 合并 mergeArr(arr, startIdx, mid, endIdx); }
以茅台股票的股价走势日线图为例，如下图。假如我们能够穿越时空，回到过去，给你足够买一手茅台的钱，只买卖一次，你怎样可以实现最大化收益。
茅台一个月的收盘价：[644.79, 671.49, 667.7, 670.21, 660.3, 687.3, 681.0, 685.85, 680.4, 659.19, 666.21, 675.04, 657.79, 644.0, 650.97, 644.8, 646.0, 630.0, 631.98, 642.9, 645.81, 666.7, 681.42]
一种方法是暴力求解：尝试每对可能的买进和卖出组合，只要卖出日期在买入日期之后即可。n天时间的组合有 n+n-1+n-2+...+1 = O(n^2) 种。
下面使用分治法来求解。
首先变化一下思路，我们将股价每天的变化值列出来，得到一个新的数组：
[26.7, -3.79, 2.51, -9.91, 27.0, -6.3, 4.85, -5.45, -21.21, 7.02, 8.83, -17.25, -13.79, 6.97, -6.17, 1.2, -16.0, 1.98, 10.92, 2.91, 20.89, 14.72]
这样我们原来的问题就转化成：寻找A中最大的非空连续子数组。
分治法三步骤：分解，解决，合并
先把数组分解，假定我们寻找子数组A[low...high]的最大子数组。我们可以找到子数组中央位置mid，然后求解两个子数组A[low...mid]和A[mid+1...high]
A[low...high]的任何连续子数组A[i...j]所处位置有三种情况：
1. 完全位于A[low...mid]中, low <= i <= j <= mid
2. 完全位于A[mid+1...high]中, mid < i <= j <= high
3. 跨越了中点，low <= i <= mid < j <= high
1和2两种情况是原问题的子问题，第3中情况，可以由两个子数组 A[i...mid] 和 A[mid+1...j] 组成。我们只需要找出形如 A[i...mid] 和 A[mid+1...j] 的最大子数组，然后合并就可以了。
#include <stdio.h> #include <stdlib.h> #include <string.h> double cross_subarray(double* arr, int low, int mid, int high, int& left, int& right) { // 左边的最大子数组，arr[mid]肯定被选中 double leftsum = arr[mid] - 1; double sum = 0; for (int i = mid; i >= low; i--) { sum += arr[i]; if (sum > leftsum) { leftsum = sum; left = i; } } // 右边的最大子数组，arr[mid]肯定被选中 double rightsum = arr[mid] - 1; sum = 0; for (int i = mid; i <= high; i++) { sum += arr[i]; if (sum > rightsum) { rightsum = sum; right = i; } } // arr[mid]被计算了两次，减去一次 return leftsum + rightsum - arr[mid]; } double max_sub_array(double* arr, int low, int high, int& left, int& right) { if (low == high) { left = right = low; return arr[low]; } else { int mid = (low + high) >> 1; int left_low, left_high, right_low, right_high, cross_low, cross_high; double left_sum = max_sub_array(arr, low, mid, left_low, left_high); double right_sum = max_sub_array(arr, mid+1, high, right_low, right_high); double cross_sum = cross_subarray(arr, low, mid, high, cross_low, cross_high); if (left_sum >= right_sum && left_sum >= cross_sum) { left = left_low; right = left_high; return left_sum; } else if (right_sum >= left_sum && right_sum >= cross_sum) { left = right_low; right = right_high; return right_sum; } else { left = cross_low; right = cross_high; return cross_sum; } } } int main() { double arr[] = {26.7, -3.79, 2.51, -9.91, 27.0, -6.3, 4.85, -5.45, -21.21, 7.02, 8.83, -17.25, -13.79, 6.97, -6.17, 1.2, -16.0, 1.98, 10.92, 2.91, 20.89, 14.72}; int len = sizeof(arr) / sizeof(double); int left, right; double sum = max_sub_array(arr, 0, len-1, left, right); printf("%d, %d, %lf\n", left, right, sum); for (int i = left; i <= right; ++i) { printf("%lf ", arr[i]); } printf("\n"); return 0; }
打印结果：
17, 21, 51.420000
1.980000 10.920000 2.910000 20.890000 14.720000
如果能往前回几天，可以在9.13号买，今天卖的话，一股赚51.42,一手赚5142
如果能往前回几年，那就无脑买吧，因为茅台的股价走势是这样的：
哈哈，我真能幻想
标签：star 6.2 暴力求解 索引 ... 时空 买卖 排序 连续
原文地址：https://www.cnblogs.com/zuofaqi/p/9678356.html
