給你兩個按 非遞減順序 排列的整數(shù)數(shù)組 nums1 和 nums2，另有兩個整數(shù) m 和 n ，分別表示 nums1 和 nums2 中的元素數(shù)目。

請你 合并 nums2 到 nums1 中，使合并后的數(shù)組同樣按 非遞減順序 排列。

**注意：**最終，合并后數(shù)組不應由函數(shù)返回，而是存儲在數(shù)組 nums1 中。為了應對這種情況，nums1 的初始長度為 m + n，其中前 m 個元素表示應合并的元素，后 n 個元素為 0 ，應忽略。nums2 的長度為 n 。

示例 1：

輸入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
輸出：[1,2,2,3,5,6]
解釋：需要合并 [1,2,3] 和 [2,5,6] 。
合并結果是 [1,2,2,3,5,6] ，其中斜體加粗標注的為 nums1 中的元素。

示例 2：

輸入：nums1 = [1], m = 1, nums2 = [], n = 0
輸出：[1]
解釋：需要合并 [1] 和 [] 。
合并結果是 [1] 。

示例 3：

輸入：nums1 = [0], m = 0, nums2 = [1], n = 1
輸出：[1]
解釋：需要合并的數(shù)組是 [] 和 [1] 。
合并結果是 [1] 。
注意，因為 m = 0 ，所以 nums1 中沒有元素。nums1 中僅存的 0 僅僅是為了確保合并結果可以順利存放到 nums1 中。

提示：

• nums1.length == m + n
• nums2.length == n
• 0 <= m, n <= 200
• 1 <= m + n <= 200
• -109 <= nums1[i], nums2[j] <= 109

**進階：**你可以設計實現(xiàn)一個時間復雜度為 O(m + n) 的算法解決此問題嗎？

import org.junit.Test;import java.util.Arrays;
import java.util.Scanner;public class Merge {public void merge(int[] nums1, int m, int[] nums2, int n) {// 從后向前遍歷int pos1 = m-1;int post2 = n-1;int pos = nums1.length-1;while (pos1 >= 0 && post2 >= 0) {if(nums1[pos1] > nums2[post2]){nums1[pos--] = nums1[pos1--];}else{nums1[pos--] = nums2[post2--];}}while (post2 >= 0) {nums1[pos--] = nums2[post2--];}for (int i = 0; i < nums1.length; i++) {System.out.println(nums1[i]+" ");}}public static void main(String[] args) {Merge merge = new Merge();Scanner scanner = new Scanner(System.in);System.out.println("======請輸入n的val======");int n = scanner.nextInt();System.out.println("======請輸入m的val======");int m = scanner.nextInt();int[] nums1 = new int[n+m];int[] nums2 = new int[m];System.out.println("======請輸入nums1[]的元素======");for(int i=0;i<n;i++){nums1[i] = scanner.nextInt();}System.out.println("======請輸入nums2[]的元素======");for(int i=0;i<m;i++){nums2[i] = scanner.nextInt();}merge.merge(nums1,n,nums2,m);}}

給你一個數(shù)組 nums 和一個值 val，你需要 原地 移除所有數(shù)值等于 val 的元素。元素的順序可能發(fā)生改變。然后返回 nums 中與 val 不同的元素的數(shù)量。

假設 nums 中不等于 val 的元素數(shù)量為 k，要通過此題，您需要執(zhí)行以下操作：

• 更改 nums 數(shù)組，使 nums 的前 k 個元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
• 返回 k。

用戶評測：

評測機將使用以下代碼測試您的解決方案：

int[] nums = [...]; // 輸入數(shù)組
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 長度正確的預期答案。// 它以不等于 val 的值排序。int k = removeElement(nums, val); // 調用你的實現(xiàn)assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 個元素
for (int i = 0; i < actualLength; i++) {assert nums[i] == expectedNums[i];
}

如果所有的斷言都通過，你的解決方案將會 通過。

示例 1：

輸入：nums = [3,2,2,3], val = 3
輸出：2, nums = [2,2,_,_]
解釋：你的函數(shù)函數(shù)應該返回 k = 2, 并且 nums 中的前兩個元素均為 2。
你在返回的 k 個元素之外留下了什么并不重要（因此它們并不計入評測）。

示例 2：

輸入：nums = [0,1,2,2,3,0,4,2], val = 2
輸出：5, nums = [0,1,4,0,3,_,_,_]
解釋：你的函數(shù)應該返回 k = 5，并且 nums 中的前五個元素為 0,0,1,3,4。
注意這五個元素可以任意順序返回。
你在返回的 k 個元素之外留下了什么并不重要（因此它們并不計入評測）。

提示：

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

import java.util.Arrays;
import java.util.Scanner;public class Remove {public int removeElement(int[] nums, int val) {// 首先排序Arrays.sort(nums);int left = 0,right = 0;while(right < nums.length) {if(nums[right] == val){right++;continue;}nums[left++] = nums[right++];}return left;}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("======請輸入數(shù)組長度======");int len = scanner.nextInt();System.out.println("======請輸入要移除的值======");int val = scanner.nextInt();System.out.println("======請輸入數(shù)組元素======");int[] nums = new int[len];for(int i=0;i<len;i++){nums[i] = scanner.nextInt();}Remove remove = new Remove();int length = remove.removeElement(nums, val);System.out.println("======答案======");for(int i=0;i<length;i++){System.out.println(nums[i]);}}
}

給你一個 非嚴格遞增排列 的數(shù)組 nums ，請你** 原地** 刪除重復出現(xiàn)的元素，使每個元素 只出現(xiàn)一次 ，返回刪除后數(shù)組的新長度。元素的 相對順序 應該保持 一致 。然后返回 nums 中唯一元素的個數(shù)。

考慮 nums 的唯一元素的數(shù)量為 k ，你需要做以下事情確保你的題解可以被通過：

• 更改數(shù)組 nums ，使 nums 的前 k 個元素包含唯一元素，并按照它們最初在 nums 中出現(xiàn)的順序排列。nums 的其余元素與 nums 的大小不重要。
• 返回 k 。

判題標準:

系統(tǒng)會用下面的代碼來測試你的題解:

int[] nums = [...]; // 輸入數(shù)組
int[] expectedNums = [...]; // 長度正確的期望答案int k = removeDuplicates(nums); // 調用assert k == expectedNums.length;
for (int i = 0; i < k; i++) {assert nums[i] == expectedNums[i];
}

如果所有斷言都通過，那么您的題解將被 通過。

示例 1：

輸入：nums = [1,1,2]
輸出：2, nums = [1,2,_]
解釋：函數(shù)應該返回新的長度 2 ，并且原數(shù)組 nums 的前兩個元素被修改為 1, 2 。不需要考慮數(shù)組中超出新長度后面的元素。

示例 2：

輸入：nums = [0,0,1,1,1,2,2,3,3,4]
輸出：5, nums = [0,1,2,3,4]
解釋：函數(shù)應該返回新的長度 5 ， 并且原數(shù)組 nums 的前五個元素被修改為 0, 1, 2, 3, 4 。不需要考慮數(shù)組中超出新長度后面的元素。

提示：

• 1 <= nums.length <= 3 * 104
• -104 <= nums[i] <= 104
• nums 已按 非嚴格遞增 排列

public class removeDuplicates {public int removeDuplicates(int[] nums) {int left = 1;int right = 1;while(right<nums.length){if(nums[right] != nums[right-1]){nums[left++] = nums[right];}right++;}return left;}public static void main(String[] args) {int[] nums = new int[]{1,1,1,1,1,2,3,4,5,5,5,5,6,6,6,6,6,6,6};removeDuplicates removeDuplicates = new removeDuplicates();int len = removeDuplicates.removeDuplicates(nums);for(int i=0; i<len; i++){System.out.print(nums[i]+" ");}}
}

給你一個有序數(shù)組 nums ，請你** 原地** 刪除重復出現(xiàn)的元素，使得出現(xiàn)次數(shù)超過兩次的元素只出現(xiàn)兩次 ，返回刪除后數(shù)組的新長度。

不要使用額外的數(shù)組空間，你必須在 原地 修改輸入數(shù)組 并在使用 O(1) 額外空間的條件下完成。

說明：

為什么返回數(shù)值是整數(shù)，但輸出的答案是數(shù)組呢？

請注意，輸入數(shù)組是以**「引用」**方式傳遞的，這意味著在函數(shù)里修改輸入數(shù)組對于調用者是可見的。

你可以想象內部操作如下:

// nums 是以“引用”方式傳遞的。也就是說，不對實參做任何拷貝
int len = removeDuplicates(nums);// 在函數(shù)里修改輸入數(shù)組對于調用者是可見的。
// 根據(jù)你的函數(shù)返回的長度, 它會打印出數(shù)組中 該長度范圍內 的所有元素。
for (int i = 0; i < len; i++) {print(nums[i]);
}

示例 1：

輸入：nums = [1,1,1,2,2,3]
輸出：5, nums = [1,1,2,2,3]
解釋：函數(shù)應返回新長度 length = 5, 并且原數(shù)組的前五個元素被修改為 1, 1, 2, 2, 3。 不需要考慮數(shù)組中超出新長度后面的元素。

示例 2：

輸入：nums = [0,0,1,1,1,1,2,3,3]
輸出：7, nums = [0,0,1,1,2,3,3]
解釋：函數(shù)應返回新長度 length = 7, 并且原數(shù)組的前七個元素被修改為 0, 0, 1, 1, 2, 3, 3。不需要考慮數(shù)組中超出新長度后面的元素。

提示：

• 1 <= nums.length <= 3 * 104
• -104 <= nums[i] <= 104
• nums 已按升序排列

public class removeDuplicates {public int removeDuplicates(int[] nums) {int left = 2;int right = 2;while(right<nums.length){if(nums[right]!=nums[left-2]){nums[left++] = nums[right];}right++;}return left;}public static void main(String[] args) {int[] nums = new int[]{1,2,3,3,3,4,5,6};removeDuplicates removeDuplicates = new removeDuplicates();int len = removeDuplicates.removeDuplicates(nums);for(int i=0; i<len; i++){System.out.print(nums[i]+" ");}}
}

給定一個大小為 n 的數(shù)組 nums ，返回其中的多數(shù)元素。多數(shù)元素是指在數(shù)組中出現(xiàn)次數(shù) 大于 ? n/2 ? 的元素。

你可以假設數(shù)組是非空的，并且給定的數(shù)組總是存在多數(shù)元素。

示例 1：

輸入：nums = [3,2,3]
輸出：3

示例 2：

輸入：nums = [2,2,1,1,1,2,2]
輸出：2

提示：

• n == nums.length
• 1 <= n <= 5 * 104
• -109 <= nums[i] <= 109

**進階：**嘗試設計時間復雜度為 O(n)、空間復雜度為 O(1) 的算法解決此問題。

public class MostNumber {public int majorityElement(int[] nums) {int res = nums[0];int count = 1;for(int i=1;i<nums.length;i++){if(count==0){res = nums[i];}if(res == nums[i]){count++;}else{count--;}}return res;}public static void main(String[] args) {int[] nums = new int[]{2,2,1,1,1,2,2};int[] nums1 = new int[10];MostNumber mostNumber = new MostNumber();System.out.println(mostNumber.majorityElement(nums));}
}

給定一個整數(shù)數(shù)組 nums，將數(shù)組中的元素向右輪轉 k 個位置，其中 k 是非負數(shù)。

示例 1:

輸入: nums = [1,2,3,4,5,6,7], k = 3
輸出: [5,6,7,1,2,3,4]
解釋:
向右輪轉 1 步: [7,1,2,3,4,5,6]
向右輪轉 2 步: [6,7,1,2,3,4,5]
向右輪轉 3 步: [5,6,7,1,2,3,4]

示例 2:

輸入：nums = [-1,-100,3,99], k = 2
輸出：[3,99,-1,-100]
解釋: 
向右輪轉 1 步: [99,-1,-100,3]
向右輪轉 2 步: [3,99,-1,-100]

提示：

• 1 <= nums.length <= 105
• -231 <= nums[i] <= 231 - 1
• 0 <= k <= 105

進階：

• 盡可能想出更多的解決方案，至少有 三種 不同的方法可以解決這個問題。
• 你可以使用空間復雜度為 O(1) 的 原地 算法解決這個問題嗎？

public class rotateArray {public void rotate(int[] nums, int k) {k = k%nums.length;int[] nums1 = new int[nums.length];for(int i = 0; i < nums.length; i++){nums1[(i+k)%nums.length] = nums[i];}for(int i = 0; i < nums.length; i++){System.out.println(nums1[i]);}}public void reverse(int[] nums, int start, int end) {while(start < end){int tmp = nums[start];nums[start] = nums[end];nums[end] = tmp;start++;end--;}}public void rotate2(int[] nums, int k) {k = k%nums.length;reverse(nums, 0, nums.length-1);reverse(nums, 0, k-1);reverse(nums, k, nums.length-1);for(int i = nums.length-1; i >= 0; i--){System.out.print(nums[i]+" ");}}public static void main(String[] args) {int[] nums = {1,2,3,4,5,6,7};rotateArray rotateArray = new rotateArray();rotateArray.rotate2(nums, 3);}}

給定一個數(shù)組 prices ，它的第 i 個元素 prices[i] 表示一支給定股票第 i 天的價格。

你只能選擇 某一天 買入這只股票，并選擇在 未來的某一個不同的日子 賣出該股票。設計一個算法來計算你所能獲取的最大利潤。

返回你可以從這筆交易中獲取的最大利潤。如果你不能獲取任何利潤，返回 0 。

示例 1：

輸入：[7,1,5,3,6,4]
輸出：5
解釋：在第 2 天（股票價格 = 1）的時候買入，在第 5 天（股票價格 = 6）的時候賣出，最大利潤 = 6-1 = 5 。注意利潤不能是 7-1 = 6, 因為賣出價格需要大于買入價格；同時，你不能在買入前賣出股票。

示例 2：

輸入：prices = [7,6,4,3,1]
輸出：0
解釋：在這種情況下, 沒有交易完成, 所以最大利潤為 0。

提示：

• 1 <= prices.length <= 105
• 0 <= prices[i] <= 104

public class buy {public int maxProfit(int[] prices) {int res = Integer.MIN_VALUE;int min = Integer.MAX_VALUE;for(int i = 0; i< prices.length; i++){min = Math.min(min,prices[i]);res = Math.max(res,prices[i]-min);}return res;}public static void main(String[] args) {int[] nums = new int[]{7,1,5,3,6,4};buy b1 = new buy();int maxProfit = b1.maxProfit(nums);System.out.println(maxProfit);}}

給你一個整數(shù)數(shù)組 prices ，其中 prices[i] 表示某支股票第 i 天的價格。

在每一天，你可以決定是否購買和/或出售股票。你在任何時候 最多 只能持有 一股 股票。你也可以先購買，然后在 同一天 出售。

返回 你能獲得的 最大 利潤 。

示例 1：

輸入：prices = [7,1,5,3,6,4]
輸出：7
解釋：在第 2 天（股票價格 = 1）的時候買入，在第 3 天（股票價格 = 5）的時候賣出, 這筆交易所能獲得利潤 = 5 - 1 = 4。
隨后，在第 4 天（股票價格 = 3）的時候買入，在第 5 天（股票價格 = 6）的時候賣出, 這筆交易所能獲得利潤 = 6 - 3 = 3。
最大總利潤為 4 + 3 = 7 。

示例 2：

輸入：prices = [1,2,3,4,5]
輸出：4
解釋：在第 1 天（股票價格 = 1）的時候買入，在第 5 天 （股票價格 = 5）的時候賣出, 這筆交易所能獲得利潤 = 5 - 1 = 4。
最大總利潤為 4 。

示例 3：

輸入：prices = [7,6,4,3,1]
輸出：0
解釋：在這種情況下, 交易無法獲得正利潤，所以不參與交易可以獲得最大利潤，最大利潤為 0。

提示：

• 1 <= prices.length <= 3 * 104
• 0 <= prices[i] <= 104

class Solution {public int maxProfit(int[] prices) {int res = 0;for(int i=1;i<prices.length;i++){if(prices[i]-prices[i-1]>0){res += prices[i]-prices[i-1];}}return res;}
}

給你一個非負整數(shù)數(shù)組 nums ，你最初位于數(shù)組的 第一個下標 。數(shù)組中的每個元素代表你在該位置可以跳躍的最大長度。

判斷你是否能夠到達最后一個下標，如果可以，返回 true ；否則，返回 false 。

示例 1：

輸入：nums = [2,3,1,1,4]
輸出：true
解釋：可以先跳 1 步，從下標 0 到達下標 1, 然后再從下標 1 跳 3 步到達最后一個下標。

示例 2：

輸入：nums = [3,2,1,0,4]
輸出：false
解釋：無論怎樣，總會到達下標為 3 的位置。但該下標的最大跳躍長度是 0 ， 所以永遠不可能到達最后一個下標。

提示：

• 1 <= nums.length <= 104
• 0 <= nums[i] <= 105

public class Jump {public boolean canJump(int[] nums) {int len = nums.length;int now = 0;for(int i = 0; i < len; i++) {// 目前可以到達的最遠的地方if(nums[i] == 0 && now == i){break;}now = Math.max(now,i+nums[i]);}now++;if(now < len) return false;return true;}public static void main(String[] args) {int[] nums = {3,2,1,0,4};System.out.println(new Jump().canJump(nums));}}

給定一個長度為 n 的 0 索引整數(shù)數(shù)組 nums。初始位置為 nums[0]。

每個元素 nums[i] 表示從索引 i 向前跳轉的最大長度。換句話說，如果你在 nums[i] 處，你可以跳轉到任意 nums[i + j] 處:

• 0 <= j <= nums[i]
• i + j < n

返回到達 nums[n - 1] 的最小跳躍次數(shù)。生成的測試用例可以到達 nums[n - 1]。

示例 1:

輸入: nums = [2,3,1,1,4]
輸出: 2
解釋: 跳到最后一個位置的最小跳躍數(shù)是 2。從下標為 0 跳到下標為 1 的位置，跳 1 步，然后跳 3 步到達數(shù)組的最后一個位置。

示例 2:

輸入: nums = [2,3,0,1,4]
輸出: 2

提示:

• 1 <= nums.length <= 104
• 0 <= nums[i] <= 1000
• 題目保證可以到達 nums[n-1]

public class JumpGame {public int jump(int[] nums) {int len = nums.length-1;int maxDistance = 0;int end = 0;int res = 0;for(int i = 0 ; i < len ; i++){maxDistance = Math.max(maxDistance,i+nums[i]);if(i == end){end = maxDistance;res++;}}return res;}public static void main(String[] args) {int[] nums = new int[]{2,3,1,1,4};JumpGame jumpGame = new JumpGame();System.out.println(jumpGame.jump(nums));}}

給你一個整數(shù)數(shù)組 citations ，其中 citations[i] 表示研究者的第 i 篇論文被引用的次數(shù)。計算并返回該研究者的 h 指數(shù)。

根據(jù)維基百科上 h 指數(shù)的定義：h 代表“高引用次數(shù)” ，一名科研人員的 h 指數(shù) 是指他（她）至少發(fā)表了 h 篇論文，并且 至少 有 h 篇論文被引用次數(shù)大于等于 h 。如果 h 有多種可能的值，h 指數(shù) 是其中最大的那個。

示例 1：

輸入：citations = [3,0,6,1,5]
輸出：3 
解釋：給定數(shù)組表示研究者總共有 5 篇論文，每篇論文相應的被引用了 3, 0, 6, 1, 5 次。由于研究者有 3 篇論文每篇 至少 被引用了 3 次，其余兩篇論文每篇被引用 不多于 3 次，所以她的 h 指數(shù)是 3。

示例 2：

輸入：citations = [1,3,1]
輸出：1

提示：

• n == citations.length
• 1 <= n <= 5000
• 0 <= citations[i] <= 1000

class Solution {public int hIndex(int[] citations) {Arrays.sort(citations);int h = 0;int pos = citations.length -1;while(pos>=0 && citations[pos] > h){h++;pos--;}return h;}
}

給你一個整數(shù)數(shù)組 nums，返回 數(shù)組 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘積 。

題目數(shù)據(jù) 保證 數(shù)組 nums之中任意元素的全部前綴元素和后綴的乘積都在 32 位 整數(shù)范圍內。

請 **不要使用除法，**且在 O(n) 時間復雜度內完成此題。

示例 1:

輸入: nums = [1,2,3,4]
輸出: [24,12,8,6]

示例 2:

輸入: nums = [-1,1,0,-3,3]
輸出: [0,0,9,0,0]

提示：

• 2 <= nums.length <= 105
• -30 <= nums[i] <= 30
• 保證 數(shù)組 nums之中任意元素的全部前綴元素和后綴的乘積都在 32 位 整數(shù)范圍內

**進階：**你可以在 O(1) 的額外空間復雜度內完成這個題目嗎？（ 出于對空間復雜度分析的目的，輸出數(shù)組 不被視為 額外空間。）

public class productExceptSelf {public int[] productExceptSelf(int[] nums){// 計算Leftint[] Left = new int[nums.length];Left[0] = 1;for (int i = 1; i < nums.length; i++){Left[i] = Left[i-1]*nums[i-1];}int[] Right = new int[nums.length];Right[nums.length-1] = 1;for(int i = nums.length-2; i >= 0; i--){Right[i] = Right[i+1]*nums[i+1];}for(int i = 0;i<nums.length;i++){nums[i] = Left[i]*Right[i];}return nums;}public static void main(String[] args) {productExceptSelf p = new productExceptSelf();int[] nums = new int[]{4,5,1,8,2};int[] res = p.productExceptSelf(nums);for (int i=0;i<res.length;i++){System.out.print(res[i]+" ");}}}

在一條環(huán)路上有 n 個加油站，其中第 i 個加油站有汽油 gas[i] 升。

你有一輛油箱容量無限的的汽車，從第 i 個加油站開往第 i+1 個加油站需要消耗汽油 cost[i] 升。你從其中的一個加油站出發(fā)，開始時油箱為空。

給定兩個整數(shù)數(shù)組 gas 和 cost ，如果你可以按順序繞環(huán)路行駛一周，則返回出發(fā)時加油站的編號，否則返回 -1 。如果存在解，則 保證 它是 唯一 的。

示例 1:

輸入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
輸出: 3
解釋:
從 3 號加油站(索引為 3 處)出發(fā)，可獲得 4 升汽油。此時油箱有 = 0 + 4 = 4 升汽油
開往 4 號加油站，此時油箱有 4 - 1 + 5 = 8 升汽油
開往 0 號加油站，此時油箱有 8 - 2 + 1 = 7 升汽油
開往 1 號加油站，此時油箱有 7 - 3 + 2 = 6 升汽油
開往 2 號加油站，此時油箱有 6 - 4 + 3 = 5 升汽油
開往 3 號加油站，你需要消耗 5 升汽油，正好足夠你返回到 3 號加油站。
因此，3 可為起始索引。

示例 2:

輸入: gas = [2,3,4], cost = [3,4,3]
輸出: -1
解釋:
你不能從 0 號或 1 號加油站出發(fā)，因為沒有足夠的汽油可以讓你行駛到下一個加油站。
我們從 2 號加油站出發(fā)，可以獲得 4 升汽油。 此時油箱有 = 0 + 4 = 4 升汽油
開往 0 號加油站，此時油箱有 4 - 3 + 2 = 3 升汽油
開往 1 號加油站，此時油箱有 3 - 3 + 3 = 3 升汽油
你無法返回 2 號加油站，因為返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，無論怎樣，你都不可能繞環(huán)路行駛一周。

public class GasStation {public int canCompleteCircuit(int[] gas, int[] cost) {int total = 0;int pos = 0;int tank = 0;for(int i=0;i<gas.length;i++){total += gas[i] - cost[i];tank += gas[i] - cost[i];if(tank <= 0){pos = i+1;tank = 0;}}return total < 0 ? -1 : pos;}// 測試用例public static void main(String[] args) {GasStation solution = new GasStation();// 示例 1int[] gas1 = {3,1,1};int[] cost1 = {1,2,2};System.out.println("起始站點: " + solution.canCompleteCircuit(gas1, cost1));}
}

n 個孩子站成一排。給你一個整數(shù)數(shù)組 ratings 表示每個孩子的評分。

你需要按照以下要求，給這些孩子分發(fā)糖果：

• 每個孩子至少分配到 1 個糖果。
• 相鄰兩個孩子評分更高的孩子會獲得更多的糖果。

請你給每個孩子分發(fā)糖果，計算并返回需要準備的 最少糖果數(shù)目 。

示例 1：

輸入：ratings = [1,0,2]
輸出：5
解釋：你可以分別給第一個、第二個、第三個孩子分發(fā) 2、1、2 顆糖果。

示例 2：

輸入：ratings = [1,2,2]
輸出：4
解釋：你可以分別給第一個、第二個、第三個孩子分發(fā) 1、2、1 顆糖果。第三個孩子只得到 1 顆糖果，這滿足題面中的兩個條件。

提示：

• n == ratings.length
• 1 <= n <= 2 * 104
• 0 <= ratings[i] <= 2 * 104

public class CandyDistribution {public static int candy(int[] ratings) {int[] candy = new int[ratings.length];int res = 0;for (int i = 0; i < ratings.length; i++) {candy[i] = 1;}// 從左到右遍歷for(int i = 1;i < candy.length; i++){if(ratings[i]>ratings[i-1]){candy[i] = candy[i-1]+1;}}// 從右到左遍歷for(int i = candy.length - 2; i >= 0; i--){if(ratings[i]>ratings[i+1]){candy[i] = Math.max(candy[i],candy[i+1]+1);}}for(int c : candy){res += c;}return res;}public static void main(String[] args) {// 示例 1int[] ratings1 = {1, 0, 2};System.out.println("最少糖果數(shù): " + candy(ratings1)); // 輸出: 5}
}

給定 n 個非負整數(shù)表示每個寬度為 1 的柱子的高度圖，計算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

輸入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
輸出：6
解釋：上面是由數(shù)組 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度圖，在這種情況下，可以接 6 個單位的雨水（藍色部分表示雨水）。 

示例 2：

輸入：height = [4,2,0,3,2,5]
輸出：9

提示：

• n == height.length
• 1 <= n <= 2 * 104
• 0 <= height[i] <= 105

題解1：

public class trap {public int trap_01(int[] height) {int len = height.length;int[] pre = new int[len];pre[0] = height[0];int[] suf = new int[len];suf[len-1] = height[len-1];// 計算左前綴for(int i = 1; i < height.length; i++) {pre[i] = Math.max(pre[i-1], height[i]);}// 計算右前綴for(int i = len-2; i >= 0; i--) {suf[i] = Math.max(suf[i+1], height[i]);}// 統(tǒng)計int res = 0;for(int i=0;i<height.length;i++){if(pre[i] < suf[i]){res += pre[i] - height[i];}else{res += suf[i] - height[i];}}return res;}public static void main(String[] args) {trap t = new trap();int[] height = new int[]{0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};System.out.println(t.trap_01(height));}}

優(yōu)化版本，一次遍歷：

public class trap {public int trap_02(int[] height){// 雙指針int left = 0,right = height.length-1;int res = 0;int leftMax = height[0];int rightMax = height[height.length-1];while(left < right){// 更新leftMax和rightMax的值leftMax = Math.max(leftMax, height[left]);rightMax = Math.max(rightMax, height[right]);if(leftMax < rightMax){res += leftMax - height[left];left++;}else{res += rightMax - height[right];right--;}}return res;}public static void main(String[] args) {trap t = new trap();int[] height = new int[]{0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};System.out.println(t.trap_02(height));}}

給你一個字符串 s ，請你反轉字符串中 單詞 的順序。

單詞 是由非空格字符組成的字符串。s 中使用至少一個空格將字符串中的 單詞 分隔開。

返回 單詞 順序顛倒且 單詞 之間用單個空格連接的結果字符串。

**注意：**輸入字符串 s中可能會存在前導空格、尾隨空格或者單詞間的多個空格。返回的結果字符串中，單詞間應當僅用單個空格分隔，且不包含任何額外的空格。

示例 1：

輸入：s = "the sky is blue"
輸出："blue is sky the"

示例 2：

輸入：s = "  hello world  "
輸出："world hello"
解釋：反轉后的字符串中不能存在前導空格和尾隨空格。

示例 3：

輸入：s = "a good   example"
輸出："example good a"
解釋：如果兩個單詞間有多余的空格，反轉后的字符串需要將單詞間的空格減少到僅有一個。

提示：

• 1 <= s.length <= 104
• s 包含英文大小寫字母、數(shù)字和空格 ' '
• s 中 至少存在一個 單詞

**進階：**如果字符串在你使用的編程語言中是一種可變數(shù)據(jù)類型，請嘗試使用 O(1) 額外空間復雜度的 原地 解法。

import java.util.ArrayList;
import java.util.Arrays;public class reverseWords {public String reverseWords(String s) {String[] split = s.trim().split(" ");String[] filter = Arrays.stream(split).filter(e -> !e.isEmpty()).toArray(String[]::new);int left = 0;int right = filter.length - 1;while (left < filter.length/2) {String tmp = filter[right];filter[right] = filter[left];filter[left] = tmp;left++;right--;}return String.join(" ", filter);}public static void main(String[] args) {reverseWords r = new reverseWords();System.out.println(r.reverseWords("a good   example"));}}