第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(); } }