从零开始的刷LeetCode生活 第43期 451-464

class Solution {
public:
    string frequencySort(string s) {
        unordered_map<char, int>map;
        for(auto &c : s)
            map[c] ++;
        vector<pair<char, int>>vec;
        for(auto &m : map)
            vec.push_back(m);
        sort(vec.begin(), vec.end(), [](const pair<char, int>&p1, const pair<char, int>&p2) 
        {
            return p1.second > p2.second;
        });
        string res;
        //for(auto &v : vec) cout << v.first << ' ' << v.second << endl;
        for(const auto v : vec)            
            res += string(v.second, v.first);
        return res;
    }
};

class Solution {
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.size() < 1) return 0;
        //按照右端点排序
        sort(points.begin(), points.end(), [](vector<int>a, vector<int>b){return a[1] < b[1];});
        int res = 1, r = points[0][1];
        //if(points.size() >= 1 && points[0][0] == INT_MIN) res ++;
        for(auto p : points)
        {
            if(p[0] > r)
            {
                r = p[1];
                res ++;
            }
        }
        return res;
    }
};

class Solution {
public:
    int minMoves(vector<int>& nums) {
        int res = 0;
        int minNun = INT_MAX;
        for(auto n : nums)
            minNun = min(minNun, n);
        for(auto c : nums)
            res += c - minNun;
        return res;
    }
};

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        unordered_map<int, int>hash;
        int res = 0;
        for(auto a : A)
            for(auto b : B)
                hash[a + b] ++;
        for(auto c : C)
            for(auto d : D)
                //if(hash.count(-c - d) > 0)
                res += hash[-c - d];
        return res;
    }
};

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int res = 0;
        int i = 0;
        for(int j = 0; j < s.size() && i < g.size(); j ++)
            if(s[j] >= g[i])
            {
                res ++;
                i++;
            }
        return res;
    }
};

class Solution {
public:
    bool find132pattern(vector<int>& nums) {
        int jNum = INT_MIN;
        stack<int> stk;
        for(int i = nums.size() - 1; ~i; i --)
        {
            if(nums[i] < jNum) return true;
            while(stk.size() && nums[i] > stk.top())
            {
                jNum = stk.top();
                stk.pop();
            }
            stk.push(nums[i]);// i < k < j 这里是k
        }
        return false;
    }
};

class Solution {
public:
    bool circularArrayLoop(vector<int>& nums) {
        int n = nums.size();
        for(int i = 0; i < n; i ++)
        {
            if(nums[i] == 0) continue;
            int dir = nums[i] > 0 ? 1 : -1;
            if(dfs(nums, i, n, dir))
                return true;
        }            
        return false;
    }
    const int INF = 1e8;
    bool dfs(vector<int>& nums, int i, int n, int dir)
    {
        if(nums[i] == 0) return false;
        if(nums[i] == INF) return true;
        int dir1 = nums[i] > 0 ? 1 : -1;
        if(dir == dir1)
        {
            int j = (n + (nums[i] + i) % n) % n;
            nums[i] = INF;
            if(j != i && dfs(nums, j, n, dir1))
                return true;
            else
            {
                nums[i] = 0;
                return false;
            }
        }
        return false;
    }
};

class Solution {
public:
    int poorPigs(int buckets, int minutesToDie, int minutesToTest) {
        int pigs = 0;
        int base = minutesToTest / minutesToDie + 1;
        while(pow(base, pigs) < buckets) pigs ++;
        return pigs;
    }
};

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        int len = s.size(), i = 0, t = 0;
        for(t = 1; t <= len / 2; t ++)
        {
            if(len % t) continue;
            for(i = t; i < len && s[i % t] == s[i]; i ++);
            if(i == len) return true;
        }
        return false;
    }
};

class Solution {
public:
    int hammingDistance(int x, int y) {
        int z = x ^ y;//两个字符 不同字符的个数
        int res = 0;
        while(z)
        {
            res += z & 1;
            z >>= 1;
        }
        return res;
    }
};

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

class Solution {
public:
    int islandPerimeter(vector<vector<int>>& grid) {
        if(grid.size() == 0) return 0;
        int res = 0;
        for(int i = 0; i < grid.size(); i ++)
            for(int j = 0; j < grid[0].size(); j ++)
                if(grid[i][j] == 1)
                {
                    res += 4;
                    if(i > 0 && grid[i - 1][j] == 1)
                        res -= 2;
                    if(j > 0 && grid[i][j - 1] == 1)
                        res -= 2;
                }
        return res;
    }
};

class Solution {
public:
    map<pair<int, int>, bool>s;
    bool canIWin(int max, int des) {
        if(des <= 0) return true;
        if(max * (max + 1) / 2 < des) return false;
        return dfs(0, max, des);
    }

    bool dfs(int state, int max, int des)
    {
        if(des <= 0) return false;
        if(s.count({state, des})) return s[{state, des}];
        for(int i = 0; i < max; i ++)
            if(! (state >> i & 1)) //当前位不是1 还没选
            {
                if(!dfs(state | (1 << i), max, des - i - 1))
                    return s[{state, des}] = true;
            }
        return false;
    }
};