代码随想录——贪心

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量4k 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41433002/article/details/123847232
版权

题目来自《代码随想录》

文章目录

455. 分发饼干

https://leetcode-cn.com/problems/assign-cookies/

	/**
	 * 执行用时：7 ms, 在所有 Java 提交中击败了99.93%的用户
	 * 内存消耗：42.5 MB, 在所有 Java 提交中击败了12.66%的用户
	 * @param g 孩子胃口值
	 * @param s 饼干值
	 * @return 能够满足多少个孩子的胃口
	 */
	public int findContentChildren2(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int start = 0;
        int count = 0;
        for (int i = 0; i < s.length && start < g.length; i++) {
            if (s[i] >= g[start]) {
                start++;
                count++;
            }
        }
        return count;
    }
	
	/**
	 * 1. 平什么版
	 * 执行用时：8 ms, 在所有 Java 提交中击败了23.59%的用户
	 * 内存消耗：42.1 MB, 在所有 Java 提交中击败了63.17%的用户
	 * @param g 孩子胃口值
	 * @param s 饼干值
	 * @return 能够满足多少个孩子的胃口
	 */
	public int findContentChildren(int[] g, int[] s) {
		int ans = 0;
		Arrays.sort(g);
		Arrays.sort(s);
		int ind = 0;
		System.out.println(s.length);
		for(int i=0; i<g.length; i++) {
			System.out.println("i=" + i + "，ind:" + ind);
			while(ind < s.length) {
				System.out.println("第" + i + "个孩子胃口：" + g[i] + "，第" + ind + "个饼干：" + s[ind]);
				if(g[i] <= s[ind]) {
					System.out.println("满足胃口" );
					ans++;
					ind++;
					System.out.println("满足后ind变为" + ind );
					break;
				} else {
					ind++;
					System.out.println("不满足后ind变为" + ind );
				}
			}
			if(ind == s.length) break;
		}		
		return ans;
	}

376. 摆动序列

https://leetcode-cn.com/problems/wiggle-subsequence/

	/*
	 * 碰到【0，0，0】输出就是2，不对
	 */
	public int wiggleMaxLength(int[] nums) {
		if(nums.length <=2) {
			if( nums.length == 2 && nums[0] == nums[1]) return 1;
			return nums.length;
		}
		int ans = 2;
		int pre = 0; //前一对差
		int next = 0; //下一个差
		for(int i=1; i<nums.length-1; i++) {//判断从第二个到倒数第二个
			pre = nums[i-1] - nums[i];
			next = nums[i] - nums[i+1];
			if((pre > 0 && next < 0) || (pre < 0 && next >0)) ans++;
		}
		return ans;
	}
	
	/*
	 * 正确答案
	 */
	public int wiggleMaxLength2(int[] nums) {
		if(nums.length <=1) return nums.length;
		int up = 1;
		int down = 1;
		for(int i=1; i<nums.length; i++) {
			if(nums[i]-nums[i-1] > 0) up = down+1;
			if(nums[i]-nums[i-1] < 0) down = up+1;
		}		
		return Math.max(up, down);
	}

53. 最大子数组和

https://leetcode-cn.com/problems/maximum-subarray/

	//当前连续和为负数时，立马放弃
	public int maxSubArray(int[] nums) {
		int ans = Integer.MIN_VALUE;
		int curans = 0;
		for(int i=0; i<nums.length; i++) {
			curans += nums[i];
			if(curans > ans) ans = curans;
			if(curans < 0) curans = 0;
		}		
		return ans;
	}

122. 买卖股票的最佳时机 II

一遍过，蔑视中等题

	/*
	 * 执行用时：1 ms, 在所有 Java 提交中击败了87.62%的用户
	 * 内存消耗：41.5 MB, 在所有 Java 提交中击败了11.16%的用户
	 */
	public int maxProfit(int[] prices) {
		int ans = 0;
		for(int i=1; i<prices.length; i++) {
			if(prices[i]-prices[i-1] > 0) ans+=prices[i]-prices[i-1];
		}		
		return ans;	
	}

55. 跳跃游戏

https://leetcode-cn.com/problems/jump-game/

  1. 递归思路
  2. 找能覆盖的最大面积
	public boolean canJump(int[] nums) {
		if(nums.length <= 1) return true;
		return digui(nums, nums.length-1);
	}

	public boolean digui(int[] nums, int s) {
		if(nums[0] >= s) {
			System.out.println("从第" + s + "格可以跳到起点");
			return true;
		}
		
		for(int i=s-1; i>=0; i--) {
			if(nums[i] >= s-i) {
				System.out.println("从第" + s + "格跳往第" + i + "格");
				return digui(nums, i);
			}
		}
		return false;
	}

45. 跳跃游戏 II

	/*
	 * 1. 从后往前遍历所有，这种递归会超时的
	 */
	LinkedList<Integer> path = new LinkedList<>();	
	
	int ans = Integer.MAX_VALUE;
	public int jump(int[] nums) {
		if(nums.length == 1) return 0;
		digui(nums, nums.length-1, 0);
		return ans;
    }
	
	public void digui(int[] nums, int s, int curstep) {
		if(nums[0] >= s) {
			curstep++;
			System.out.println("从第" + s + "格可以跳到起点，存入step为：" + curstep);
			if(curstep < ans) ans = curstep;
			path.add(curstep);
		}
		
		for(int i=s-1; i>=0; i--) {
			if(nums[i] >= s-i) {
				System.out.println("从第" + s + "格跳往第" + i + "格");
				digui(nums, i, curstep+1);
			}
		}
	}
	
	/*
	 * 2. 还是从后往前，不递归，每次只迈最大步。但这玩意效率也不高
	 * 执行用时：14 ms, 在所有 Java 提交中击败了24.58%的用户
	 * 内存消耗：42 MB, 在所有 Java 提交中击败了13.65%的用户
	 */

	public int jump2(int[] nums) {
		int ind = nums.length-1;
		int step = 0;
		while( ind > 0) {
			for(int i=0; i<ind; i++) {
				if(i+nums[i] >= ind) {
					ind = i;
					step++;
					break;
				}
			}
		}
		return step;
	}
	
	/*
	 * 3. 没有达到我上一次跳跃的最远距离，就不跳
	 * 这过程中储存下一次能跳的最远距离
	 * 达到我上一次跳的最远距离了，就跳，次数加一
	 * 执行用时：2 ms, 在所有 Java 提交中击败了44.78%的用户
	 * 内存消耗：42.1 MB, 在所有 Java 提交中击败了11.47%的用户
	 */
	public int jump3(int[] nums) {
		int res = 0;
		int cur = 0;//当前最远
		int next = 0; //下一步最远
		for (int i = 0; i <= cur && cur < nums.length - 1; ++i) {//在条约范围内
			next = Math.max(next, nums[i] + i);//这比的不是cur，比的是next
			if(i == cur) {
				cur = next;
				res++;
			}			
		}	
		return res;
	}

1005. K 次取反后最大化的数组和

	public int largestSumAfterKNegations(int[] nums, int k) {
        // 排序，把可能有的负数排到前面
        Arrays.sort(nums);
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            // 贪心：如果是负数，而k还有盈余，就把负数反过来
            if (nums[i] < 0 && k > 0) {
                nums[i] = -1 * nums[i];
                k--;
            }
            sum += nums[i];
        }
        Arrays.sort(nums);
        // 1. 如果k没剩，那说明能转的负数都转正了，已经是最大和，返回sum
        // 2. 如果k还剩偶数个就自己抵消掉，不用删减，
        // 3. 如果k还剩奇数个就减掉2倍最小正数。
        if( k%2 != 0) sum -= 2*nums[0];
        
        return sum;
	}

134. 加油站

https://leetcode-cn.com/problems/gas-station/

	/*
	 * 方法1：
	 * (1)如果gas和小于cost和，那就到不了(2)起点在gas和cost差最大的地方
	 * 答案错误！
	 * 如：gas = [5,8,2,8]， cost = [6,5,6,6]
	 */
	public int canCompleteCircuit(int[] gas, int[] cost) {
		int gassum = 0; // 能提供的汽油总和
		int costsum = 0; // 消耗的汽油总和
		int ans_index = 0; 
		int ans = 0;
		for(int i=0; i<gas.length; i++) {
			gassum += gas[i];
			costsum += cost[i];
			if( (gas[i]-cost[i]) > ans ) {
				ans = gas[i]-cost[i];
				ans_index = i;
			}
		}
		if( gassum < costsum ) ans_index = -1;
		return ans_index;
	}
	
	/*
	 * 方法2：
	 * 一直计算gas[i]-cost[i]的累加和，出现负数了，累加和置0，从下一位开始新的计算和记录
	 */
	public int canCompleteCircuit2(int[] gas, int[] cost) {
		int index = 0; //最终答案
		int tolsum = 0; //gas和-cost和
		int cursum = 0; //gas[i]-cost[i]的累加和，出现负数了，累加和置0
		
		for(int i=0; i<gas.length; i++) {
			tolsum += gas[i]-cost[i];
			cursum += gas[i]-cost[i];
			if( cursum < 0 ) {
				cursum = 0;
				index = i+1;
			}			
		}
		if( tolsum < 0) return -1;
		return index;
	}

135. 分发糖果

https://leetcode-cn.com/problems/candy/

	/*
	 * 一次是从左到右遍历，只比较右边孩子评分比左边大的情况。
	 * 一次是从右到左遍历，只比较左边孩子评分比右边大的情况。
	 */
	public int candy(int[] ratings) {
		int[] candy = new int[ratings.length];
		//1. 从左到右。右边比左边大，右边就加一。
		candy[0] = 1;
		for(int i=1; i<ratings.length; i++) {
			candy[i] = 1;
			if( ratings[i] > ratings[i-1]) {
				System.out.println(i + "位置上的值比" + (i-1) + "位置上的大");
				
				candy[i] = candy[i-1] + 1;
				System.out.println(i + "位置上的值加完1为" + candy[i]);
			}
		}		
		//2. 从右到左。左边比右边大，左边就加一
		//因为从左到右加过一次！所以要判断是从左边过来的大还是右边加一之后大！！
		for(int i=ratings.length-2; i>=0; i--) {
			if( ratings[i] > ratings[i+1]) {
				candy[i] = Math.max(candy[i], candy[i+1] + 1);
			}
		}		
		//3. 求和
		int ans = 0;
		for( int i: candy) {
			System.out.print(i + " ");
			ans += i;
		}
		return ans;
	}

860. 柠檬水找零

https://leetcode-cn.com/problems/lemonade-change/
一遍过

		/*
		 * 1. 10块的只能用5块的找
		 * 2. 20的：①10+5 ②5+5+5
		 * 注意这题是有顺序的，
		 */
	
	public boolean lemonadeChange(int[] bills) {
		int num5 = 0;
		int num10 = 0;
		int num20 = 0;		
		for(int i=0; i<bills.length; i++) {
			if( bills[i] == 5) num5++;
			if( bills[i] == 10) {
				if( num5 > 0) {//5块的够找10块的
					num5--;
					num10++;
				}else return false; //不够找，false
			}
			if( bills[i] == 20) {
				if( num10 > 0 && num5 > 0) {//1. 优先10+5的找
					num5--;
					num10--;
					num20++;
				}else if(num5 >= 3) {//2. 5块的有三张够找
					num5 -= 3;
					num20++;
				}else return false; // 都不够找，false
			}
		}	
		return true;
	}

406. 根据身高重建队列

https://leetcode-cn.com/problems/queue-reconstruction-by-height/

  1. 数组的sort
  2. 多维数组遍历
  3. 多维数组List之间转化
	public int[][] reconstructQueue(int[][] people) {
		// 身高从大到小排（身高相同k小的站前面）
        Arrays.sort(people, (a, b) -> {
            if (a[0] == b[0]) return a[1] - b[1];
            return b[0] - a[0];
        });
        int len = people.length;
        List<int[]> res= new ArrayList<>();
        for(int i = 0;i<len;i++){
            if (res.size() > people[i][1]){
                //结果集中元素个数大于第i个人前面应有的人数时，将第i个人插入到结果集的 people[i][1]位置
                res.add(people[i][1],people[i]);
            }else{
                //结果集中元素个数小于等于第i个人前面应有的人数时，将第i个人追加到结果集的后面
                res.add(res.size(),people[i]);
            }
        }
        return res.toArray(new int[len][2]);
	}

452. 用最少数量的箭引爆气球

https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/

	//先排序，每有左边界超过上一个右边界的，答案加一
	public int findMinArrowShots(int[][] points) {
		if(points.length == 0) return 0;
        Arrays.sort(points, (p1, p2) -> p1[1] < p2[1] ? -1 : 1);
        int res = 1;
        int pre = points[0][1];
        for(int i=1; i<points.length; i++) {
        	if(points[i][0] > pre) {
        		res++;
        		pre = points[i][1];
        	}
        }   
        return res;
	}

435. 无重叠区间

https://leetcode-cn.com/problems/non-overlapping-intervals/

	//按右闭区间从小到大排序
	public int eraseOverlapIntervals(int[][] intervals) {
		if(intervals.length == 0) return 0;
		
		//得右边靠齐
        Arrays.sort(intervals, new Comparator<int[]>() {
            public int compare(int[] interval1, int[] interval2) {
                return interval1[1] - interval2[1];
            }
        });
        show(intervals);
        int res = 0;
        int pre = intervals[intervals.length-1][0];//最后一个的左区间
        System.out.println("最后一个区间的左为：" + pre);
        for(int i=intervals.length-2; i>=0; i--) {
        	if(intervals[i][1] > pre) {//当前右大于上一个左，重叠
        		System.out.println("倒数第" + (i+1) + "个区间的右后一个的左，即" 
        						+ intervals[i][1] + "大于" + pre);
        		res++;//答案加一，pre不变
        	}else{//当前左小于等于上一个左，没重叠
        		pre = intervals[i][0];//pre换人
        	}
        }   
        return res;
	}
	
	public void show(int[][] nums) {
		for(int i=0; i<nums.length; i++) {
			System.out.print("[");
			for(int j=0; j<nums[i].length; j++) {
				System.out.print(nums[i][j] + " ");
			}
			System.out.print("],");
		}
		System.out.print("\n");
	}
	
	//正解
    public int eraseOverlapIntervals2(int[][] intervals) {
        Arrays.sort(intervals, (a, b) -> {
            if (a[0] == a[0]) return a[1] - b[1];
            return a[0] - b[0];
        });

        int count = 0;
        int edge = Integer.MIN_VALUE;
        for (int i = 0; i < intervals.length; i++) {
            if (edge <= intervals[i][0]) {
                edge = intervals[i][1];
            } else {
                count++;
            }
        }

        return count;
    }

763. 划分字母区间

https://leetcode-cn.com/problems/partition-labels/

	public List<Integer> partitionLabels(String s) {
        List<Integer> list = new LinkedList<>(); //储存答案
        int[] edge = new int[26];
        char[] chars = s.toCharArray(); //统计每个字符出现的最后位置存入edge中
        for (int i = 0; i < chars.length; i++) {
            edge[chars[i] - 'a'] = i;
        }
        int idx = 0;//当前字符最远边界
        int last = -1;//已经分割出去的片段总长度片段长度
        for (int i = 0; i < chars.length; i++) {
        	//idx表示当前片段最小边界 = max（上个字符最远位置，当前字符最远位置）
            idx = Math.max(idx,edge[chars[i] - 'a']);
            if (i == idx) {//！！！如果当前字符最远位置和当前字符位置一样，得到答案
                list.add(i - last);
                last = i;
            }
        }
        return list;		
	}

56. 合并区间

https://leetcode-cn.com/problems/merge-intervals/
注意考虑最后一对有没有存进去

	public int[][] merge(int[][] intervals) {
		List<int[]> res = new LinkedList<>();
		Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[0]));//按左边界从小到大排      
        show(intervals);
        //每有一个左小于上一个右，合并
        int l = intervals[0][0];//第一个左边界
        int r = intervals[0][1];//第一个右边界
        for(int i=1; i<intervals.length; i++) {
        	if(intervals[i][0] <= r ) {//如果左小于上一个右，l不变，r扩大
        		r = Math.max(intervals[i][1], r);//当前右和上一个右当中大的当新右
        	}else{//如果左大于上一个右，res.add，更新l r
        		res.add(new int[]{l, r});
                l = intervals[i][0];//更新左边界
                r = intervals[i][1];//更新右边界       		
        	}
        }
        res.add(new int[]{l, r});//最后一对没加，加一下
        return res.toArray(new int[res.size()][]);
	}

738. 单调递增的数字

https://leetcode-cn.com/problems/monotone-increasing-digits/

	/*
	 * 局部最优：遇到strNum[i - 1] > strNum[i]的情况，
	 * 让strNum[i - 1]--，然后strNum[i]给为9，可以保证这两位变成最大单调递增整数。
	 * 全局最优：得到小于等于N的最大单调递增的整数。
	 * 
	 */
	public int monotoneIncreasingDigits(int n) {
		if (n==0)return 0;
        char[] chars= Integer.toString(n).toCharArray();
        //start记录从第几位开始后面都是9了。一开始设置最大值是为了防止本身就是递增的
        int start=Integer.MAX_VALUE;
        for (int i=chars.length-1;i>0;i--){
            if (chars[i]<chars[i-1]){
                chars[i-1]--;
                start=i;
            }
        }
        StringBuilder res=new StringBuilder();
        for (int i=0;i<chars.length;i++){
            if (chars[i]=='0'&&i==0)continue;//防止出现09这样的情况
            if (i>=start){//到了start的位置，后面全都搞成9
                res.append('9');
            }else res.append(chars[i]);//在start之前该是啥是啥
        }
        return Integer.parseInt(res.toString());
	}

714. 买卖股票的最佳时机含手续费

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/

	public int maxProfit(int[] prices, int fee) {
		int sum = 0;
		int buy = prices[0] + fee;
		for(int i=0; i<prices.length; i++) {
			if( prices[i] + fee < buy) {//有更低的买入价，更新
				buy = prices[i] + fee;
			} else if(prices[i] > buy) {//如果我现在已经能赚钱了
				sum += prices[i] - buy; //先把肯定能赚到的这一部分加上
				buy = prices[i]; 
				//这样接下来有两种情况
				//1. 如果后面的价格比我卖出的buy高，我依然可以赚到这部分钱
				//2. 如果后面的价格低了，有更低的价格买入价会更新的，我们赚了就跑了，完美
			}
		}
		return sum;
	}

968. 监控二叉树

https://leetcode-cn.com/problems/binary-tree-cameras/

	/*
	 * 2. 该节点无覆盖0（无摄像），本节点有摄像头1，本节点有覆盖2（无摄像）。空结点当做有覆盖
	 * 后序遍历，从下往上，从叶子节点的爹开始安装摄像头
	 */
	
	public int count = 0;//记录摄像头个数
	public int minCameraCover(TreeNode root) {
		if( trval(root) == 0) count++; //如果答案是0，说明就一个根，答案++
		return count;
	}
	private int trval(TreeNode root) {
		// 1. 空节点，该节点有覆盖，返回2
		if (root == null) {
			System.out.println("当前结点为空，返回2");
			return 2;
		}
		//后序遍历树
		int l = trval(root.left);
		int r = trval(root.right);		
		// 2. 左右节点都有覆盖无摄像，那当前点是无覆盖无摄像的
		if (l == 2 && r == 2) {
			System.out.println("当前结点" + root.val + "的左右孩子都为空，返回0");
			return 0;
		}
		// 4. 左右有一个孩子没有覆盖，那就该装个摄像头了
		// 注意第一次错在这了！！！左右有一个是0的优先级很高！！先判断！！！
		if( l == 0 || r == 0) {
			System.out.println("当前结点" + root.val + "的左右孩子有一个是0，返回1");
			count++;
			return 1;
		}
		// 3. 左右有一个有摄像，不用放摄像了，本结点被覆盖了
		if( l == 1 || r == 1) {
			System.out.println("当前结点" + root.val + "的左右孩子有一个是1，返回2");
			return 2;
		}
		
		return -1;//走不到这的
	}
平什么阿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言malloc(n*sizeof(char))解析
weixin_44412982的博客
09-07 1908
基本结构 (char*）malloc(n*sizeof(char)) 举个例子 char *ch = (char*)malloc(sizeof(char)*(2*len+1)); //申请(2*len+1)*1个连续字节的空间，定义*ch，指向该连续空间的首地址(sizeof(char)=1) 上面的2len+1相当于n，然后需要申请啥类型的连续空间只要一一对应即可，如：sizeof(char)对应char，若是需要int型则对应做修改即可。 例如： int *a=(int *)malloc(n*si
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
LeetCode第五题：Longest Palindromic Substring（c++）详解
WangHuanToBeBest
04-21 422
LeetCode：第五题 Longest Palindromic Substring Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000. Example 1: Input: “babad” Output: “bab” N...
实现NFA到DFA的转化（C语言）
zqsen的博客
04-30 7577
简单记录一下，自动机课上的一个实验，用C语言实现NFA到DFA的转化，使用的是子集构造法。 子集构造法相信大家都会，直接甩代码。 先是把NFA和DAF的转移表存储在数据结构里，这里用了二维字符数组，先是定义了一个struct onechar,用来当作转移表的一格，这让我这个程序简单了不少，但是局限性是真的多。所以程序的状态只能使用当个字符表示，且设置的最大状态集数量是20。 typedef struct onechar { char block[MAX_NUM];//用于存储一个20个字符的字符数组 }o
【代码随想录】-贪心专题
一舟的博客
01-18 1081
有一堆钞票，你可以拿走十张，如果想达到最大的金额，你要怎么拿？每次拿最大就是局部最优。做题的时候，只要想清楚 局部最优 是什么，如果推导出全局最优，其实就够了。上述过于理论化，在实际做题中，很难按照上面四部去逐步思考。
【代码随想录】贪心算法专栏（java版本含注释）
码农研究僧的博客
05-05 1371
所谓的贪心算法，就是局部最优到全局最优 关于该算法的学习路线如下： 代码随想录的贪心算法路线
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录知识算法讲解PDF
10-26
代码随想录贪心算法知识，非常管用
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
代码随想录--贪心--分饼干
weixin_56194193的博客
09-13 314
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j]。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
代码随想录：贪心算法
互勉
04-16 296
i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。本题的思路就是从后向前遍历，当遇到前一位大于当前位的时候，让前一位减减，当前位变位9，例如当n=98时，9>8，则9变为8，当前位的8变为9，输出答案89。以上代码中，应注意index的使用，同时也应注意%的特性，一个数%另一个数，如a%b，则得值永远不会大于b，在0-(b-1)区间。
代码随想录——贪心算法
weixin_44479862的博客
09-18 206
代码随想录——贪心算法
跟着代码随想录练算法——贪心（JS）
pingting_的博客
07-26 671
贪心的本质是选择每一阶段的局部最优，从而达到全局最优。
「代码随想录」精讲了18道力扣上贪心算法经典题目，总结了这些！
代码随想录
12-31 1079
> 今天是2020年的最后一天，今天也是贪心系列大总结的一天，那么就用贪心总结篇来准备结束2020年吧
golang 接口
m0_70982551的博客
07-24 927
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 502
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 617
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 581
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

平什么阿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值