从零开始的刷LeetCode生活 第32期 321-330

class Solution {
public:
    vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
        int n = nums1.size(), m = nums2.size();
        vector<int>res(k, INT_MIN);
        for(int i = max(0, k - m); i <= k && i <= n; i ++)
        {
            vector<int> N = maxArray(nums1, i);//vector<int>可排序
            vector<int> M = maxArray(nums2, k - i);
            vector<int> temp = merge(N, M);
            if(res < temp) res = temp;
        }
        return res;
    }
    vector<int>maxArray(vector<int>&nums, int k)
    {
        int n = nums.size();
        vector<int> res(k);
        for(int i = 0, j = 0; i < n; i ++)
        {
            while(n - i + j > k && j && res[j - 1] < nums[i]) j --;//res最后一个比后面的小
            if(j < k) res[j ++] = nums[i];
        }
        return res;
    }
    vector<int>merge(vector<int>&N, vector<int>&M)
    {
        vector<int>res;
        while(N.size() && M.size())
        {
            if(N > M)
                res.push_back(N[0]), N.erase(N.begin());
            else 
                res.push_back(M[0]), M.erase(M.begin());
        }
        while(N.size()) res.push_back(N[0]), N.erase(N.begin());
        while(M.size()) res.push_back(M[0]), M.erase(M.begin());
        return res;
    }
};

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int>f(amount + 1, INT_MAX / 2);
        f[0] = 0;
        for(auto c : coins)
            for(int i = c; i <= amount; i++)
                f[i] = min(f[i], f[i - c] + 1);
        if(f[amount] == INT_MAX / 2) return -1;
        return f[amount];
    }
};

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        int n = nums.size();
        auto midptr = nums.begin() + n / 2;
        nth_element(nums.begin(), midptr, nums.end());
        int mid = * midptr;
        //for(auto c : nums) cout << c << ' ';
        // nth_element 后 ----=====++++ 转为 ++++++=====------
        #define A(i) nums[(1 + 2 * i) % (n | 1)]
        int i = 0, j = 0, k = n - 1;
        while(j <= k)
            if(A(j) > mid)
                swap(A(i ++), A(j ++));
            else if(A(j) < mid)
                swap(A(j), A(k --));
            else 
                j ++;
        //for(auto c : nums) cout << c << '-';
    }
};

class Solution {
public:
    bool isPowerOfThree(int n) {
        int num = pow(3, 19);
        return n > 0 && num % n == 0;
    }
};

class Solution {
public:
    int countRangeSum(vector<int>& nums, int lower, int upper) {
        int n = nums.size();
        vector<long long> preSum(n + 1, 0);
        for(int i = 0; i < n; i ++)
            preSum[i + 1] = preSum[i] + nums[i];
        return merge_sort(preSum, 0, n, lower, upper);
    }
    int merge_sort(vector<long long>&preSum, int lo, int hi, int lower, int upper)
    {
        if(hi <= lo) return 0;
        int mid = (hi + lo) >> 1, r1 = mid + 1, r2 = mid + 1;
        int res = merge_sort(preSum, lo, mid, lower, upper) + merge_sort(preSum, mid + 1, hi, lower, upper);
        for(int i = lo; i <= mid; i ++)
        {
            while(r1 <= hi && preSum[r1] - preSum[i] < lower) r1 ++;
            while(r2 <= hi && preSum[r2] - preSum[i] <= upper) r2++;
            res += (r2 - r1);
        }
        inplace_merge(preSum.begin() + lo, preSum.begin() + (mid + 1), preSum.begin() + (hi + 1));
        return res;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode *o = head;
        ListNode *e = head->next;
        ListNode *p = e;
        while(o->next && e->next)
        {
            o->next = e->next;
            o = o->next;
            e->next = o->next;
            e = e->next;
        }
        o->next = p;
        return head;
    }
};

class Solution {
public:
    int n, m;
    vector<vector<int>> f;//状态数组
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.empty()) return 0;
        n = matrix.size(), m = matrix[0].size();
        f = vector<vector<int>>(n, vector<int>(m, -1));
        int res = 0;
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < m; j ++)
                res = max(res, dp(i, j, matrix));
        return res;
    }
    int dp(int x, int y, vector<vector<int>>&matrix)
    {
        if(f[x][y] != -1) return f[x][y];
        f[x][y] = 1;
        for(int i = 0; i < 4; i ++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(a >= 0 && a < n && b >= 0 && b < m && matrix[a][b] > matrix[x][y])
                f[x][y] = max(f[x][y], dp(a, b, matrix) + 1);
        }
        return f[x][y];
    }
};

class Solution {
public:
    int minPatches(vector<int>& nums, int n) {
        int res = 0, idx = 0, m = nums.size();
        long long miss = 1;
        while(miss <= n)
        {
            if(idx < m && miss >= nums[idx])
                miss += nums[idx ++];
            else
            {
                miss = miss + miss;
                res ++;
            }
        }
        return res;
    }
};