1.最佳支付方法
有1元、5元、10元、20元、100元、200元的钞票无穷多张。现使用这些钞票支付X元，最少需要多少张。
例如，X=628，最佳支付方法：3张200的，1张20的，3张1块的，共需要3+1+1+3=8张。
这里给出的钱金额：1，5，10，20，100是成倍数关系的，所以当使用一张较大面额的钞票时，若用较小面额钞票替换，一定需要更多的其他面额的钞票，所以尽可能使用面额较大的钞票，所以可以用贪心算法。
代码实现：
public class TanXin {
public static void main(String[] args)
{
int[] a = {200,100,20,10,5,1};
int X = 628;
int count = 0;
for(int i=0;i<a.length;i++){
if(a[i]<=X){
count+=X/a[i];
X = X%a[i];
}
}
System.out.println("count: "+count);
}
}说明：这里能使用贪心的条件是，给出的面额成倍数，如果给出的面额不是成倍数，就不一定能使用贪心算法，举例如果给出钱金额：1，10，求组合达到金额为14的最少组合方法，这时候使用贪心算法就无能为力了，因为14=10+1+1+1+1,e而显然最优解是14=7+7。
2.分糖果问题
已知一些小孩和一些糖果，每个孩子有需求因子g,每个糖果有大小s,当某个糖果的大小s>=某个孩子的需求因子g时，代表该糖果可以满足该孩子，求使用这些糖果，最多能满足多少孩子？（注意某个孩子只能用一个糖果满足）
例如，需求因子数组g=[5,10,2,9,15,9]；糖果大小数组s=[6,1,20,3,8]，最多可以满足3个孩子。
思路：典型的贪心思想，最大的糖果满足需求因子最大的学生，次大的糖果满足次大需求的学生。先将需求因子数组和糖果大小数组都排序，得到s=[1,3,6,8,20],需求因子g=[2,5,9,910,15]，如果最小的糖果能满足最小的需求因子，就将最小的糖果给最小的需求因子，例中的1无法满足需求因子2，所以试着将次小的糖果给最小的需求因子，仍然无法满足，然后将第三小的糖果给最小的需求因子，此时可以满足，然后将第四小的糖果给第二小的需求因子，依此下去。
代码实现：
class TanXin
{
public static void main(String[] args)
{
int[] g = {5,10,2,9,15,9};
int[] s = {6,1,20,3,8};
Arrays.sort(g);
Arrays.sort(s);
int i = 0;
int j = 0;
int count = 0;
while(i<g.length&&j<s.length)
{
if(s[j]>=g[i])
{
j++;
i++;
count++;
}
else
{
j++;
}
}
System.out.println("满足的小朋友个数: "+count);
}
}3.摇摆序列
一个整数序列，如果两个相邻元素的查恰好正负（负正）交替出现，则该序列被称为摇摆序列。
例如：序列[1,7,4,9,2,5]，相邻元素的差(6,-3,5,-7,3)，该序列为摇摆序列。
理解思路，写并不好写，这里使用状态机做，但是基本思想是简单的，如果一组数字是递增的，那么就选取这组数字中最大的一个，如果一组数字是单调递减的，那么就选取这组数字中最小的那个，这里体现了贪心的思想。
4.移除k个数字
已知一个字符串表示的非负整数num，num中的k个数字移除，求移除k个数字后，可以获得的最小的可能的新数字。(num不会以0开头，num长度小于10002)。
举例：输入num=”1432219″,k=3,去掉3个数字后，得到的最小的数字是1219。
思考：让得到的数字最小，需要尽可能让得到的新数字优先最高位最小，其次次高位最小，再一次高位最小。例如输入num是1432219，此时可以使用栈存储最终的结果或删除工作，从高位向低位遍历num，如果遍历的数字大于栈顶元素，则将该数字push入栈，如果小于栈顶元素则进行pop弹栈，直到栈为空，或者不能再删除数字(k==0)或栈顶小于当前元素为止。
第一种特殊情况：一种特殊情况是在栈为空的时候，进去的为0，例如数字是num=100200，此时先取出1，1进入栈，但是第二个0的时候，此时1出栈，但0不能进栈，因为此时栈内为空。
第二种特殊情况：数字是单调递增的时候，例如12345678，此时在入栈完成后，检查栈的大小，如果栈的size()大于原先的字符串中的数字的长度减去2，此时要做处理，直接删除最后的两个数字。
代码实现：
class TanXin
{
public static void main(String[] args)
{
//测试用例
//String num = "1432219";
//String num = "12345678";
//String num = "1002345";
//String num = "100200";
String num = "123411";
int k = 2;
Stack<Integer> al = new Stack<>();
for(int i=0;i<num.length();i++)
{
int number = num.charAt(i) - '0';
while(al.size()!=0&&al.peek()>number&&k>0) //如果进入一个小于栈顶数的数字
{
al.pop();
k--;
}
if(number!=0||al.size()!=0) //栈为空的时候不能进去值为0
{
al.push(number);
}
}
//如果是顺序的那么把最后的k位数字删除
while(al.size()>0&&k>0)
{
al.pop();
k--;
}
//打印最终结果，因为栈实现了Iterator接口，所以可以使用for each语句
System.out.println(al.toString());
for(int c:al)
{
{
System.out.print(c+" ");
}
}
}
说明：最终的栈的输出要从栈底输出，因为栈实现了Iterator接口，所以这里用for each语句最为方便，否则从栈顶出栈后，还要颠倒一次顺序。
代码实现：
第二种特殊情况：进入一个单调递增的数，此时
5.跳跃游戏
一个数组存储了非负整型数据，数组中第i个元素nums[i]，代表了可以从数组第i个位置最多向前跳跃nums[i]步，已知数组各元素的情况下，求是否可以从数组第0个位置跳跃到数组的最后一个元素的位置。
跳跃游戏有两种问题：一种问能不能从第0个位置跳跃到数组的最后一个元素的位置，另一个中是从第0个位置跳跃到数组最后一个位置，最少需要跳跃多少步。
思路：例如：nums = [2,3,1,1,4]，从第0个位置(2)可以跳至第一个位置(3)和第二个位置(1)，从第一个位置(3)又可以跳至第二(1)、第三(1)、第四个位置(4),从第二个位置(1)又可以跳至第三个位置，所以从第0个位置是跳到第一个位置还是跳到第二个位置呢？此时选择跳到该位置后能够继续跳到的更远的位置。例如跳到第一个位置后最远能跳到第4个位置，而跳到第二个位置后最远能跳到第三个位置，所以我们就选择从第0个位置，跳到第1个位置，这也是典型的一种贪心思想。
如果不能到达的情况，例如nums=[3,2,1,0,4]，此时不能达到，那么这该怎么判断呢？可以继续使用上面的办法，这时会出现在第3个位置（值为0）的地方停止，此时发现走一步后在原地，且该位置不是最终位置，说明停滞在该位置，说明无法到达最后位置了，代码描述：nums[i]+i==i&&i!=nums.length-1。
class TanXin
{
public static void main(String[] args)
{
//int[] nums = {2,3,1,1,4};
int[] nums = {3,2,1,0,4};
//int[] nums = {3,2,1,0};
int count = 0;
int i = 0;
boolean flag = true;
while(count<nums.length&&(i+nums[i]<=nums.length-1)){ //防止到达不到停死在那，和已经走过两种情况
if(nums[i]+i==i&&i!=nums.length-1){ //如果停滞在那边，就说明无法到达
flag = false;
break;
}
if(nums[i]+i==nums.length-1){ //如果下一步能到达，那么加一后退出
count++;
break;
}
int k = i + nums[i];
int maxReach=0;
int j;
int save = 0; //这一个保存变量很重要,记录上次到达的位置
for(j=i+1;j<=k;j++){
if(maxReach<=(nums[j]+j)) //这边的等于号必须加,{3,2,1,0,4}
{
System.out.println("maxReach: "+maxReach+"nums[j]+j: "+(nums[j]+j));
save = j;
maxReach = nums[j]+j;
}
}
i = save;
System.out.println("i: "+i);
count++;
}
System.out.println("count: "+count);
if(flag==false){
System.out.println("无法到达");
}
else
System.out.println("经过"+count+"步后到达");
}
}6.射气球问题
已知在一个平面上有一定数量的气球，平面可以看作是一个坐标系，在平面的x轴的不同位置安排弓箭手向y轴方向射箭，弓箭可以向y轴走无穷远，给定气球的宽度xstart<=x<=xend，问至少需要多少弓箭手，将全部气球 打爆？
例如：四个气球：[[10,16],[2,8],[1,6],[7,12]]，至少需要2个弓箭手。
分析：对于某个气球，至少需要使用1只弓箭将它击穿，在这只气球将其击穿的同时，尽可能击穿其他更多的气球。（这里体现了贪心的思想）。做法：使用一个类Node代表一个气球，类中的first代表的气球的左坐标，类中的second代表气球的右坐标，对各个气球（即Node类）进行排序，按照气球的左端点从小到大排序（即按照Node类的first属性排序），遍历气球数组，同时维护一个射击区间（通过两个变量[shoot_begin，shoot_end]），在满足就将当前气球射穿的情况下，尽可能击穿更多的气球，每击穿一个新的气球，更新一次射击区间。具体的更新方法：如果下一个first属性大于上一个的first属性，那么shoot_beign更新，如果下一个second属性下雨上一个的second属性，那么更新。
代码实现：
class Node implements Comparable<Node>
{
int first;
int second;
public Node(int first,int second)
{
this.first = first;
this.second = second;
}
@Override
public int compareTo(Node o) {
// TODO Auto-generated method stub
return first-o.first;
}
}
class TanXin
{
public static void main(String[] args)
{
Node n1 = new Node(10,16);
Node n2 = new Node(2,8);
Node n3 = new Node(1,6);
Node n4 = new Node(7,12);
ArrayList<Node> al = new ArrayList<>();
al.add(n1);
al.add(n2);
al.add(n3);
al.add(n4);
Collections.sort(al); //排序，等会总结一下排序
// for(Node n:al)
// {
// System.out.println(n.first+" "+n.second);
// }
int shoot_num = 1;
int shoot_begin = n1.first;
int shoot_end = n1.second;
for(int i=1;i<al.size();i++)
{
if(al.get(i).first<=shoot_end)
{
shoot_begin = al.get(i).first; //因为已经排序过了，所以直接赋值
if(shoot_end>al.get(i).second) //跟新设计区间的右坐标
{
shoot_end = al.get(i).second;
}
}
else
{
shoot_num++;
shoot_begin = al.get(i).first; //更新射击区间
shoot_end = al.get(i).second;
}
}
System.out.println("shootNum: "+shoot_num);
}
}
