K次取反后最大化的数组和
给定一个整数数组 A,我们只能用以下方法修改该数组:我们选择某个索引 i 并将 A[i] 替换为 -A[i],然后总共重复这个过程 K 次。(我们可以多次选择同一个索引 i。)
以这种方式修改数组后,返回数组可能的最大和。
示例 1:
- 输入:A = [4,2,3], K = 1
- 输出:5
- 解释:选择索引 (1) ,然后 A 变为 [4,-2,3]。
示例 2:
- 输入:A = [3,-1,0,2], K = 3
- 输出:6
- 解释:选择索引 (1, 2, 2) ,然后 A 变为 [3,1,0,2]。
示例 3:
- 输入:A = [2,-3,-1,5,-4], K = 2
- 输出:13
- 解释:选择索引 (1, 4) ,然后 A 变为 [2,3,-1,5,4]。
提示:
- 1 <= A.length <= 10000
- 1 <= K <= 10000
- -100 <= A[i] <= 100
第一反应:遍历数组是否存在负数,若存在将绝对值大的负数优先取反然后返回数组和,如不存在则找到最小的正数取反再返回数组和;
其实这两步就是贪心算法的思想:
前者局部最优为:让绝对值大的负数变为正数,当前数值达到最大,整体最优;
后者局部最优为:只找数值最小的正整数进行反转,当前数值和可以达到最大;
共同整体最优:整个数组和达到最大;
整体代码如下:
class Solution {
public:
//using namespace std
static bool compare(int a, int b){
return abs(a) > abs(b);//定义排序规则,绝对值从大到小排列
}
int largestSumAfterKNegations(vector<int>& nums, int k){
sort(nums.begin(), nums.end(), compare);//排序,统一处理规则
int res = 0;
for(int i = 0; i < nums.size(); i++){
if(nums[i] < 0 && k > 0){//遇负取反
nums[i] = -nums[i];
k--;
}
}
if(k % 2 == 1) nums[nums.size() - 1] *= -1;//如果k依然不为零,则反复处理最后一个绝对值最小的元素
for(int j = 0; j < nums.size(); j++){
res += nums[j];
}
return res;
}
};
加油站
在一条环路上有 N 个加油站,其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车,从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发,开始时油箱为空。
如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 -1。
说明:
- 如果题目有解,该答案即为唯一答案。
- 输入数组均为非空数组,且长度相同。
- 输入数组中的元素均为非负数。
示例 1: 输入:
- gas = [1,2,3,4,5]
- cost = [3,4,5,1,2]
输出: 3 解释:
- 从 3 号加油站(索引为 3 处)出发,可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
- 开往 4 号加油站,此时油箱有 4 - 1 + 5 = 8 升汽油
- 开往 0 号加油站,此时油箱有 8 - 2 + 1 = 7 升汽油
- 开往 1 号加油站,此时油箱有 7 - 3 + 2 = 6 升汽油
- 开往 2 号加油站,此时油箱有 6 - 4 + 3 = 5 升汽油
- 开往 3 号加油站,你需要消耗 5 升汽油,正好足够你返回到 3 号加油站。
- 因此,3 可为起始索引。
示例 2: 输入:
- gas = [2,3,4]
- cost = [3,4,3]
- 输出: -1
- 解释: 你不能从 0 号或 1 号加油站出发,因为没有足够的汽油可以让你行驶到下一个加油站。我们从 2 号加油站出发,可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油。开往 0 号加油站,此时油箱有 4 - 3 + 2 = 3 升汽油。开往 1 号加油站,此时油箱有 3 - 3 + 3 = 3 升汽油。你无法返回 2 号加油站,因为返程需要消耗 4 升汽油,但是你的油箱只有 3 升汽油。因此,无论怎样,你都不可能绕环路行驶一周
直观思路,暴力求解:将gas数组扩充为两倍为gas_new数组,即可实现从任意下标为i的加油站出发并回到原点的过程;同理将cost数组扩充到两倍为cost_new数组,遍历i < gas.size() -1的所有可能出发点,然后判断对应的gas_new[j] - cost_new[j + 1]是否大于等于零,若一直大于等于零,则返回出发时的编号i,结束遍历;若遍历完整个gas数组都没有一直大于零的情况,则返回-1;
整体代码如下:
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost){
int n = gas.size();
for (int i = 0; i < n; i++) {
int sum = 0;
for(int j = i; j < n + i; j++){
sum += gas[j % n] - cost[j % n];
if(sum < 0) break;
else{
if((j + 1) % n == i)
return i;
}
}
}
return -1;
}
};
这段代码逻辑是没有问题的,但是遇到很长的数组的时候会超时;这是因为每次遍历都是将整个数组进行整体遍历,且嵌套了两层for循环,暴力解法必然跟随着超时问题;
考虑贪心算法的思路,如果总油量减去总消耗大于等于零那么一定可以跑完一圈,说明各个站点的加油站剩油量rest[i]相加一定是大于等于零的;
定义每个加油站的剩余量rest[i]为gas[i] - cost[i]。
i从0开始累加rest[i],和记为curSum,一旦curSum小于零,说明[0, i]区间都不能作为起始位置,因为这个区间选择任何一个位置作为起点,到i这里都会断油;
即当前的sum值已经小于零,则直接将i移动到下一位重新进行累加操作,起始位置重新从i+1算起,再从0开始计算curSum;
如果再次遇到负数则再次更新,直到找到首个保证全部大于等于零的区间即返回此时的起始下标(因为题目默认存在唯一解);
下面简单论证逻辑统一性:
假设[0,i]区间curSum<0,[j,i]区间curSum>0,其实也是满足了区间和curSum<0的时候直接跳入下一个区间的逻辑,因为此时区间和2大于0,区间和1小于0,实际上依然是满足给出的逻辑进行遍历的;
局部最优:当前累加rest[i]的和curSum一旦小于0,起始位置更改为i+1,因为从i之前开始一定不行;
全局最优:找到可以跑一圈的起始位置;
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost){
int curSum = 0;
int totalSum = 0;
int startIndex = 0;
for(int i = 0; i < gas.size(); i++){
curSum += gas[i] - cost[i];
totalSum += gas[i] - cost[i];
if(curSum < 0){//更新逻辑
startIndex = i + 1;//更新起始位置
//此处不会索引异常的原因
//如果startIndex == gas.size()
//则此时必然是[0,gas.size() - 1]的所有差值之和小于零
//这个时候已经return -1了,不会出现startIndex越界数组的情况
curSum = 0;
}
}
//此时走出循环,startIndex必然没有被后序的更新替代,此时[startIndex,gas.size()-1]之间的curSum为正数
//若记此时的curSum为B,startIndex之前的Sum为A,那么A+B=totalSum,
//已知totalSum>=0, A<0, B>0, 所以B>-A, 走完一圈的B+A>=0
if(totalSum < 0) return -1;
return startIndex;//即:如果totalSum >= 0 则必然存在一条路径,返回此时的startIndex必然是满足题目要求的唯一解
}
};
分发糖果
老师想给孩子们分发糖果,有 N 个孩子站成了一条直线,老师会根据每个孩子的表现,预先给他们评分。
你需要按照以下要求,帮助老师给这些孩子分发糖果:
- 每个孩子至少分配到 1 个糖果。
- 相邻的孩子中,评分高的孩子必须获得更多的糖果。
那么这样下来,老师至少需要准备多少颗糖果呢?
示例 1:
- 输入: [1,0,2]
- 输出: 5
- 解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。
示例 2:
- 输入: [1,2,2]
- 输出: 4
- 解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。第三个孩子只得到 1 颗糖果,这已满足上述两个条件。
如果同时兼顾两边的话是不行的,题目一定是要确定一边之后,再确定另一边,例如比较每一个孩子的左边,然后再比较右边;
先确定右边评分大于左边的情况(也就是从前向后遍历):
此时局部最优:只要右边评分比左边大,右边的孩子就多一个糖果,全局最优:相邻的孩子中,评分高的右孩子获得比左边孩子更多的糖果;
同理,从后向前遍历,确定左孩子大于右孩子的情况;
至于为何不能从前往后遍历?
如果从前向后遍历,rating[5]与rating[4]的比较要利用上rating[5]与rating[6]的比较结果,所以要从后向前遍历;
rating[5]与rating[4]的比较就不能用上rating[5]与rating[6]的比较结果了;
如果 ratings[i] > ratings[i + 1],此时candyVec[i](第i个小孩的糖果数量)就有两个选择了,一个是candyVec[i + 1] + 1(从右边这个加1得到的糖果数量),一个是candyVec[i](之前比较右孩子大于左孩子得到的糖果数量)。
那么又要贪心了,局部最优:取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量,保证第i个小孩的糖果数量既大于左边的也大于右边的。全局最优:相邻的孩子中,评分高的孩子获得更多的糖果。
局部最优可以推出全局最优。
所以就取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量,candyVec[i]只有取最大的才能既保持对左边candyVec[i - 1]的糖果多,也比右边candyVec[i + 1]的糖果多。
整体代码如下:
class Solution {
public:
int candy(vector<int>& ratings) {
vector<int> candyVec(ratings.size(), 1);
// 从前向后
for (int i = 1; i < ratings.size(); i++) {
if (ratings[i] > ratings[i - 1]) candyVec[i] = candyVec[i - 1] + 1;
//右边大于左边
}
// 从后向前
for (int i = ratings.size() - 2; i >= 0; i--) {
if (ratings[i] > ratings[i + 1] ) {
candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1);
//左边大于右边,取最大值
}
}
// 统计结果
int result = 0;
for (int i = 0; i < candyVec.size(); i++) result += candyVec[i];
return result;
}
};