class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int, int> map;
        vector<int> res;
        for(auto num1:nums1){
            map[num1]++;
        }

        for(auto num2:nums2){
            if (map[num2]>0) {
                map[num2]--;
                res.push_back(num2);
            }
        }
        return res;
    }
};

class Solution {
public:
    string frequencySort(string s) {
        unordered_map<char, int> map;
        for (int i =0; i<s.length(); i++) {
            map[s[i]]++;
        }

        sort(s.begin(), s.end(), [&map](char a ,char b){
            return map[a]>map[b] || (map[a] == map[b] && a > b);
        });
        
        return s;
    }
};

class Solution {
public:
    int firstUniqChar(string s) {
        unordered_map<char, int> map;
        for (int i =0; i<s.length(); i++) {
            map[s[i]]++;
        }
        for (int i =0; i<s.length(); i++) {
            if (map[s[i]]==1) {
                return i;
            }
        }
        return -1;
    }
};

class Solution {
public:
    int minMoves2(vector<int>& nums) {
        int n = nums.size();
        if(n <= 1) return 0;
        sort(nums.begin(), nums.end());
        int mid = nums.size()/2 ,res = 0;
        for(int i = 0; i < mid; ++i)
        {
            res+=nums[mid]-nums[i];
        }
        for (int j = n-1; j>mid; j--) {
            res+=nums[j]-nums[mid];
        }
        return res;
    }
};

class Solution {
public:
    int minMoves(vector<int>& nums) {
        int n = nums.size();
        if(n <= 1)
            return 0;
        int mn = nums[0];   //mn为最小数字
        int sum = nums[0];
        for(int i = 1; i < n; ++i)
        {
            mn = min(mn,nums[i]);
            sum += nums[i];
        }
        return sum - mn*n;
    }
};

class Solution {
public:
    int maxCount(int m, int n, vector<vector<int>>& ops) {
        for (auto tmp:ops) {
            m = min(m, tmp[0]);
            n = min(n, tmp[1]);
        }
        return m*n;
    }
};