561. Array Partition I/581. Shortest Unsorted Continuous Subarray

561. Array Partition I

description

Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), ..., (an, bn) which makes sum of min(ai, bi) for all i from 1 to n as large as possible.

Example 1:
Input: [1,4,3,2]

Output: 4
Explanation: n is 2, and the maximum sum of pairs is 4.
Note:
n is a positive integer, which is in the range of [1, 10000].
All the integers in the array will be in the range of [-10000, 10000].

From the description, we can know that the largest for sum of min pairs is the sum of the ascend sorted array with odd index number.

implementation

class Solution {
public:
    int arrayPairSum(vector<int>& nums) {
        int res = 0;
        int size = nums.size();

        sort(nums.begin(), nums.end());

        for(int idx  = 0; idx < size; idx+=2) {
            res += nums[idx];
        }

        return res;
    }
};

581. Shortest Unsorted Continuous Subarray

description

Given an integer array, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order, too.

You need to find the shortest such subarray and output its length.

Example 1:
Input: [2, 6, 4, 8, 10, 9, 15]
Output: 5
Explanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.
Note:
Then length of the input array is in range [1, 10,000].
The input array may contain duplicates, so ascending order here means <=.

Here I use a simple strategy that sorting the array first then compare it with previous array to get the difference.

implementation

class Solution {
public:
    int findUnsortedSubarray(vector<int>& nums) {
        int size = nums.size();

        if(size == 0) return 0;

        vector<int> aux_arr(size, 0);
        for(int idx = 0; idx < size; idx++)
            aux_arr[idx] = nums[idx];

        sort(aux_arr.begin(), aux_arr.end());

        int stt = 0, last = size - 1;
        while(stt <size && nums[stt] == aux_arr[stt]) {
            stt++;
        }

        if(stt < last)
            while(last >= 0 && nums[last] == aux_arr[last]) 
                last--;

        return last - stt + 1;
    }
};