Solution to CLRS Chapter 4

这一章主要介绍了几个divide-and-conquer的例子，并且引入了对递归算法的复杂度进行刻画的数学工具，这章工具数学性很强，所以数学部分打算以后遇到了再回头来看，不过那个master theorem真的好方便啊！

4.1-1
用divide-and-conquer处理最大连续子序列和，在conquer的时候，涉及3个sum之间的比较：
left-sum,right-sum,cross-sum,其中cross-sum必须要包含a[mid],a[mid+1]两个点，由于整个序列都是负数，所以cross-sum是最小的（加的越多越下），先排除，这样，剩下left-sum和right-sum本质上是就是找左右区间中最大的那个元素，所以，最后的结果一定返回的是[1…n]中，最大的负数

4.1-2
brute-force算法，就是要枚举每一种买股票的可能，这可以通过枚举买进时间i,卖出时间j来实现,这样的复杂度，已经达到theta(n^2)了，所以，在确定了区间[i,j]的时候，需要一个常数级算法，求出区间[i,j]的和，这个可以用一个预处理，得到一个sum[]数组，sum[i]表示前i项的和，那么区间[i,j]的和就可以表示成sum[j]-sum[i-1]
pseudocode：

BRUTE-FORCE-MAXIMUN-SUBARRAY        sum[0] = 0;        for i = 1 : N                sum[i] = sum[i-1] + a[i]        maxSum = -INF        for i = 1 : N                for j = i : N                        if sum[j] - sum[i-1] > maxSum                                maxSum = sum[j] - sum[i-1]                                startPoint = i;                                endPoint = j;        return (maxSum, startPoint, endPoint)

4.1-3
这题是判断brute－force算法和用divide-and-conquer paradigm的性能的分界点，然后用这个来优化recursive版本算法的性能，换角度说也就是coarsen the leaves，这个思想在之前的merge sort 也用到了。
下面用C++实现一下这个比较:(比较方法是测试规模为10000的数据）
我电脑测试的时候，从n=1开始，就是divide-and-conquer更加优秀………………
C++ code:

#include <iostream>#include <cstdlib>#include <ctime>#include <cstring>#include <cstdio>using namespace std;const int INF = 0x7fffffff;const int MAX_N = 1000000 + 3;int A[MAX_N];int CrossSum (int *A, int l, int mid, int r) {        int left_max = -INF, left_sum = 0;        int right_max = -INF, right_sum = 0;        for (int i = mid; i >= l; --i) {                left_sum += A[i];                left_max = max(left_max, left_sum);        }        for (int i = mid+1; i <= r; ++i) {                right_sum += A[i];                right_max = max(right_max, right_sum);        }        return left_max + right_max;}int RecursiveMaxSub (int *A, int l, int r) {        if (l == r)                 return A[l];        int mid = (l + r) / 2;        int left_sum = RecursiveMaxSub(A, l, mid);        int right_sum = RecursiveMaxSub(A, mid+1, r);        int cross_sum = CrossSum(A, l, mid, r);        int maxSum = left_sum;        if (right_sum > maxSum)                maxSum = right_sum;        if (cross_sum > maxSum)                maxSum = cross_sum;        return maxSum;}int sum[MAX_N];int BruteForceMaxSub (int *A, int N) {        int i, j, maxSum = -INF;        sum[0] = 0;        for (i = 1; i <= N; ++i)                sum[i] = sum[i-1] + A[i];        for (i = 1; i <= N; ++i)                for (j = i; j <= N; ++j)                        if (sum[j] - sum[i-1] > maxSum)                                maxSum = sum[j] - sum[i-1];        return maxSum;}void getNewArray(int* A, int n) {        for (int i = 1; i <= n; ++i)                A[i] = rand() % 1000 - 500;}int main (int argc, char* argv[]) {        int n = 9;               srand(time(NULL));        getNewArray(A, n); //randomly get a new array        int time1 = clock();        int result1 = BruteForceMaxSub(A, n);        time1 = clock() - time1;        int time2 = clock();        int result2 = RecursiveMaxSub(A, 1, n);        time2 = clock() - time2;        if (result1 != result2)                cout << "Algorithm Error!" << endl;        //cout << "brute-force: " << time1 / CLOCKS_PER_SEC << " s   divide-and-conquer: " << time2 / CLOCKS_PER_SEC << " s" << endl;        cout << "brute-force: " << time1 << " clocks   divide-and-conquer: " << time2 << " clocks" << endl;        return 0;}

4.1-4
这个挺简单的，不允许empty array只会出现在所有的元素都是负数的情况下，由4.1-1知这种情况下，返回的一定是元素中最大的负数，所以，只要加一个判断－如果MaxSub返回的结果是负数，那么显然这个结果不如选取一个空串得到0，所以将所以返回负数的情况，特判改成0就可以了。

4.1-5
这道题就是动态规划的思想吧，hdu1003 Max Sum 就是这个题目，还有一个升级版是hdu1024
这里给出升级版：

#include <cstdio>#include <cstring>#include <algorithm>using std::max;const int MAX_N = 1000000 + 6;const int INF = 0x7fffffff;int dp[MAX_N];int a[MAX_N];int rmax[MAX_N];int main (int argc, char* argv[]) {#ifndef ONLINE_JUDGE    freopen("in.txt", "r", stdin);#endif    int n, m;    while (scanf("%d%d", &m, &n) != EOF) {        for (int i = 1; i <= n; ++i)            scanf("%d", a + i);        memset(dp, 0, sizeof(dp));        memset(rmax, 0, sizeof(rmax));        int ans = -INF;        int i, j;        for (i = 1; i <= m; ++i) {            ans = -INF;            for (j = i; j <= n; ++j) {                dp[j] = max(dp[j-1], rmax[j-1]) + a[j];                rmax[j-1] = ans;                ans = max(ans, dp[j]);            }        }        printf("%d\n", ans);    }    return 0;}

这一章有点奇怪，但感觉并不是无用，回头再看
4.2-1
4.2-2
4.2-3
4.2-4
4.2-5
4.2-6
4.2-7

以后遇到相关的计算再来看，现在对这个没什么概念