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