[Leetcode] 360. Sort Transformed Array 解题报告

题目：

Given a sorted array of integers nums and integer values a, b and c. Apply a function of the form f(x) = ax2 + bx + c to each element x in the array.

The returned array must be in sorted order.

Expected time complexity: O(n)

Example:

nums = [-4, -2, 2, 4], a = 1, b = 3, c = 5,

Result: [3, 9, 15, 33]

nums = [-4, -2, 2, 4], a = -1, b = 3, c = 5

Result: [-23, -5, 1, 7]

思路：

这道题目的本质其实是对一个有序数组重新进行排序。由于是一个二次变换，所以分如下情况分别考虑：

1）a == 0：此时函数退化为线性函数，不用排序，直接变换并且返回（如果b < 0的时候需要对结果进行逆转）。

2）a != 0：此时首先计算出二次函数的对称轴(-b / (2 * a))，然后根据距离这个对称轴的远近对nums中的元素进行排序，再进行变换（当然在a < 0的情况下，还需要对变换结果进行逆转）。由于原来的数组已经是有序的了，所以这里的重新排序可以在O(n)的时间内完成。

代码：

class Solution {
public:
    vector<int> sortTransformedArray(vector<int>& nums, int a, int b, int c) {
        vector<int> ret;
        double DOUBLE_MAX = numeric_limits<double>::max();
        if(nums.size() == 0) {
            return ret;
        }
        if(a == 0) {        // transform directly
            for(int i = 0; i < nums.size(); ++i) {
                ret.push_back(b * nums[i] + c);
            }
            if(b < 0) {
                reverse(ret.begin(), ret.end());
            }
        }
        else {
            double axis = ((double)(-b)) / (2 * a);     // re sort accoring to the axis (-b / (2 * a))
            int upper = distance(nums.begin(), lower_bound(nums.begin(), nums.end(), axis));
            int lower = upper - 1;
            while(upper < nums.size() || lower >= 0) {
                double upper_differ = (upper == nums.size()) ? DOUBLE_MAX : abs(nums[upper] - axis);
                double lower_differ = (lower == -1) ? DOUBLE_MAX : abs(axis - nums[lower]);
                if(upper_differ < lower_differ) {
                    ret.push_back(nums[upper++]);
                }
                else {
                    ret.push_back(nums[lower--]);
                }
            }
            for(int i = 0; i < ret.size(); ++i) {       // transform after resorting
                ret[i] = a * ret[i] * ret[i] + b * ret[i] + c;
            }
            if(a < 0) {
                reverse(ret.begin(), ret.end());
            }
        }
        return ret;
    }
};