贪心算法

一、概念

贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。

它省去了为找最优解要穷尽所有可能而必须耗费的大量时间，它采用自顶向下，以迭代的方法做出相继的贪心选择，每做一次贪心选择就将所求问题简化为一个规模更小的子问题，通过每一步贪心选择，可得到问题的一个最优解，虽然每一步上都要保证能获得局部最优解，但由此产生的全局解有时不一定是最优的

对于一个给定的问题，往往可能有好几种量度标准。初看起来，这些量度标准似乎都是可取的，但实际上，用其中的大多数量度标准作贪婪处理所得到该量度意义下的最优解并不是问题的最优解，而是次优解。因此，选择能产生问题最优解的最优量度标准是使用贪婪算法的核心。

二、经典例题

• 分糖果问题
  已知一些孩子和一些糖果，每个孩子有需求因子g，每个糖果有大小s，当某个糖果的大小s>=某个孩子的需求因子g时，代表该糖果可以满足该孩子，求使用这些糖果，最多能满足多少孩子（注意，某个孩子最多只能用1个糖果满足）

此题应该是一道很简单的贪心算法题，若要使糖果满足的孩子数量较多，则应该使孩子分得的糖果满足其需求并且大小为最小。即满足其需求的最小糖果。

• 摆动序列
  一个整数序列，如果两个相邻元素的差恰好正负(负正)交替出现，则该序列呗成为摇摆序列，一个小于2个元素的序列直接为摇摆序列，给一个随机序列，求这个序列满足摇摆序列定义的最长子序列的长度。
  例如：
  序列[1,7,4,9,2,5],相邻元素的差(6,-3,5,-7,3),该序列为摇摆序列
  序列[1,4,7,2,5]相差(3,3,-5,3)不是摇摆序列

我们从左至右一次遍历数组，当满足摇摆数组的条件时，使序列长度+1，当出现递归或递减时，为了使后续的值更容易满足条件，我们需要获取递增数字中的最大值，或是递减数字中的最小值

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums.length <= 1){
            return nums.length;
        }
        int flag = 0;
        boolean auth = true;
        int n = 1;
        for (int i = 0; i < nums.length-1; i++) {
            if (auth && nums[i + 1] - nums[i] != 0) {
                flag = nums[i + 1] - nums[i] > 0 ? 1 : -1;
                auth = false;
            }
            if ((nums[i + 1]-nums[i])*flag >0  ) {
                n++;
                flag *= -1;
                continue;
            } else if ((nums[i + 1] - nums[i]) * flag < 0) {
                /**
                 * 当出现递增或递减时，使当前的值为最大或最小
                 */
                nums[i] = flag > 0 ? Math.max(nums[i], nums[i + 1]) : Math.min(nums[i], nums[i + 1]);
            }
        }
        return n;
    }

• 移除k个数字
  已知一个使用字符串表示非负整数num，将num中的k个数字移除，求移除k个数字后，可以获得的最小的可能的新数字(num不会以0开头，num长度小于10002)

例如：输入：num = “1432219”,k=3
在去掉3个数字后得到的很多可能里，如1432，4322，2219，1219。。。。；去掉数字4、3、2、得到的1219最小
该题最简单的解法即是利用单调栈，其核心算法也是贪心

class Solution {
    public String removeKdigits(String num, int k) {
        // 时间复杂度O(n)
        public String removeKdigits2 (String num,int k){
            if (k >= num.length()) {
                return "0";
            }
            // 应该在前面算，因为后面k变了
            int newLen = num.length() - k;
            // 创建一个栈，用于接收所有的数字
            char[] stack = new char[num.length()];
            // 始终指向栈顶上一个元素
            int top = 0;
            for (int i = 0; i < num.length(); ++i) {
                // 遍历当前数字
                char c = num.charAt(i);
                // 当栈顶数字大于遍历到的当前数字，栈顶数字出栈（相当于删除数字）
                while (top > 0 && stack[top - 1] > c && k > 0) {
                    top -= 1;
                    k -= 1;
                }
                // 遍历到的当前数字入栈
                stack[top++] = c;
            }

            // 找到栈中第一个非零数字的位置，以此构建新的整数字符串
            int offset = 0;
            while (offset < newLen && stack[offset] == '0') {
                offset++;
            }
            return offset == newLen ? "0" : new String(stack, offset, newLen
                    - offset);
        }
    }
}

• 马踏棋盘
  国际象棋的棋盘为8*8的方格棋盘。现将”马”放在任意指定的方格中，按照”马”走棋的规则将”马”进行移动(如图所示，如果将空格标成点，就是象棋中的马走“日”字)。要求每个方格只能进入一次，最终使得”马 ”走遍棋盘的64个方格。如图所示，任意一个位置，“马”最多有8个方向可以跳动，所以每次都要依据这最多8个方向进行选择。
  
  

  image

这里我们采用贪心对深搜算法进行优化
我们知道，当下一步的可选择数为0的时候，进行回溯。当下一步的可选择数有1个的时候，我们直接取那一步就行了。但是如果下一步的可选择数有多个的时候呢？单纯使用回溯法的时候，我们是任意取一个的，只要它在棋盘内，且未遍历就可以了。

但其实我们怎么选下一步，对搜索的效率影响是非常大的！
当我们选择下一步的时候，根据我们自己设的贪心策略，应该选择下一点的下一步可走步数最少的点，因为这样，可以使我们后期回溯的时候，回溯的深度更浅，从而减少时间复杂度

/**
 * @author zmrwego
 * @descreption 马踏棋盘问题
 * @create 2018-12-21
 **/

public class Chess {
    //声明棋盘大小
    static int n = 20;
    //直接声明一个棋盘，初始化为0
    static int[][] chess = new int[n][n];
    static int times = 0;
    static int[] moveX = {1, 2, 1, 2, -1, -2, -1, -2};
    static int[] moveY = {2, 1, -2, -1, 2, 1, -2, -1};

    //使用回溯法进行踏马
    public static void runHorse(int[][] chess, int x, int y) {
        chess[x][y] = 1;
        int direction = 8;
        int c = 0;
        int d = 0;
        Map map = new HashMap<>();
        times++;
        System.out.println(":第" + times + "步,马(" + x + "," + y + ")->");
        for (int i = 0; i < moveX.length; i++) {

            int a = x + moveX[i];
            int b = y + moveY[i];
            int n = availableN(chess, a, b);
            if (i + 1 < 8) {
                c = x + moveX[i + 1];
                d = moveY[i + 1] + y;
            }
            if (n == 0 ) {
                if (!(c < 0 || c > n - 1 || d < 0 || d > n - 1))
                runHorse(chess, c, d);
            } else {
//            System.out.println(n);
                int available = n;
                if (available <= direction && chess[a][b] == 0) {
                    map.put(available, i);
                    direction = available;
                }
            }

        }
        System.out.println(direction);
        try {
            int a = x + moveX[map.get(direction)];
            int b = y + moveY[map.get(direction)];
            if (a >= 0 && a <= n - 1 && b >= 0 && b <= n - 1) {
                runHorse(chess, a, b);
            }
        } catch (Exception e) {
            System.out.println(e);
        }

    }

    public static void show(int[][] chess) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(chess[i][j] + "");
            }
            System.out.println();
        }
    }

    /**
     * 获取下一节点可走的方向
     *
     * @param chess
     * @param x
     * @param y
     * @return
     */
    public static int availableN(int[][] chess, int x, int y) {
        int direction = 0;
        if (x < 0 || x > n - 1 || y < 0 || y > n - 1) {
            return 0;
        }
        for (int i = 0; i < moveX.length; i++) {
            int a = x + moveX[i];
            int b = y + moveY[i];
            if (a >= 0 && a <= n - 1 && b >= 0 && b <= n - 1 && chess[a][b] == 0) {
                direction++;
            }
        }
        return direction;

    }

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        runHorse(chess, 0, 0);
        System.out.println(System.currentTimeMillis() - start + "ms");
        show(chess);
    }
}