从零开始的刷LeetCode生活 第31期 311-320

class Solution {
public:
    vector<vector<int>>f;
    vector<int>nums;
    int maxCoins(vector<int>& _nums) {
        int n = _nums.size();
        f = vector<vector<int>>(n + 2, vector(n + 2, -1));
        nums = vector<int>(n + 2);
        nums[0] = nums[n + 1] = 1;
        for(int i = 0; i < n; i ++) nums[i + 1] = _nums[i];
        return dp(0, n + 1);
    }

    int dp(int x, int y)
    {
        if(f[x][y] != -1) return f[x][y];
        f[x][y] = 0;
        for(int i = x + 1; i < y; i ++)
            f[x][y] = max(f[x][y], dp(x, i) + dp(i, y) + nums[x] * nums[i] * nums[y]);
        return f[x][y];
    }
};

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        vector<int>dp(n + 1, INT_MAX);
        dp[0] = 1;
        vector<int>index(primes.size(), 0);

        for(int i = 1; i <= n; i ++)
        {
            for(int j = 0; j < index.size(); j ++)
                dp[i] = min(dp[i], primes[j] * dp[index[j]]);

            for(int j = 0; j < index.size(); j ++)
                if(dp[i] == primes[j] * dp[index[j]])
                    index[j] ++;
        }
        return dp[n - 1];
    }
};

class Solution {
    struct Node{
        shared_ptr<Node>left;
        shared_ptr<Node>right;
        int val;
        int count = 0;
        Node(int val) : val(val){}
    };
public:
    vector<int> countSmaller(vector<int>& nums) {
        shared_ptr<Node>root;
        vector<int>res(nums.size());
        for(int i = nums.size() - 1; ~i; i --)
            root = insert(root, nums[i], &res, i);
        return res;
    }
    shared_ptr<Node>insert(shared_ptr<Node>root, int val, vector<int>*res, int index)
    {
        if(!root)
            return make_shared<Node>(val);
        auto &r = *res;
        if(val <= root->val)
        {
            root->count ++;
            root->left = insert(root->left, val, res, index);
        }
        else{
            r[index] += root->count + 1;
            root->right = insert(root->right, val, res, index);
        }
        return root;
    }
};

class Solution {
public:
    string removeDuplicateLetters(string s) {
        string res = "";
        int n = s.size();
        unordered_map<char, int>hash;
        vector<int> vis(26, false);
        for(int i = 0; i < n; i ++)
            hash[s[i]] = i;
        for(int i = 0; i < n; i ++)
        {
            if(vis[s[i] - 'a']) continue;
            while(res.size() > 0 && s[i] < res.back() && i < hash[res.back()])
            {
                vis[res.back() - 'a'] = false;
                res.pop_back();
            }
            res += s[i];
            vis[s[i] - 'a'] = true;
        }
        return res;
    }
};

class Solution {
public:
    int maxProduct(vector<string>& words) {
        int n = words.size(), res = 0;
        vector<int> val(n, 0);
        for(int i = 0; i < n; i ++)
            for(auto &c : words[i])
                val[i] |= 1 << (c - 'a');

        for(int i = 0; i < n; i ++)
            for(int j = i + 1; j < n; j ++)
            {
                int v = (val[i] & val[j]) ? 0 : words[i].size() * words[j].size();
                res = max(res, v);
            }
        return res;
    }
};

class Solution {
public:
    int bulbSwitch(int n) {
        return sqrt(n);
    }
};