【LEETCODE】55、数组分类，适中级别，题目：79、611、950

第950题，这题我是真的没想到居然会说使用队列去做，大神的答案，拿过来瞻仰一下

package y2019.Algorithm.array;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName Exist
 * @Description TODO 79. Word Search
 *
 * Given a 2D board and a word, find if the word exists in the grid.
 * The word can be constructed from letters of sequentially adjacent cell,
 * where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.
 *
 * board =
 * [
 *   ['A','B','C','E'],
 *   ['S','F','C','S'],
 *   ['A','D','E','E']
 * ]
 * Given word = "ABCCED", return true.
 * Given word = "SEE", return true.
 * Given word = "ABCB", return false.
 *
 * 给定一个二维网格和一个单词，找出该单词是否存在于网格中。
 * 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/word-search
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 *
 * @Author xiaof
 * @Date 2019/7/14 22:50
 * @Version 1.0
 **/
public class Exist {

    public boolean solution(char[][] board, String word) {
        //1.遍遍历Word，对字符进行遍历，并对字符位置进行比较
        //遍历word
        char[] w = word.toCharArray();
        for (int y=0; y<board.length; y++) {
            for (int x=0; x<board[y].length; x++) {
                if (exist1(board, y, x, w, 0)) return true;
            }
        }

        return false;
    }

    //i当前查看位置,然后把之前比遍历过的位置去掉，然后这里是对每个字符位置进行按位置异或操作,对256异或，其实就是取反
    private boolean exist1(char[][] board, int y, int x, char[] word, int i) {
        if(i == word.length) return true;
        //如果深度满足，然后，x,y不能
        if(y < 0 || x < 0 || y == board.length || x == board[y].length) return false;
        if(board[y][x] != word[i]) return false;
        //匹配成功,修改当前位置标记
        board[y][x] = (char) ~board[y][x];

        //继续向其他四个方向探索
        boolean exist = exist1(board, y, x - 1, word, i + 1)
                    || exist1(board, y, x + 1, word, i + 1)
                    || exist1(board, y - 1, x, word, i + 1)
                    || exist1(board, y + 1, x, word, i + 1);
        //不断向四个方向探索，只要有一个方向探索成功，继续往下递归
        board[y][x] = (char) ~board[y][x]; //还原
        return exist;

    }

}

package y2019.Algorithm.array;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName TriangleNumber
 * @Description TODO 611. Valid Triangle Number
 * Given an array consists of non-negative integers,
 * your task is to count the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.
 *
 * Input: [2,2,3,4]
 * Output: 3
 * Explanation:
 * Valid combinations are:
 * 2,3,4 (using the first 2)
 * 2,3,4 (using the second 2)
 * 2,2,3
 *
 * 给定一个包含非负整数的数组，你的任务是统计其中可以组成三角形三条边的三元组个数。
 *
 * @Author xiaof
 * @Date 2019/7/14 23:38
 * @Version 1.0
 **/
public class TriangleNumber {

    public int solution(int[] nums) {
        //1.首先对数组排序
        quikSort(nums, 0, nums.length);
//        Arrays.sort(nums);
        //2.首先取三边的最大边
        int count = 0;
        for(int i = nums.length - 1; i >= 2; --i) {
            int b1 = 0, b2 = i - 1, b3 = nums[i];
            //3.然后排除最大边和右边的数据，在最大边左边取2条边比较，两边之和大于第三边
            while(b1 < b2) {
                //避免第一，第二个边取值错位
                if(nums[b1] + nums[b2] > b3) {
                    //两边之和大于第三边
                    count += b2 - b1; //可以获取的个数是第二个和第一个边的位置距离，因为左边最小的加上也比第三条边大，那么说明中间所有数据和都比三大
                    //缓缓减少一遍大小
                    b2--;
                } else {
                    //如果不满住两边之和大于第三边，那么就增加大小
                    b1++;
                }
            }
        }
        return count;
    }

    private void quikSort(int[] nums, int begin, int end) {
        if(begin < end) {
            int midSite = midSite(nums, begin, end);
            quikSort(nums, begin, midSite);
            quikSort(nums, midSite + 1, end);
        }
    }

    private int midSite(int[] nums, int left, int right) {
        if(left >= right) {
            return nums[left];
        }

        //这个位置是为了取出中位数的位置，并把两边的顺序分开
        int midValue = nums[left], l1 = left, r1 = right;

        do {

            //遍历左边比他小的,因为这里是do-while，那么会先++，排除掉第0位
            do { ++ l1; } while(l1 < right && nums[l1] < midValue);

            do { --r1; } while (left < r1 && nums[r1] > midValue);

            if(l1 < r1) {
                //交换
                int temp = nums[l1];
                nums[l1] = nums[r1];
                nums[r1] = temp;
            }

        } while(l1 < r1);

        //最后把第一个位置的数据，交换到中间位置
        nums[left] = nums[r1];
        nums[r1] = midValue;

        return r1;
    }

    public static void main(String[] args) {
        int data[] = {10,20,11,30,5,40};
        int data1[] ={2,2,3,4};
        int data2[] = {82,15,23,82,67,0,3,92,11};
        TriangleNumber fuc = new TriangleNumber();
        fuc.quikSort(data2, 0, data2.length);
//        System.out.println(fuc.solution(data2));
        System.out.println(data);
    }

}

package y2019.Algorithm.array.medium;

import y2019.Algorithm.array.TriangleNumber;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.array.medium
 * @ClassName: DeckRevealedIncreasing
 * @Author: xiaof
 * @Description: TODO 950. Reveal Cards In Increasing Order
 * In a deck of cards, every card has a unique integer.  You can order the deck in any order you want.
 * Initially, all the cards start face down (unrevealed) in one deck.
 * Now, you do the following steps repeatedly, until all cards are revealed:
 * Take the top card of the deck, reveal it, and take it out of the deck.
 * If there are still cards in the deck, put the next top card of the deck at the bottom of the deck.
 * If there are still unrevealed cards, go back to step 1.  Otherwise, stop.
 * Return an ordering of the deck that would reveal the cards in increasing order.
 * The first entry in the answer is considered to be the top of the deck.
 *
 * Input: [17,13,11,2,3,5,7]
 * Output: [2,13,3,11,5,17,7]
 * Explanation:
 * We get the deck in the order [17,13,11,2,3,5,7] (this order doesn't matter), and reorder it.
 * After reordering, the deck starts as [2,13,3,11,5,17,7], where 2 is the top of the deck.
 * We reveal 2, and move 13 to the bottom.  The deck is now [3,11,5,17,7,13].
 * We reveal 3, and move 11 to the bottom.  The deck is now [5,17,7,13,11].
 * We reveal 5, and move 17 to the bottom.  The deck is now [7,13,11,17].
 * We reveal 7, and move 13 to the bottom.  The deck is now [11,17,13].
 * We reveal 11, and move 17 to the bottom.  The deck is now [13,17].
 * We reveal 13, and move 17 to the bottom.  The deck is now [17].
 * We reveal 17.
 * Since all the cards revealed are in increasing order, the answer is correct.
 *
 * 牌组中的每张卡牌都对应有一个唯一的整数。你可以按你想要的顺序对这套卡片进行排序。
 * 最初，这些卡牌在牌组里是正面朝下的（即，未显示状态）。
 * 现在，重复执行以下步骤，直到显示所有卡牌为止：
 * 从牌组顶部抽一张牌，显示它，然后将其从牌组中移出。
 * 如果牌组中仍有牌，则将下一张处于牌组顶部的牌放在牌组的底部。
 * 如果仍有未显示的牌，那么返回步骤 1。否则，停止行动。
 * 返回能以递增顺序显示卡牌的牌组顺序。
 * 答案中的第一张牌被认为处于牌堆顶部。
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/reveal-cards-in-increasing-order
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 *
 * @Date: 2019/7/15 10:27
 * @Version: 1.0
 */
public class DeckRevealedIncreasing {

    public int[] solution(int[] deck) {
        //也就是要把数组中的数据间隔按照依次增大的顺序排列，然后把剩余间隔的按照递减的顺序，最后一个放最大值
        Arrays.sort(deck);

        //如果长度是奇数，那么倒数第二位放最大，前面按照递减，如果是偶数，那么从最后往前奇数位递减
        //偶数位放递增，奇数位放递减
        int[] res = new int[deck.length];
        if(deck.length % 2 == 0) {
            //如果是偶数
            for(int i = 0, j = 0, k = deck.length - 1; i < deck.length; i += 2) {
                res[i] = deck[j++];
                res[deck.length - i - 1] = deck[k--];
            }
        } else {
            //如果是奇数
            if(deck.length > 2)
                res[deck.length - 2] = deck[deck.length - 1];
            for(int i = 0, j = 0, k = deck.length - 2; i < deck.length; i += 2) {
                res[i] = deck[j++];
                if(i + 1 < deck.length && i != deck.length - 3)
                    res[i + 1] = deck[k--];
            }
        }

        return res;
    }

    /**
     *
     * @program: y2019.Algorithm.array.medium.DeckRevealedIncreasing
     * @description: 答案来源：https://leetcode.com/problems/reveal-cards-in-increasing-order/discuss/200526/Java-Queue-Simulation-Step-by-Step-Explanation
     */
    public int[] solution2(int[] deck) {
        int n= deck.length;
        Arrays.sort(deck);
        Queue<Integer> q= new LinkedList<>();
        //排序号入队
        for (int i=0; i<n; i++) q.add(i);
        int[] res= new int[n];
        for (int i=0; i<n; i++){
            //先进后出的队列数据，从小取到大为对应的值
            res[q.poll()]=deck[i];
            //连续出队，这样间隔的数据放到队列尾部，后面取出来的时候，重新是间隔的从小到大的位置
            q.add(q.poll());
        }
        return res;
    }

    public static void main(String[] args) {
        int data[] = {17,13,11,2,3,5,7};
        int data1[] = {1,2,3,4,5,6};
        DeckRevealedIncreasing fuc = new DeckRevealedIncreasing();
        System.out.println(fuc.solution2(data1));
        System.out.println();
    }

}