算法-贪心算法

一、知识点介绍

1. 什么是贪心算法

保证每次操作都是局部最优的，从而使最后得到的结果是全局最优的。
通常的预处理是：排序

二、练习题目

        (1)1221. 分割平衡字符串
        (2)1217. 玩筹码
        (3)1029. 两地调度
        (4)面试题 10.11. 峰与谷

三、算法思路

1. 分割平衡字符串

        (1) 需要设置一个计数器cnt: 遇见’R’的时候，计数器cnt加1；遇到’L’的时候，计数器cnt减1. cnt为0的时候就说明可以切割，最后返回切割数。

class Solution {
public:
    int balancedStringSplit(string s) {
        int ans = 0;
        int cnt = 0;
        int i;
        for(i = 0; i < s.size(); ++i) {
            if(s[i] == 'L') cnt++;
            if(s[i] == 'R') cnt--;
            if(cnt == 0) ans++;
        }
        return ans;

    }
};

2. 玩筹码

        (1)这道题比较绕的一个点就是：第 i 个芯片的位置是 position[i]；
        (2)我们发现这道题的数据量不大，所以直接遍历，如果把所有筹码归到第i个芯片的位置 -> 也就是把其他位置的芯片归到position[i] -> 也就是把position[j]的位置归到position[i]；
        (3) 根据题意可得当position[i]和position[j]的距离是偶数的时候，移动不需要成本；当position[i]和position[j]的距离是奇数的时候，移动需要1的成本；
        (4)所以遍历把所有筹码归到各个位置的代价，并返回最小的代价。

class Solution {
public:
    int minCostToMoveChips(vector<int>& position) {
        int i, j;
        int cost = 0;
        int min = 100000009;
        for(i = 0; i < position.size(); ++i) {
            cost = 0;//每次代价都要初始化为0
            for(j = 0; j < position.size(); ++j) {
                if((abs(position[j]-position[i])) & 1) cost++; 
                //如果把j位置的元素放到i位置，
                //判断两个元素的位置之差是不是奇数
                //如果是奇数的话，总代价+1
            }
           // printf("%d\n", cost);
            if(min > cost) min = cost;
        }
        return min;

    }
};

3. 两地调度

        (1) 这道题的第一个关键点在于排序。如果要一半的人去a地，一半的人去b地，如何确定谁应该去a地？谁应该去b地？所以将每个人去a地或者去b地的费用的差值进行升序排序。因为每个人去a地或者去b地的费用的差值越小，说明这些人去a地更省钱，去b地更花钱，所以根据题意，前n个人应该要去a地。
        (2) 如何保证一半的人去a地，另外一半的人去b地，是第二个关键点。遍历一半的数组，费用的和就是前一半数组的a地费用加上后一半数组的b地的费用。

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

4. 峰与谷

        (1) 因为原函数的返回值是void，所以要copy一个nums数组；
        (2) 然后要从小到大对这两个数组进行排序；
        (3) 用双指针，定义一个左指针指向copy数组的最小值，一个右指针指向copy数组的最大值；对nums进行遍历，当位置为偶数时，向nums数组插入copy数组的最大值，右指针减一，往左边移动；当位置为奇数时，向nums数组插入copy数组的最小值，左指针加一，往右边移动。

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        vector<int> copy;
        int i, j;
        int l = 0;
        int r = nums.size()-1;
        for(i = 0; i < nums.size(); ++i) {
            copy.push_back(nums[i]);
        }
        sort(copy.begin(), copy.end());
        sort(nums.begin(), nums.end());
        for(i = 0; i < nums.size(); ++i) {
            if(!(i&1)) {
                nums[i] = copy[r];
                r--;
            } else {
                nums[i] = copy[l];
                l++;
            }
            
        }

    }
};

5. 总结