代码随想录算法训练营第八天 | 344.反转字符串、541. 反转字符串II、剑指Offer 05.替换空格、151.翻转字符串里的单词、剑指Offer58-II.左旋转字符串

344. 反转字符串

class Solution {
public:
    void reverseString(vector<char>& s) {
        int left = 0, right = s.size() - 1;
        while (left < right) {
            swap(s[left++], s[right--]);
        }
    }
};

541. 反转字符串 II

start + k < s.size()直接翻转前k个，若大于s.size()，则翻转剩余的部分。

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int start = 0; start < s.size(); start += 2 * k) {
            if (start + k < s.size()) {
                reverse(s.begin() + start, s.begin() + start + k);
            } else {
                reverse(s.begin() + start, s.end());
            }
        }
        return s;
    }
};

剑指 Offer 05. 替换空格

计算s中的空格个数，扩充s到目标大小，从后向前遍历，遇到空格则用"%20"替换

class Solution {
public:
    string replaceSpace(string s) {
        int count = 0;
        for (char ch : s) {
            if (ch == ' ') count++;
        }
        int n = s.size() + 2 * count;
        s.resize(n);
        for (int left = n - 2 * count - 1, right = n - 1; right >= 0;) {
            if (s[left] == ' ') {
                left--;
                s[right--] = '0';
                s[right--] = '2';
                s[right--] = '%';
            } else {
                s[right--] = s[left--];
            }
        }
        return s;
    }
};

151. 反转字符串中的单词

先去除字符串中多余的空格，将字符串整体翻转，再将每个单词翻转。

class Solution {
public:
    string reverseWords(string s) {
        // 先去除字符串前后的空格
        int start = 0, end = s.size() - 1;
        while (s[start] == ' ') {
            start++;
        }
        while (s[end] == ' ') {
            end--;
        }
        s = s.substr(start, end - start + 1);
        // 去除中间的多余空格
        int left = 0, right = 0;
        while (right < s.size()) {
            if (s[right] == ' ') {
                s[left++] = s[right++];
                while (s[right] == ' ') {
                    right++;
                }
            } else {
                s[left++] = s[right++];
            }
        }
        s.resize(left);
        // 先将字符串全部翻转，再将每个单词翻转
        reverse(s.begin(), s.end());
        for(int slow = 0, fast = 0; fast <= s.size(); ++fast){
            if(fast == s.size() || s[fast] == ' '){
                reverse(s.begin() + slow, s.begin() + fast);
                slow = fast + 1;
            }
        }
        return s;
    }
};

剑指 Offer 58 - II. 左旋转字符串

先翻转前n个，再翻转后面所有的，再整体翻转。

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        reverse(s.begin(), s.begin() + n);
        reverse(s.begin() + n, s.end());
        reverse(s.begin(), s.end());
        return s;
    }
};

1626. 无矛盾的最佳球队

理解转态转移方程

dp[i]表示包含第i名球员的无矛盾球队中的最大分数

dp[i] = max(dp[j]) + scores[i] 其中j < i,且 ages[j] <= ages[i]

排序后第i名球员得分最高，所以包含该i球员的球队中，他的年龄应该为最大的。

class Solution {
public:
    int bestTeamScore(vector<int>& scores, vector<int>& ages) {
        int n = scores.size();
        vector<pair<int, int>> people(n);
        for (int i = 0; i < n; i++) {
            people[i] = {scores[i], ages[i]};
        }
        sort(people.begin(), people.end());
        vector<int> dp(n, 0); // dp[i]表示包含第i名球员的无矛盾球队中的最大分数
        int res = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                // i的得分最高，所以包含i的球队中球员年龄应全部小于i的年龄
                if (people[j].second <= people[i].second) { 
                    dp[i] = max(dp[i], dp[j]);
                }
            }
            dp[i] += people[i].first; // 最后把i的分数加进去
            res = max(res, dp[i]);
        }
        return res;
    }
};