[103. 二叉樹的鋸齒形層序遍歷]
題目描述
給定一個二叉樹，返回其節點值的鋸齒形層序遍歷。（即先從左往右，再從右往左進行下一層遍歷，以此類推，層與層之間交替進行）。
例如：
給定二叉樹 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回鋸齒形層序遍歷如下：
[
[3],
[20,9],
[15,7]
]
DFS
使用dfs，對應層判斷一下奇偶，決定在表頭還是表尾添加元素就可以了
Code
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
List<List<Integer>> res = new ArrayList<>();
traversal(root, res, 0);
return res;
}
private void traversal(TreeNode root,List<List<Integer>> res,int level){
if(root == null){
return;
}
if(res.size() == level){
res.add(new ArrayList<Integer>());
}
if((level & 1) == 1){
res.get(level).add(0,root.val);//是奇數層則在表頭加入
}else{
res.get(level).add(root.val);//偶數層在表尾加入
}
traversal(root.left,res,level+1);
traversal(root.right,res,level+1);
}
}
隊列BFS
用隊列來暫時存儲節點,在bfs時先統計這一層的節點數量,然後再根據節點數量選擇表頭加入還是表尾加入
Code
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
if (root == null) {
return Collections.emptyList();
}
LinkedList<TreeNode> queue = new LinkedList<>();
queue.add(root);
List<List<Integer>> res = new ArrayList<>();
boolean reverse = true;
while (queue.size() > 0) {
List<Integer> tmp = new ArrayList<>(queue.size());
for (int i = queue.size() - 1; i >= 0; i--) {
TreeNode tmpNode = reverse ? queue.removeFirst() : queue.removeLast();
tmp.add(tmpNode.val);
if (reverse) {
if (tmpNode.left != null) {
queue.addLast(tmpNode.left);
}
if (tmpNode.right != null) {
queue.addLast(tmpNode.right);
}
} else {
if (tmpNode.right != null) {
queue.addFirst(tmpNode.right);
}
if (tmpNode.left != null) {
queue.addFirst(tmpNode.left);
}
}
}
res.add(tmp);
reverse = !reverse;
}
return res;
}
}
[746. 使用最小花費爬樓梯]
題目描述
數組的每個索引作爲一個階梯，第 i個階梯對應着一個非負數的體力花費值 cost[i](索引從0開始)。
每當你爬上一個階梯你都要花費對應的體力花費值，然後你可以選擇繼續爬一個階梯或者爬兩個階梯。
您需要找到達到樓層頂部的最低花費。在開始時，你可以選擇從索引爲 0 或 1 的元素作爲初始階梯。
示例 1:
輸入: cost = [10, 15, 20]
輸出: 15
解釋: 最低花費是從cost[1]開始，然後走兩步即可到階梯頂，一共花費15。
示例 2:
輸入: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
輸出: 6
解釋: 最低花費方式是從cost[0]開始，逐個經過那些1，跳過cost[3]，一共花費6。
(動態規劃)
這個爬樓梯的問題和斐波那契數列問題很像。
讀完題大家應該知道指定需要動態規劃的，貪心是不可能了。
然後我們按照動規四步曲:
1.確定dp數組以及下標的含義
1.1:使用動態規劃，就要有一個數組來記錄狀態，本題只需要一個一維數組dp[i]就可以了。
1.2:dp[i]的定義：第i個臺階所花費的最少體力爲dp[i]。
2.確定遞推公式
2.1可以有兩個途徑得到dp[i]，一個是dp[i-1] 一個是dp[i-2]。
那麼究竟是選dp[i-1]還是dp[i-2]呢？
2.2:一定是選最小的，所以dp[i] = min(dp[i - 1], dp[i - 2]) + cos:t[i];
注意這裏爲什麼是加cost[i]，而不是cost[i-1],cost[i-2]之類的，因爲題目中說了：第i個階梯對應着一個非負數的體力花費值 cost[i]
3.dp數組如何初始化
3.1:根據dp數組的定義，dp數組初始化其實是比較難的，因爲不可能初始化爲第i臺階所花費的最少體力。
3.2:那麼看一下遞歸公式，dp[i]由dp[i-1]，dp[i-2]推出，既然初始化所有的dp[i]是不可能的，那麼只初始化dp[0]和dp[1]就夠了，其他的最終都是dp[0],dp[1]推出。
4.確定遍歷順序
4.1:因爲是模擬臺階，而且dp[i]又dp[i-1]dp[i-2]推出，所以是從前到後遍歷cost數組就可以了。
Code
class Solution {
public int minCostClimbingStairs(int[] cost) {
int[] dp = new int[cost.length];
dp[0] = cost[0];
dp[1] = cost[1];
for(int i = 2; i<cost.length; i++){
dp[i] = Math.min(dp[i-1],dp[i-2])+cost[i];
}
return Math.min(dp[cost.length - 1],dp [cost.length - 2]);
}
}
[387. 字符串中的第一個唯一字符]
題目描述
給定一個字符串，找到它的第一個不重複的字符，並返回它的索引。如果不存在，則返回 -1。
示例:
s = "leetcode"
返回 0
s = "loveleetcode"
返回 2
建立map數組
創建一個長度爲26的數組,每一個下標對應一個字母,當讀取到該字母時,則這個下標++,最後從頭開始遍歷數組,當找到第一個下標值爲1的字母時,return其下標
Code
class Solution {
public int firstUniqChar(String s) {
int[] map = new int[26];
char[] chars = s.toCharArray();
for (char c : chars) {
map[c - 'a']++;
}
for (int i = 0; i < chars.length; i++) {
if (map[chars[i] - 'a'] == 1)
return i;
}
return -1;
}
}
HashMap
相當於上一種辦法的詳細版,建立每個char ch與 它所出現次數count的map映射關係,然後遍歷map,找到第一個count爲1的char,將其return掉
Code
class Solution {
public int firstUniqChar(String s) {
Map<Character, Integer> map = new HashMap<>(26);
char[] chars = s.toCharArray();
for (char ch : chars) {
map.put(ch, map.getOrDefault(ch, 0) + 1);
}
for (int i = 0; i < chars.length; i++) {
if (map.get(chars[i]) == 1) {
return i;
}
}
return -1;
}
}
indexOf和lastIndexOf
調用系統庫函數indexOf和lastIndexOf(),如果兩者相等,則說明這個字符只出現了一次,將其return掉
Code
class Solution {
public int firstUniqChar(String s){
char[] chars = s.toCharArray();
int len = chars.length;
if(len == 1){
return 0;
}
for (int i = 0; i < len; i++) {
if(s.indexOf(chars[i]) == s.lastIndexOf(chars[i])){
return i;
}
}
return -1;
}
}
[135. 分發糖果]
題目描述
老師想給孩子們分發糖果，有 N 個孩子站成了一條直線，老師會根據每個孩子的表現，預先給他們評分。
你需要按照以下要求，幫助老師給這些孩子分發糖果：
每個孩子至少分配到 1 個糖果。
相鄰的孩子中，評分高的孩子必須獲得更多的糖果。
那麼這樣下來，老師至少需要準備多少顆糖果呢？
示例I/O
輸入: [1,0,2]
輸出: 5
解釋: 你可以分別給這三個孩子分發 2、1、2 顆糖果。
輸入: [1,2,2]
輸出: 4
解釋: 你可以分別給這三個孩子分發 1、2、1 顆糖果。
第三個孩子只得到 1 顆糖果，這已滿足上述兩個條件。
貪心(兩次遍歷)
這種題目是很典型的貪心算法,一定是要確定一邊之後，再確定另一邊，例如比較每一個孩子的左邊，然後再比較右邊，如果兩邊一起考慮就會顧此失彼。先初始化一個糖果數組candyArray用來記錄每位孩子應該得到的糖果數並全部賦值爲1。
先從前往後遍歷,如果後一個孩子的得分比前一個高,則比前一個孩子多得到一顆糖果
再從後往前遍歷,如果前一個孩子的得分比後一個孩子得分高,那麼就看前一個孩子所得糖果數量和後一個孩子的糖果數+1哪個更大,選擇更大的作爲前一個孩子所得糖果數
Code
class Solution {
public int candy(int[] ratings) {
int len = ratings.length;
if(len == 0 || ratings == null){
return 0;
}
if(len == 1){
return 1;
}
//初始化糖果數組
int[] candyArray = new int[len];
Arrays.fill(candyArray,1);
//從前往後
for (int i = 1; i < len; i++) {
if(ratings[i] > ratings[i - 1]){
candyArray[i] = candyArray[i - 1] + 1;
}
}
//從後往前
for (int i = len - 2; i >= 0; i--) {
if(ratings[i] > ratings[i + 1]){
candyArray[i] = Math.max(candyArray[i],candyArray[i + 1] + 1);
}
}
//求和
int result = 0;
for (int i : candyArray) {
result += i;
}
return result;
}
}
[85. 最大矩形]
題目描述:
給定一個僅包含 0 和 1 、大小爲 rows x cols 的二維二進制矩陣，找出只包含 1 的最大矩形，並返回其面積。
示例 1：
輸入：matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
輸出：6
解釋：最大矩形如上圖所示。
示例 2：
輸入：matrix = []
輸出：0
示例 3：
輸入：matrix = [["0"]]
輸出：0
示例 4：
輸入：matrix = [["1"]]
輸出：1
示例 5：
輸入：matrix = [["0","0"]]
輸出：0
(動態規劃)
有點類似暴搜,先處理邊界,然後依次遍歷每個點,找到最小寬度然後乘以高度即可
Code
class Solution {
public int maximalRectangle(char[][] matrix) {
int m = matrix.length;
if (m == 0) {
return 0;
}
int n = matrix[0].length;
// 記錄每個點的最大寬（向左的連續1長度）和最大高（向上的連續1長度）
int[][][] dp = new int[m][n][2];
int res = 0;
// 左上角
if (matrix[0][0] == '0') {
dp[0][0][0] = 0;
dp[0][0][1] = 0;
}
else {
dp[0][0][0] = 1;
dp[0][0][1] = 1;
res = 1;
}
// 最左1列
for(int i = 1; i < m; i ++) {
if (matrix[i][0] == '0') {
dp[i][0][0] = 0;
dp[i][0][1] = 0;
}
else {
dp[i][0][0] = 1;
dp[i][0][1] = 1 + dp[i - 1][0][1];
res = Math.max(res, dp[i][0][1]);
}
}
// 最上1行
for (int j = 1; j < n; j ++) {
if (matrix[0][j] == '0') {
dp[0][j][0] = 0;
dp[0][j][1] = 0;
}
else {
dp[0][j][0] = 1 + dp[0][j - 1][0];
dp[0][j][1] = 1;
res = Math.max(res, dp[0][j][0] * 1);
}
}
for (int i = 1; i < m; i ++) {
for (int j = 1; j < n; j ++) {
if (matrix[i][j] == '1') {
dp[i][j][0] = dp[i][j - 1][0] + 1;
dp[i][j][1] = dp[i - 1][j][1] + 1;
// 需要保證圍成的矩形只包含1
// 向左遍歷判斷最大矩形的高能否是height
int height = dp[i][j][1];
while (height > 0) {
for (int y = j - 1; y >= 0; y --) {
if (dp[i][y][1] < height) {
break;
}
else {
res = Math.max(res, (j - y + 1) * height);
}
}
height --;
}
// 向上遍歷判斷最大矩形的寬能否是width
int width = dp[i][j][0];
while (width > 0) {
for (int x = i - 1; x >= 0; x --) {
if (dp[x][j][0] < width) {
break;
}
else {
res = Math.max(res, (i - x + 1) * width);
}
}
width --;
}
}
}
}
return res;
}
}
[劍指 Offer 10- I. 斐波那契數列]
題目描述:
寫一個函數，輸入 n ，求斐波那契（Fibonacci）數列的第 n 項。斐波那契數列的定義如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契數列由 0 和 1 開始，之後的斐波那契數就是由之前的兩數相加而得出。
答案需要取模 1e9+7（1000000007），如計算初始結果爲：1000000008，請返回 1。
示例I/O
輸入：n = 2
輸出：1
輸入：n = 5
輸出：5
(動態規劃)
這題我先用了遞歸,後來爆表了...
後來試了動態規劃,纔可以AC,感覺這種題目都只能用動態規劃來做纔不會爆表...
題目已經給了動態規劃方程F(N) = F(N-1)+F(N-2)
邊界條件爲dp[0] = 0,dp[1] = 1,執行dp之前判斷一下即可
所以用上這個規劃條件即可
Code
class Solution {
public int fib(int n) {
if(n < 2){
return n;
}
int[] dp = new int[n + 1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] =(dp[i-1] + dp[i-2]) % 1000000007;
}
return dp[n];
}
}
[1025. 除數博弈]
題目描述:
愛麗絲和鮑勃一起玩遊戲，他們輪流行動。愛麗絲先手開局。
最初，黑板上有一個數字 N 。在每個玩家的回合，玩家需要執行以下操作：
選出任一 x，滿足 0 < x < N 且 N % x == 0 。
用 N - x 替換黑板上的數字 N 。
如果玩家無法執行這些操作，就會輸掉遊戲。
只有在愛麗絲在遊戲中取得勝利時才返回 True，否則返回 False。假設兩個玩家都以最佳狀態參與遊戲。
示例I/O
示例 1:
輸入：2
輸出：true
解釋：愛麗絲選擇 1，鮑勃無法進行操作。
示例 2：
輸入：3
輸出：false
解釋：愛麗絲選擇 1，鮑勃也選擇 1，然後愛麗絲無法進行操作。
數學方法
有一個原則就是先手偶數必勝。先手爲偶數的話，先手只需要讓自己每步都保持偶數，那麼他可以通過讓對手得到的數爲奇數，比如偶數-1就是奇數了，對手拿到奇數，那麼能整除的只有奇數，奇數-奇數又回到了偶數，最後先手一定會得到最小的偶數2，然後-1讓對手得到1，對手無解，必勝。
Code
class Solution {
public boolean divisorGame(int N) {
return N%2==0;
}
}
(動態規劃)
基本思路：
將所有的小於等於 N 的解都找出來，基於前面的，遞推後面的。
狀態轉移: 如果 i 的約數裏面有存在爲 flase 的（即輸掉的情況），則當前 i 應爲 true；如果沒有，則爲 false。
Code
class Solution {
public boolean divisorGame(int N){
if(N == 1){
return false;
}
if(N == 2){
return true;
}
boolean[] dp = new boolean[N+1];
dp[1] = false;
dp[2] = true;
for (int i = 3; i < N+1; i++) {
for (int j = 1; j < i; j++) {
if(i % j ==0 && dp[i - j] == false){
dp[i] = true;
break;
}
dp[i] = false;
}
}
return dp[N];
}
}
[同構字符串]
題目描述:
給定兩個字符串 s 和 t，判斷它們是否是同構的。
如果 s 中的字符可以被替換得到 t ，那麼這兩個字符串是同構的。
所有出現的字符都必須用另一個字符替換，同時保留字符的順序。兩個字符不能映射到同一個字符上，但字符可以映射自己本身。
示例I/O
示例 1:
輸入: s = "egg", t = "add"
輸出: true
示例 2:
輸入: s = "foo", t = "bar"
輸出: false
示例 3:
輸入: s = "paper", t = "title"
輸出: true
HashMap
這種題一般使用hashmap建立起映射關係即可,如果不存在這一組鍵值,那麼則添加,添加前考慮value值是否唯一即可,如果已存在,則考慮新的value值是否與原value值相同
Code
class Solution {
public boolean isIsomorphic(String s, String t) {
char[] chars = s.toCharArray();
char[] chars1 = t.toCharArray();
Map<Character, Character> map = new HashMap<>(chars.length);
for (int i = 0; i < chars.length; i++) {
if(!map.containsKey(chars[i])){
if(map.containsValue(chars1[i])){
return false;
}
map.put(chars[i],chars1[i]);
}else{
if(map.get(chars[i])!=chars1[i]){
return false;
}
}
}
return true;
}
}
(數組模擬map)
創建兩個數組,分別對應s->t和t->s的映射關係,然後在添加時,先看是否有,沒有則插入,有則雙向比較
Code1
class Solution {
public boolean isIsomorphic(String s, String t) {
int []map1=new int[256];
int []map2=new int[256];
for(int i=0;i<t.length();i++){
if(map1[(int)s.charAt(i)]==0&&map2[(int)t.charAt(i)]==0){
map1[(int)s.charAt(i)]=(int)t.charAt(i);
map2[(int)t.charAt(i)]=(int)s.charAt(i);
}else{
if(map1[(int)s.charAt(i)]!=(int)t.charAt(i)){
return false;
}
}
}
return true;
}
}
Code2
class Solution {
public boolean isIsomorphic(String s, String t) {
return canMap(s, t) && canMap(t, s);
}
private boolean canMap(String s, String t) {
if (s.length() != t.length()) {
return false;
}
int[] ms = new int[128];
char[] cs = s.toCharArray();
char[] ct = t.toCharArray();
int len = s.length();
for (int i = 0; i < len; i++) {
if (ms[cs[i]] == 0) {
ms[cs[i]] = ct[i];
} else if (ms[cs[i]] != ct[i]) {
return false;
}
}
return true;
}
}