从零开始的刷LeetCode生活 第36期 371-380

class Solution {
public:
    int getSum(int a, int b) {
        if(!b) return a;
        int sum = a ^ b, carry = uint(a & b) << 1;
        return getSum(sum, carry);
    }
};

class Solution {
public:
    int superPow(int a, vector<int>& b) {
        if(b.empty()) return 1;
        int last_digit = b.back();
        b.pop_back();
        return pow(superPow(a, b), 10) * pow(a, last_digit) % base;
    }
    const int base = 1337;
    int pow(int a, int b)
    {
        a %= base;
        int res = 1;
        for(int i = 0; i < b; i ++) res = (res * a) % base;
        return res;
    }
};

class Solution {
public:
    struct cmp{
        bool operator()(pair<int, int>&a, pair<int, int>&b)
            {return a.first + a.second < b.first + b.second;}
    };
    vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp>q;
        vector<vector<int>>res;
        for(int i = 0; i < nums1.size(); i ++)
            for(int j = 0; j < nums2.size(); j ++)
            {
                if(q.size() < k) q.push({nums1[i], nums2[j]});
                else if(nums1[i] + nums2[j] < q.top().first +q.top().second)
                {
                    q.pop();
                    q.push({nums1[i], nums2[j]});
                }
            }
        while(!q.empty())
        {
            pair<int, int> top = q.top();
            res.push_back({top.first, top.second});
            q.pop();
        }
        return res;
    }
};

// Forward declaration of guess API.
// @param num, your guess
// @return -1 if my number is lower, 1 if my number is higher, otherwise return 0
int guess(int num);

class Solution {
public:
    int guessNumber(int n) {
        int l = 1, r = n;
        while(l <= r)
        {
            int mid = l + (r - l) / 2;
            if(guess(mid) == 0) return mid;
            else if(guess(mid) < 0) r = mid - 1;
            else if(guess(mid) > 0) l = mid + 1;            
        }
        return -1;
    }
};

class Solution {
public:
    int getMoneyAmount(int n) {
        vector<vector<int>>dp(n + 1, vector<int>(n + 1, 0));
        for(int i = 1; i <= n; i ++) dp[i][i] = 0;
        for(int i = 1; i <= n; i ++)
        {
            for(int j = 1; j + i <= n; j ++)
            {
                dp[j][j + i] = INT_MAX;
                for(int k = j; k <= j + i; k ++)
                {
                    int temp = k;
                    if(k != j + i) temp = max(temp, k + dp[k + 1][j + i]);
                    if(k != j) temp = max(temp, k + dp[j][k - 1]);
                    dp[j][j + i] = min(temp, dp[j][j + i]);
                }
            }
        }
        return dp[1][n];
    }
};

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        //unique函数去除容器中相邻的重复元素（注意它是把重复元素放在容器末尾，返回值为去重之后的尾地址
        nums.erase(unique(nums.begin(), nums.end()), nums.end());
        if(nums.size() <= 2) return nums.size();
        int res = 2;
        for(int i = 1; i + 1 < nums.size(); i ++)
            if(nums[i - 1] < nums[i] && nums[i] > nums[i + 1]
            || nums[i - 1] > nums[i] && nums[i] < nums[i + 1])
            res ++;
        return res;
    }
};

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        int n = nums.size();
        vector<unsigned> f(target + 1, 0);
        f[0] = 1;
        for(int i = 1; i <= target; i ++)
            for(int j = 0; j < n; j ++)
                if(i >= nums[j])
                    f[i] = (f[i] + f[i - nums[j]]);
        return f[target];
    }
};

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        int n = matrix.size();
        priority_queue<int>q; //优先队列默认降序 大根堆
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < n; j ++)
            {
                if(q.size() < k) q.push(matrix[i][j]);
                else 
                {
                    if(matrix[i][j] < q.top())
                    {
                        q.pop();
                        q.push(matrix[i][j]);
                    }
                }
            }
        return q.top();
    }
};

class RandomizedSet {
public:
    /** Initialize your data structure here. */
    vector<int>arr;
    unordered_map<int, int> hash;
    int cnt = 0;
    RandomizedSet() {
        
    }
    
    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
    bool insert(int val) {
        if(hash.find(val) == hash.end())
        {
            hash[val] = cnt ++;
            arr.push_back(val);
            return true;
        }
        return false;
    }
    
    /** Removes a value from the set. Returns true if the set contained the specified element. */
    bool remove(int val) {
        auto it = hash.find(val);
        if(it != hash.end())
        {
            int idx = it->second;
            arr[idx] = arr.back();//返回arr末尾引用给arr[idx]
            hash[arr[idx]] = idx;
            arr.pop_back();
            cnt --;
            hash.erase(it);
            return true;
        }
        return false;
    }
    
    /** Get a random element from the set. */
    int getRandom() {
        return arr[rand() % cnt];
    }
};

/**
 * Your RandomizedSet object will be instantiated and called as such:
 * RandomizedSet* obj = new RandomizedSet();
 * bool param_1 = obj->insert(val);
 * bool param_2 = obj->remove(val);
 * int param_3 = obj->getRandom();
 */