《算法导论》第四章 分治策略

第四章 分治策略

4.1-1

返回最大的负数。

4.1-3

递归代码，在LeetCode验证通过。

class Solution {
public:
    int find_max_crossing_subarray(int l, int r, int mid, const std::vector<int> &data) {
        int sum = 0, lsum = std::numeric_limits<int>::min(), rsum = std::numeric_limits<int>::min();
        for (int i = mid; i >= l; --i) {
            sum += data[i];
            if (sum > lsum) {
                lsum = sum;
            }
        }
        sum = 0;
        for (int i = mid+1; i <= r; i++) {
            sum += data[i];
            if (sum > rsum) {
                rsum = sum;
            }
        }
        return lsum + rsum;
    }
    int find_maximum_subarray(int l, int r, const std::vector<int> &data) {
        if (l > r) {
            return 0;
        }
        if (l == r) {
            return data[l];
        }
        int mid = (l+r)>>1;
        int lsum = find_maximum_subarray(l, mid, data);
        int rsum = find_maximum_subarray(mid+1, r, data);
        int csum = find_max_crossing_subarray(l, r, mid, data);
        return max(max(lsum, rsum), csum);
    }
    int maxProfit(vector<int>& prices) {
        for (int i = prices.size()-1; i >= 1; i--) {
            prices[i] -= prices[i-1];
        }
        return max(0,find_maximum_subarray(1, prices.size()-1, prices));
    }
};

数据规模小于 $n_0$ 时，替换为暴力算法，性能交叉点会变化吗？

不会变化。递归算法原本慢于暴力的部分，变成了和暴力算法持平，但是并没有优于后者。

4.1-4

时间复杂度 $\mathrm{O}(n)$的代码，在LeetCode验证通过。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        for (int i = prices.size()-1; i >= 1; i--) {
            prices[i] -= prices[i-1];
        }
        int anw = 0;
        if (prices.size() >= 2) {
            anw = max(anw, prices[1]);
        }
        for (int i = 2; i < prices.size(); i++) {
            prices[i] = max(prices[i], prices[i-1] + prices[i]);
            anw = max(prices[i], anw);
        }
        return anw;
    }
};