算法笔记--贪心

贪心算法

贪心算法是一种对某些求最优解问题的更简单、更迅速的设计技术。
用贪心法设计算法的特点是一步一步地进行，常以当前情况为基础根据某个优化测度作最优选择，而不考虑各种可能的整体情况，它省去了为找最优解要穷尽所有可能而必须耗费的大量时间，它采用自顶向下,以迭代的方法做出相继的贪心选择,每做一次贪心选择就将所求问题简化为一个规模更小的子问题, 通过每一步贪心选择,可得到问题的一个最优解，虽然每一步上都要保证能获得局部最优解，但由此产生的全局解有时不一定是最优的，所以贪婪法不要回溯。
贪婪算法是一种改进了的分级处理方法，其核心是根据题意选取一种量度标准，然后将这多个输入排成这种量度标准所要求的顺序，按这种顺序一次输入一个量，如果这个输入和当前已构成在这种量度意义下的部分最佳解加在一起不能产生一个可行解，则不把此输入加到这部分解中。这种能够得到某种量度意义下最优解的分级处理方法称为贪婪算法。
对于一个给定的问题，往往可能有好几种量度标准。初看起来，这些量度标准似乎都是可取的，但实际上，用其中的大多数量度标准作贪婪处理所得到该量度意义下的最优解并不是问题的最优解，而是次优解。因此，选择能产生问题最优解的最优量度标准是使用贪婪算法的核心。
一般情况下，要选出最优量度标准并不是一件容易的事，但对某问题能选择出最优量度标准后，用贪婪算法求解则特别有效。

---

以下4道题为leetcode中几道典型习题，贪心算法在线上笔试中出现频率较高，建议掌握。
除此之外还有一些两地调度(#1029)，柠檬水找零(#860)等问题都是贪心思想。

买卖股票的最佳时机

（#122 系列题型很爱考，可能是贪心、动态规划）
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

int maxProfit(vector<int>& prices) 
{
		if (prices.size() <= 1)
			return 0;

		int nMaxProfit = 0;//0 4 7 
		int nBuyPrice = prices[0];//  7 1   3   4
		int nSellPrice = prices[0];// 7 1 5 3 6 4
		for (vector<int>::size_type i = 1; i < prices.size(); ++i) {
			//如果第二天价格高  就卖  计算获利
			if (prices[i] > nSellPrice) { //1-5  3-6   
				nMaxProfit += (prices[i] - nSellPrice);  //4 7
				// 更新卖出价格
				nSellPrice = prices[i];
			} 
			//如果第二天价格低了 就买
			else 
			{
				// 价格降低了，得重新买入了 7-1  5-3  6-4 
				nSellPrice = nBuyPrice = prices[i];
			}
		}

		return nMaxProfit;
	}

分糖果 （hard难度贪心）

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：
每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？

示例 1:
输入: [1,0,2]
输出: 5
解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。
示例 2:
输入: [1,2,2]
输出: 4
解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。

方法1：遍历两次 满足左规则和右规则

int candy(vector<int>& ratings) {
	const int N=ratings.size();
	if(N==0) return 0;
	if(N==1) return 1;
	vector<int> left(N,0);
	left[0]=1;
	for(int i=1;i<N;i++){
		if(ratings[i] > ratings[i-1]){
			left[i] = left[i-1] + 1;
		}else if(ratings[i] <= ratings[i-1]){
			left[i] = 1;
		}
	}
	int right = 1;
	int s = 0;
	s += max(left[N-1],right);
	for(int i=N-2;i>=0;i--){
		if(ratings[i] > ratings[i+1]){
			right = right + 1;
		}else if(ratings[i] <= ratings[i+1]){
			right = 1;
		}
		s += max(left[i],right);
	}
	
	return s;
}

方法2 ：遍历一遍

   int candy(vector<int>& ratings) {
        if(ratings.empty()) return 0;
        int size = ratings.size();
        int candies = 1;
        int sum = 1;
        int max = 0;
        int downIndex = 0;
        for(int i=1;i<size;i++){
            if(ratings[i]<ratings[i-1]){
                if(downIndex==0){
                    // 记录上一个评分波峰峰值
                    max = candies;
                    // 记录评分开始下降的位置
                    downIndex=i;
                }
                candies=1;
                // 补发糖果
                sum+=i-downIndex;
                // 判断波峰是否需要补发糖果
                if(i-downIndex+1>=max)
                    sum+=1;
            }else if(ratings[i]>ratings[i-1]){
                downIndex = 0;
                candies+=1;
            }else{
                downIndex = 0;
                candies=1;
            }
            // 发糖果
            sum+=candies;
        }
        return sum;
    }

贪心判断子序列

题目描述：给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
示例 1:
s = “abc”, t = “ahbgdc”
返回 true.
示例 2:
s = “axc”, t = “ahbgdc”
返回 false.

bool isSubsequence(string s, string t)
{
    if(s.empty())
        return true;
    if(t.empty())
        return false;
        
    int j =0;
    for(int i=0;i<t.size();i++)
    {
        if(j < s.size())
        {
            if(s[j] == t[i])
            {   
                j++;
            }                
        }  
    }
    if(j == s.size())
        return true;
	return false;
}

模拟行走机器人(leetcode#874)

机器人在一个无限大小的网格上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令：
-2：向左转 90 度
-1：向右转 90 度
1 <= x <= 9：向前移动 x 个单位长度
在网格上有一些格子被视为障碍物。
第 i 个障碍物位于网格点 (obstacles[i][0], obstacles[i][1])
如果机器人试图走到障碍物上方，那么它将停留在障碍物的前一个网格方块上，但仍然可以继续该路线的其余部分。
返回从原点到机器人的最大欧式距离的平方。
示例 1：
输入: commands = [4,-1,3], obstacles = []
输出: 25
解释: 机器人将会到达 (3, 4)
示例 2：
输入: commands = [4,-1,4,-2,4], obstacles = [[2,4]]
输出: 65
解释: 机器人在左转走到 (1, 8) 之前将被困在 (1, 4) 处
设置一个方向，设置两个方向数组 一一对应 怎么改变方向

i

nt robotSim(vector<int>& commands, vector<vector<int>>& obstacles) {
        int res = 0,x = 0, y = 0,dir = 0;   //dir 0 1 2 3
        int dx[] = {0,1,0,-1};//上  右  下  左
        int dy[] = {1,0,-1,0};
        set<pair<int,int>> s;   //使用set向量加快寻找速度
        for(int i=0;i<obstacles.size();i++)    //存障碍物
        {
            s.insert({obstacles[i][0],obstacles[i][1]}); 
        }
        for(int i=0;i<commands.size();i++)
        {
            if(commands[i] == -2)  //左转  
                dir = (dir+3) % 4;
            else if(commands[i] == -1)   //右转
                dir = (dir+1) % 4;
            else{
                for(int j=0;j<commands[i];j++)
                {
					//设置一个临时坐标
                    int tmp_x = x+dx[dir];
                    int tmp_y = y+dy[dir];
					//判断是否有障碍物
                    if(s.find(make_pair(tmp_x,tmp_y)) == s.end())
                    {
						//没有障碍物就相加
                        x = tmp_x;
                        y = tmp_y;
						//取最大值
                        res = max(res,x*x+y*y);
                    }
                }
            }
        }
        return res;
    }