LeetCode日记20200214

LeetCode日记2020.2.14

316 去除重复字母(hard)

class Solution {
public:
    string removeDuplicateLetters(string s) {
        string res;
        for(int i=0;i<s.size();++i)
        {
            auto pos= res.find(s[i]);
            if(pos==string::npos)
            {
                while(!res.empty()&&res.back()>=s[i]&&s.find(res.back(), i)!=string::npos)
                    res.pop_back();

                res.append(1, s[i]);
            }
        }
        return res;
    }
};

120 三角形最小路径和(mid)

基本动态规划

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        vector<int> dp(triangle.back());
        for(int i = triangle.size() - 2; i>=0; --i)
        {
            for(int j = 0;j<triangle[i].size(); ++j)
            {
                dp[j] = triangle[i][j] + min(dp[j], dp[j+1]);
            }
        }
        return dp[0];
    }
};

16 最接近三数之和(mid)

双指针还能这么用！

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        int optSum = nums[0] + nums[1] + nums[2];
        for(int i=0; i<nums.size()-2; ++i)
        {
            int beg = i + 1, End = nums.size()-1;
            while(beg < End)
            {
                int sum = nums[beg] + nums[End] + nums[i];
                if(sum == target)
                    return target;
                else
                {
                    if(abs(optSum - target)>abs(sum-target))
                        optSum = sum;

                    sum>target?--End:++beg;
                }
            }
        }
        return optSum;
    }
};

39 组合总和(mid)

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        return combinaSum(candidates.cbegin(), candidates.cend(), target);
    }

    vector<vector<int>> combinaSum(vector<int>::const_iterator beg, 
        vector<int>::const_iterator End, int target)
    {
        vector<vector<int>> res;
        if(beg == End || target <= 0)
            return res;

        while(beg != End)
        {
            int fir = *beg;
            if(fir == target)
                res.emplace_back(1, fir);

            auto combi = combinaSum(beg, End, target-(*beg));
            for(auto& c: combi)
            {
                res.push_back(std::move(c));
                res.back().push_back(fir);
            }
            ++beg;
        }
        return res;
    }
};

1079 活字印刷(mid)

class Solution {
public:
    int numTilePossibilities(string tiles) {
        map<char, int> cM;
        vector<int> ps;
        for(auto c: tiles)
        {
            auto iter = cM.find(c);
            if(iter == cM.end())
            {
                cM[c] = ps.size();
                ps.push_back(1);
            }
            else
                ++ps[iter->second];
        }

        deque<vector<int>> deq;
        deq.push_back(ps);
        int n = ps.size();
        int cnt = 0;
        while(!deq.empty())
        {
            auto t = deq.front();
            deq.pop_front();
            for(int i=0;i<n;++i)
            {
                if(t[i] != 0)
                {
                    auto cpyT = t;
                    --cpyT[i];
                    deq.push_back(cpyT);
                    ++cnt;
                }
            }
        }
        return cnt;
    }
};

77 组合(mid)

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        if(n == 0 || n < k)
            return vector<vector<int>>();

        vector<vector<int>> res;
        if(k == 1)
        {
            for(int i = 1;i<=n;++i)
            {
                res.push_back(vector<int>(1, i));
            }
            return res;
        }

        for(int i = n; i>=k; --i)
        {
            auto combi = combine(i-1, k-1);
            for(auto& c: combi)
            {
                res.push_back(std::move(c));
                res.back().push_back(i);
            }
        }
        return res;
    }
};

22 括号生成(mid)

居然可以转化为DP！

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<vector<string>> dp;
        dp.push_back(vector<string>(1, string("")));
        dp.push_back(vector<string>(1, string("()")));
        for(int i=2;i<=n;++i)
        {
            dp.push_back(vector<string>());
            for(int j=0;j<i;++j)
            {
                for(const auto& p: dp[j])
                {
                    for(const auto& q: dp[i-j-1])
                    {
                        dp.back().push_back(string("(") + p + string(")") + q);
                    }
                }
            }
        }
        return dp[n];
    }
};

左右括号匹配枚举

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        geneP(res, 0, 0, n);
        return res;
    }

    void geneP(vector<string>& res, int left, int right, int n)
    {
        if(left == right && left == n)
        {
            res.push_back(descr);
            return;
        }

        if(n>left)
        {
            descr.append(1, '(');
            geneP(res, left + 1, right, n);
            descr.pop_back();
        }

        if(right < left)
        {
            descr.append(1, ')');
            geneP(res, left, right + 1, n);
            descr.pop_back();
        }
    }

    string descr;
};

46 全排列(mid)

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        if(nums.empty())
            return vector<vector<int>>();
        
        if(nums.size() == 1)
            return vector<vector<int>>(1, nums);

        vector<vector<int>> res;
        for(int i=0;i<nums.size();++i)
        {
            vector<int> sub;
            int h = nums[i];
            copy_if(nums.cbegin(), nums.cend(), back_inserter(sub), [h](int i){return i!=h;});
            auto se = permute(sub);
            for(auto& s: se)
            {
                res.push_back(std::move(s));
                res.back().push_back(h);
            }
        }
        return res;
    }
};