LeetCode 第 201 场周赛

A 整理字符串

class Solution {
public:
    string makeGood(string s) {
        stack<char> v;
        int n = s.size();
        for (int i = 0; i < n; i++) {
            char c1 = s[i];
            if (v.size()) {
                char c2 = v.top();
                if (abs(c1 - c2) == 32) v.pop();
                else v.push(c1);
            } else {
                v.push(c1);
            }
        }
        s = "";
        while (v.size()) {
            char c = v.top();
            v.pop();
            s = s + c;
        }
        reverse(s.begin(), s.end());
        return s;
    }
};

B 找出第 N 个二进制字符串中的第 K 位

class Solution {
public:
    char findKthBit(int n, int k) {
        string s[30];
        s[1] = "0";
        for (int i = 2; i <= n; i++) {
            string p = s[i - 1];
            for (int j = 0; j < p.size(); j++) {
                if (p[j] == '0') p[j] = '1';
                else p[j] = '0';
            }
            reverse(p.begin(), p.end());
            s[i] = s[i - 1] + "1" + p;
        }
        return s[n][k - 1];
    }
};

C 和为目标值的最大数目不重叠非空子数组数目

前缀和，贪心，用map标记一下前缀和，得到target，清空下map，记得每次更新都要把map[0] = 1，不然会缺少情况。

class Solution {
public:
    int maxNonOverlapping(vector<int>& nums, int target) {
        int n = nums.size();
        map<int, int> m;
        int ans = 0, sum = 0;
        m[0] = 1;
        for (int i = 0; i < n; i++) {
            sum += nums[i];
            if (m[sum - target]) {
                ans++; 
                m.clear();
                m[0] = 1;
                sum = 0;
            } else {
                m[sum] = 1;
            }
        }
        return ans;
    }
};

D 切棍子的最小成本

很典型的区间DP，一开始没想到...，还以为是个贪心。

动态转移方程：$dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + cost[i][j])$，$dp[i][j]$表示从第i个切割点到第j个切割点之间的最少代价，枚举分割点i和j之间所有的切割点k，寻找最优值。

class Solution {
public:
    int minCost(int n, vector<int>& cuts) {        
        cuts.push_back(0);
        cuts.push_back(n);
        int m = cuts.size();
        vector< vector<int> > dp(m, vector<int>(m, 0x3f3f3f3f));
        sort(cuts.begin(), cuts.end());
        dp[0][0] = 0;
        for (int i = 1; i < m; ++i){
            dp[i][i] = 0;
            dp[i - 1][i] = 0;
        }
        for (int i = m - 2; i >= 0; i--){
            for (int j = i + 1; j < m; j++){
                for (int k = i + 1; k < j; k++){
                    int cost = cuts[j] - cuts[i];
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + cost);
                }
            }
        }
        return dp[0][m-1];
    }
};