六月集训代码打卡---DAY4

前言

        来自 英雄哪里出来 的一个 免费 集训，每天 $5$ 点打卡学习算法（我是为了卷吗，主要是想早起 😏），希望能坚持下去。这里用来复盘每天都的打卡题目。
       今日份知识点：贪心

一、题目

题目	难度
1221. 分割平衡字符串	⭐️
1217. 玩筹码	⭐️
1029. 两地调度	⭐️
面试题 10.11. 峰与谷	⭐️⭐️

二、算法思路

1、分割平衡字符串

        （1）题目保证了 $s$ 一定是一个平衡字符串，那么我们从左往右依次选择 LR 数量相等的 最短 字符串进行切割。
        （2）贪心证明：使每个子字符串的长度最小，得到最优解。
                反证法：假设存在两个合法的分割位置 $a,b$，其中 $a<b$，并且第一次分割点选 $b$ 得到最优解。
                ① 将第一个分割位置由 $b$ 调整为 $a$，分割后两端依旧是合法的平衡字符串，不会由 “有解” 变成 “无解”。
                ② 从 $a$ 点首次分割剩下部分的长度要大于 从 $b$ 点首次分割，并且由 $a$ 分割后剩余部分严格覆盖由 $b$ 分割后的剩余部分，因此首次由 $a$ 分割的解要优于由 $b$ 分割的解。与假设矛盾。

class Solution {
public:
    int balancedStringSplit(string s) {
        int ret = 0;
        int cl = 0, cr = 0;
        for (auto x: s) {
            if (x == 'L') ++ cl;
            if (x == 'R') ++ cr;
            if (cl == cr) {
                ++ ret;
                cl = 0, cr = 0;
            }
        }
        return ret;
    }
};

        （3）这里可以转化为数学判定，$L$ 记 $-1$ 分， $R$ 记 $1$ 分，那么一个合格的 LR 子串的充要条件为 整个 LR 子串得分为0。

class Solution {
public:
    int balancedStringSplit(string s) {
        int ret = 0;
        int cnt = 0;
        for (auto x: s) {
            if (x == 'L') -- cnt;
            if (x == 'R') ++ cnt;
            if (cnt == 0) {
                ++ ret;
            }
        }
        return ret;
    }
};

2、玩筹码

        （1）根据题目中给出的条件，筹码移动 偶数 个位置代价为 0，移动 奇数 次代价为1，那么所有 奇数 位置上的筹码移动到 奇数 位置的代价为 0， 偶数 位置上的筹码同理。
        （2）对结果分析：最后所有筹码在 奇数 位置上，代价为筹码初始位置为 偶数 的筹码数量；在 偶数 位置上，代价为筹码初始位置在 奇数 位置上的筹码数量，二者取最小值即为最优解。

class Solution {
public:
    int minCostToMoveChips(vector<int>& position) {
        int cl = 0, cr = 0;
        for (auto x: position) {
            if (x & 1)  ++ cl;
            else ++ cr;
        }
        return min(cl, cr);
    }
};

3、两地调度

        （1）假设所有人都飞到城市 $b$，然后从中挑一半人飞到城市 $a$，那么公司额外的花费为 $price(a)-price(b)$，这个花费可能是负数，挑选额外花费最小的 $n$ 个人飞到城市$a$；
        （2）那么我们先对 $costs$ 数组按照 $price(a)-price(b)$ 排序，前 $n$ 个人到城市 $a$，后 $n$ 个人到城市 $b$。

class Solution {
public:
    int twoCitySchedCost(vector<vector<int>>& costs) {
        sort(costs.begin(), costs.end(), [](const vector<int>& a, const vector<int>& b) {
            return (a[0] - a[1]) < (b[0] - b[1]);
        });
        int ret = 0;
        int n = costs.size() / 2;
        for (int i = 0; i < n; ++ i) {
            ret += costs[i][0] + costs[i + n][1];
        }
        return ret;
    }
};

4、面试题 10.11. 峰与谷

        （1）直观的做法，对数组排序，分别从最前面和最后面个挑一个数放进数组，这样一来就是 峰-谷 交替了。

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        if (nums.size() < 3)
            return;
        int n = nums.size();
        vector<int> v(nums);
        sort(v.begin(), v.end());
        int l = 0, r = nums.size() - 1;
        int idx = 0;
        while (l < r)
        {
            nums[idx ++] = v[l ++];
            nums[idx ++] = v[r --];
        }
        if (n % 2)
            nums[idx] = v[l];
    }
};

        （2）另一个做法，从前往后依次与前面一个比较，如果当前位置是峰，那么要满足 $nums[i]⩾nums[i-1]$，如果不满足，则交换两个数；如果当前位置是谷，那么需要满足 $nums[i]⩽nums[i-1]$，如果不满足，则交换；
        （3）如果当前是峰的位置，并且 $nums[i]⩽nums[i-1]$，交换两个数之后，再看 $i-1$ 的位置，它的数变成了 $nums[i]$，要比 $nums[i-1]$ 更小，所以可以满足其谷的要求；另一个同理。

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        for (int i = 1; i < nums.size(); ++ i) {
            if (i % 2 == 0) {
                if (nums[i - 1] < nums[i]) 
                    swap(nums[i - 1], nums[i]);
            }else {
                if (nums[i - 1] > nums[i])
                    swap(nums[i - 1], nums[i]);
            }
        }
    }
};

结语

        计算机离不开准确性，科学的证明非常有必要，对于贪心，直觉上可以做，但还是需要证明，日常的学习尽量做好每一步，菜鸡在学走路。