diff --git a/.gitignore b/.gitignore deleted file mode 100644 index a1c2a23..0000000 --- a/.gitignore +++ /dev/null @@ -1,23 +0,0 @@ -# Compiled class file -*.class - -# Log file -*.log - -# BlueJ files -*.ctxt - -# Mobile Tools for Java (J2ME) -.mtj.tmp/ - -# Package Files # -*.jar -*.war -*.nar -*.ear -*.zip -*.tar.gz -*.rar - -# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml -hs_err_pid* diff --git "a/OfferCode/\351\242\230\347\233\25603_\344\273\216\345\260\276\345\210\260\345\244\264\346\211\223\345\215\260\351\223\276\350\241\250.java" "b/OfferCode/\351\242\230\347\233\25603_\344\273\216\345\260\276\345\210\260\345\244\264\346\211\223\345\215\260\351\223\276\350\241\250.java" new file mode 100644 index 0000000..5e1ae2b --- /dev/null +++ "b/OfferCode/\351\242\230\347\233\25603_\344\273\216\345\260\276\345\210\260\345\244\264\346\211\223\345\215\260\351\223\276\350\241\250.java" @@ -0,0 +1,52 @@ +/* +题目03 +描述:输入一个链表,按链表从尾到头的顺序返回一个ArrayList。 + */ +/** +* public class ListNode { +* int val; +* ListNode next = null; +* +* ListNode(int val) { +* this.val = val; +* } +* } +* +*/ + +// 方法1:反转链表 +import java.util.ArrayList; +public class Solution { + public ArrayList printListFromTailToHead(ListNode listNode) { + ArrayList lis = new ArrayList(); + ListNode tmp=null, pre=null, cur=listNode; + + while(cur != null){ + tmp = cur.next; //保存下一个节点 + cur.next = pre; + pre = cur; //cur、tmp节点后移 + cur = tmp; + } + + while(pre != null){ + lis.add(pre.val); + pre = pre.next; + } + return lis; + } +} + +// 方法2:递归 +/* import java.util.ArrayList; +public class Solution { + public ArrayList printListFromTailToHead(ListNode listNode) { + ArrayList lis = new ArrayList(); + + if(listNode == null ) + return lis; + lis = printListFromTailToHead(listNode.next); + + lis.add(listNode.val); + return lis; + } +} */ diff --git "a/OfferCode/\351\242\230\347\233\25614_\351\223\276\350\241\250\344\270\255\345\200\222\346\225\260\347\254\254k\344\270\252\347\273\223\347\202\271.java" "b/OfferCode/\351\242\230\347\233\25614_\351\223\276\350\241\250\344\270\255\345\200\222\346\225\260\347\254\254k\344\270\252\347\273\223\347\202\271.java" new file mode 100644 index 0000000..0a975db --- /dev/null +++ "b/OfferCode/\351\242\230\347\233\25614_\351\223\276\350\241\250\344\270\255\345\200\222\346\225\260\347\254\254k\344\270\252\347\273\223\347\202\271.java" @@ -0,0 +1,32 @@ +/* +题目14 +描述:输入一个链表,输出该链表中倒数第k个结点。 + */ +/* +public class ListNode { + int val; + ListNode next = null; + + ListNode(int val) { + this.val = val; + } +}*/ +// 解法:快慢指针 +public class Solution { + public ListNode FindKthToTail(ListNode head,int k) { + ListNode slow = head, fast = head; + if(fast == null || k <= 0) //链表空 或 k <= 0 + return null; + for(int i = 1; i < k; i++){ //移动 k-1 个节点 + fast = fast.next; + if(fast == null) // k > lenth + return null; + } + + while(fast.next != null){ + fast = fast.next; + slow = slow.next; + } + return slow; + } +} \ No newline at end of file diff --git "a/OfferCode/\351\242\230\347\233\25615_\345\217\215\350\275\254\351\223\276\350\241\250.java" "b/OfferCode/\351\242\230\347\233\25615_\345\217\215\350\275\254\351\223\276\350\241\250.java" new file mode 100644 index 0000000..8548143 --- /dev/null +++ "b/OfferCode/\351\242\230\347\233\25615_\345\217\215\350\275\254\351\223\276\350\241\250.java" @@ -0,0 +1,32 @@ +/* +题目15 +描述:输入一个链表,反转链表后,输出新链表的表头 + */ +/* +public class ListNode { + int val; + ListNode next = null; + + ListNode(int val) { + this.val = val; + } +}*/ +public class Solution { + public ListNode ReverseList(ListNode head) { + ListNode pre = null, cur = head, tmp = null; + + if(cur == null || cur.next == null) //链表长度为 0 或 1 + return cur; + + while(cur.next != null){ + tmp = cur.next; //保存下一个节点 + cur.next = pre; //当前节点指向前一个节点 + + pre = cur; + cur = tmp; //pre、cur后移一个节点 + } + cur.next = pre; //最后一个节点指向前面的节点 + + return cur; + } +} \ No newline at end of file diff --git "a/OfferCode/\351\242\230\347\233\25626_\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\345\217\214\345\220\221\351\223\276\350\241\250.java" "b/OfferCode/\351\242\230\347\233\25626_\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\345\217\214\345\220\221\351\223\276\350\241\250.java" new file mode 100644 index 0000000..74a7a41 --- /dev/null +++ "b/OfferCode/\351\242\230\347\233\25626_\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\345\217\214\345\220\221\351\223\276\350\241\250.java" @@ -0,0 +1,57 @@ +/* +题目26 +描述:输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。 +要求不能创建任何新的结点,只能调整树中结点指针的指向。 +*/ +//方法1:中序遍历递归直接建立链接。 时间O(n),空间O(1) +//方法2:中序遍历递归,存储节点,二次遍历时建立链接。时间O(n),空间O(n) +/** +public class TreeNode { + int val = 0; + TreeNode left = null; + TreeNode right = null; + + public TreeNode(int val) { + this.val = val; + + } + +} +*/ +public class Solution { + public TreeNode Convert(TreeNode pRootOfTree) { + if(pRootOfTree == null) + return null; + + TreeNode headNode = null; + //中序遍历递归 + middleorderTraversal(pRootOfTree, null); + + headNode = pRootOfTree; + while(headNode.left != null){ + headNode = headNode.left; + } + return headNode; + } + //方法1:中序遍历递归 + public TreeNode middleorderTraversal(TreeNode pRootOfTree, TreeNode lastNodeInList){ + // TreeNode lastNodeInList = null; + if(pRootOfTree == null) + return null; + //左子树 + if(pRootOfTree.left != null){ + lastNodeInList = middleorderTraversal(pRootOfTree.left, lastNodeInList); + } + //key point 把当前节点与其左子树的最大节点建立链接 + pRootOfTree.left = lastNodeInList; + if(lastNodeInList != null) + lastNodeInList.right = pRootOfTree; + + //右子树 + lastNodeInList = pRootOfTree; + if(pRootOfTree.right != null){ + lastNodeInList = middleorderTraversal(pRootOfTree.right, lastNodeInList); + } + return lastNodeInList; + } +} \ No newline at end of file diff --git "a/OfferCode/\351\242\230\347\233\25636_\344\270\244\344\270\252\351\223\276\350\241\250\347\232\204\347\254\254\344\270\200\344\270\252\345\205\254\345\205\261\350\212\202\347\202\271.java" "b/OfferCode/\351\242\230\347\233\25636_\344\270\244\344\270\252\351\223\276\350\241\250\347\232\204\347\254\254\344\270\200\344\270\252\345\205\254\345\205\261\350\212\202\347\202\271.java" new file mode 100644 index 0000000..1996708 --- /dev/null +++ "b/OfferCode/\351\242\230\347\233\25636_\344\270\244\344\270\252\351\223\276\350\241\250\347\232\204\347\254\254\344\270\200\344\270\252\345\205\254\345\205\261\350\212\202\347\202\271.java" @@ -0,0 +1,64 @@ +/* +题目36 +描述:输入两个链表,找出它们的第一个公共结点。 +(注意因为传入数据是链表,所以错误测试数据的提示是用其他方式显示的,保证传入数据是正确的) + */ +/* +public class ListNode { + int val; + ListNode next = null; + + ListNode(int val) { + this.val = val; + } +}*/ +/* +方法1(优选):截取长的链表,使两个链表长度相同,然后同时遍历, +首个相同节点即为第一个公共节点 + */ +public class Solution { + public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) { + ListNode p1 = pHead1, p2 = pHead2; + if(p1 == null || p2 == null) + return null; + int len1 = 0, len2 = 0, n = 0; + + while(p1 != null){ + len1++; + p1 = p1.next; + } + while(p2 != null){ + len2++; + p2 = p2.next; + } + // ***链表head要重置为表头 + p1 = pHead1; + p2 = pHead2; + if(len1 >= len2){ + n = len1 - len2; + while(n > 0){ + p1 = p1.next; + n--; + } + } + else{ + n = len2 - len1; + while(n > 0){ + p2 = p2.next; + n--; + } + } + + while(p1 != p2){ + p1 = p1.next; + p2 = p2.next; + } + return p1; + } +} + +/* +方法2:利用哈希表 +对两个链表一次存入哈希表,当出现首个相同哈希值的即为第一个公共节点 +缺点:需要O(n+m)的空间复杂的 + */ \ No newline at end of file diff --git "a/OfferCode/\351\242\230\347\233\25646_\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260(\347\272\246\347\221\237\345\244\253\347\216\257\351\227\256\351\242\230).java" "b/OfferCode/\351\242\230\347\233\25646_\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260(\347\272\246\347\221\237\345\244\253\347\216\257\351\227\256\351\242\230).java" new file mode 100644 index 0000000..49207ea --- /dev/null +++ "b/OfferCode/\351\242\230\347\233\25646_\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260(\347\272\246\347\221\237\345\244\253\347\216\257\351\227\256\351\242\230).java" @@ -0,0 +1,34 @@ +/* +题目46 +描述:每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。 +HF作为牛客的资深元老,自然也准备了一些小游戏。 +其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。 +然后,他随机指定一个数m,让编号为0的小朋友开始报数。 +每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中, +从他的下一个小朋友开始,继续0...m-1报数....这样下去.... +直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。 +请你试着想下,哪个小朋友会得到这份礼品呢?(注:小朋友的编号是从0到n-1) + +如果没有小朋友,请返回-1 + */ +import java.util.LinkedList; +/* + 使用LinkedList模拟游戏过程即可;考虑删除节点的效率。: +*/ +public class Solution { + public int LastRemaining_Solution(int n, int m) { + + LinkedList list = new LinkedList(); + for (int i = 0; i < n; i ++) { + list.add(i); + } + + int bt = 0; + while (list.size() > 1) { + bt = (bt + m - 1) % list.size(); + list.remove(bt); + } + + return list.size() == 1 ? list.get(0) : -1; + } +} \ No newline at end of file diff --git "a/OfferCode/\351\242\230\347\233\25655_\351\223\276\350\241\250\344\270\255\347\216\257\347\232\204\345\205\245\345\217\243\350\212\202\347\202\271.java" "b/OfferCode/\351\242\230\347\233\25655_\351\223\276\350\241\250\344\270\255\347\216\257\347\232\204\345\205\245\345\217\243\350\212\202\347\202\271.java" new file mode 100644 index 0000000..75ecee2 --- /dev/null +++ "b/OfferCode/\351\242\230\347\233\25655_\351\223\276\350\241\250\344\270\255\347\216\257\347\232\204\345\205\245\345\217\243\350\212\202\347\202\271.java" @@ -0,0 +1,46 @@ +/* 题目 +描述:给一个链表,若其中包含环,请找出该链表的环的入口结点,否则,输出null。 +*/ +/* + public class ListNode { + int val; + ListNode next = null; + + ListNode(int val) { + this.val = val; + } +} +*/ +/* + 快慢指针法 +1. 快指针走两步,慢指针走一步, +2. 两指针指针相遇时,快指针从链表头重新开始,每次走一步, +3. 再次相遇时即为环的入口 +边界:链表空,无环 +*/ +public class Solution { + + public ListNode EntryNodeOfLoop(ListNode pHead) + { + if(pHead == null || pHead.next == null) + return null; + ListNode fast = pHead, slow = pHead; + //if(fast.next == pHead) + // return pHead; + + while(fast != null && fast.next != null){ + fast = fast.next.next; + slow = slow.next; + if(fast == slow){ + fast = pHead; + while(fast != slow){ + fast = fast.next; + slow = slow.next; + } + return fast; + } + } + return null; + + } +} \ No newline at end of file diff --git "a/OfferCode/\351\242\230\347\233\25656_\345\210\240\351\231\244\351\223\276\350\241\250\344\270\255\351\207\215\345\244\215\350\212\202\347\202\271.java" "b/OfferCode/\351\242\230\347\233\25656_\345\210\240\351\231\244\351\223\276\350\241\250\344\270\255\351\207\215\345\244\215\350\212\202\347\202\271.java" new file mode 100644 index 0000000..90fc850 --- /dev/null +++ "b/OfferCode/\351\242\230\347\233\25656_\345\210\240\351\231\244\351\223\276\350\241\250\344\270\255\351\207\215\345\244\215\350\212\202\347\202\271.java" @@ -0,0 +1,47 @@ +/* +题目56 +描述:在一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留,返回链表头指针。 +例如,链表1->2->3->3->4->4->5 处理后为 1->2->5 + */ + /* + public class ListNode { + int val; + ListNode next = null; + + ListNode(int val) { + this.val = val; + } +} +*/ +//双指针法,左指针指向重复节点的前一个节点,右指针用来删除重复节点 +public class Solution { + public ListNode deleteDuplication(ListNode pHead) + { + if(pHead == null || pHead.next == null) + return pHead; + ListNode headNode = new ListNode(Integer.MIN_VALUE); + ListNode pre, cur; + headNode.next = pHead; + pre = headNode; + cur = pHead; + boolean repeat = false; + + while(cur != null){ + while(cur.next != null && cur.val == cur.next.val){ + cur= cur.next; + repeat = true; + } + + if(repeat){ + repeat = false; + pre.next = cur.next; + } + else + pre = cur; + + cur = cur.next; + } + + return headNode.next; + } +} \ No newline at end of file diff --git a/README.md b/README.md deleted file mode 100644 index 8ef9ff4..0000000 --- a/README.md +++ /dev/null @@ -1,2 +0,0 @@ -# code -代码题相关 diff --git "a/leetcode/111. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md" "b/leetcode/111. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md" new file mode 100644 index 0000000..d869789 --- /dev/null +++ "b/leetcode/111. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md" @@ -0,0 +1,83 @@ +# [111. 二叉树的最小深度](https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/) + +给定一个二叉树,找出其最小深度。 + +最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 + +**说明:**叶子节点是指没有子节点的节点。 + +**示例 1:** + +``` +输入:root = [3,9,20,null,null,15,7] +输出:2 +``` + +**示例 2:** + +``` +输入:root = [2,null,3,null,4,null,5,null,6] +输出:5 +``` + +**提示:** + +- 树中节点数的范围在 `[0, 105]` 内 +- `-1000 <= Node.val <= 1000` + + + +## 题解 + + + +**代码:** + +```java +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public int minDepth(TreeNode root) { + if(root == null) + return 0; + + Queue queue = new LinkedList<>(); + //root 本身就是一层,初始化为1 + int depth = 1; + queue.offer(root); + + while(!queue.isEmpty()){ + int b = queue.size(); + /* 将当前队列中每个节点向四周扩散*/ + for(int i = 0; i < b; i++){ + TreeNode cur = queue.poll(); + /* 判断是否达到了终点 */ + if(cur.left == null && cur.right == null) + return depth; + /* 将cur的子节点加入队列 */ + if(cur.left != null) + queue.offer(cur.left); + if(cur.right != null) + queue.offer(cur.right); + } + /* 增加层数 */ + depth++; + } + return depth; + } +} +``` + diff --git "a/leetcode/121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272(\344\271\260\345\215\226\344\270\200\346\254\241).md" "b/leetcode/121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272(\344\271\260\345\215\226\344\270\200\346\254\241).md" new file mode 100644 index 0000000..0ad6120 --- /dev/null +++ "b/leetcode/121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272(\344\271\260\345\215\226\344\270\200\346\254\241).md" @@ -0,0 +1,63 @@ +# [121. 买卖股票的最佳时机](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/) + +## 题目描述 + +给定一个数组 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 + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +```java +class Solution { + public int maxProfit(int[] prices) { + int len = prices.length; + + // int[][] dp = new int[len][2]; + int dp_i_0 = 0; + int dp_i_1 = - prices[0]; + + for(int i = 1; i < len; i++){ + // dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]); + dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]); + // dp[i][1] = Math.max(dp[i-1][1], - prices[i]); + dp_i_1 = Math.max(dp_i_1, - prices[i]); + } + + return dp_i_0; + } +} +``` + diff --git "a/leetcode/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II(\344\270\215\351\231\220\346\254\241).md" "b/leetcode/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II(\344\270\215\351\231\220\346\254\241).md" new file mode 100644 index 0000000..dd5e0a8 --- /dev/null +++ "b/leetcode/122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II(\344\270\215\351\231\220\346\254\241).md" @@ -0,0 +1,74 @@ +# [122. 买卖股票的最佳时机 II](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/) + +## 题目描述 + +给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格。 + +设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。 + +注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。 + + + +**示例 1:** + +``` +输入: [7,1,5,3,6,4] +输出: 7 +解释: 在第 2 天(股票价格 = 1)的时候买入,在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 + 随后,在第 4 天(股票价格 = 3)的时候买入,在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。 +``` + +**示例 2:** + +``` +输入: [1,2,3,4,5] +输出: 4 +解释: 在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 + 注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。 + 因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。 +``` + +**示例 3:** + +``` +输入: [7,6,4,3,1] +输出: 0 +解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 +``` + + +提示: + +- 1 <= prices.length <= 3 * 10 ^ 4 +- 0 <= prices[i] <= 10 ^ 4 + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +```java +class Solution { + public int maxProfit(int[] prices) { + int len = prices.length; + + int dp_i_0 = 0; + int dp_i_1 = -prices[0]; + + for(int i = 0; i < len; i++){ + int tmp = dp_i_0; + + // dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]) + dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]); + // dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i]) + dp_i_1 = Math.max(dp_i_1, tmp - prices[i]); + } + return dp_i_0; + } +} +``` + diff --git "a/leetcode/3. \346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" "b/leetcode/3. \346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" new file mode 100644 index 0000000..888c209 --- /dev/null +++ "b/leetcode/3. \346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" @@ -0,0 +1,92 @@ +# [3. 无重复字符的最长子串](https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/) + +## 题目描述 + +给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度。 + +**示例 1:** + +``` +输入: s = "abcabcbb" +输出: 3 +解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。 +``` + +**示例 2:** + +``` +输入: s = "bbbbb" +输出: 1 +解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。 +``` + +**示例 3:** + +``` +输入: s = "pwwkew" +输出: 3 +解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。 + 请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。 +``` + +**示例 4:** + +``` +输入: s = "" +输出: 0 +``` + +**提示:** + +- 0 <= s.length <= 5 * 104 +- s 由英文字母、数字、符号和空格组成 + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/longest-substring-without-repeating-characters + +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +```java +class Solution { + public int lengthOfLongestSubstring(String s) { + + if(s.length() == 0) + return 0; + + int[] window = new int[256]; + int max = 0; + int repeat = 0; + int left = 0, right = 0; + window[s.charAt(0)] = 1; + + while( right < s.length() - 1){ + /* 扩展右边界,更新窗口数据 */ + right++; + char c = s.charAt(right); + + window[c]++; + if(window[c] > 1) + repeat++; + + /* 判断左边界是否收缩,更新窗口数据 */ + while(repeat > 0 && left < right){ + c = s.charAt(left); + left++; + + if(window[c] == 2) + repeat--; + window[c]--; + } + /* 更新最长字串数据 */ + if(right - left > max) + max = right - left; + } + return max + 1; + } +} +``` + diff --git "a/leetcode/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" "b/leetcode/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" new file mode 100644 index 0000000..999285c --- /dev/null +++ "b/leetcode/300. \346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" @@ -0,0 +1,82 @@ +# [300. 最长递增子序列](https://leetcode-cn.com/problems/longest-increasing-subsequence/) + +## 题目: + +给你一个整数数组 nums ,找到其中最长严格递增子序列的长度。 + +子序列是由数组派生而来的序列,删除(或不删除)数组中的元素而不改变其余元素的顺序。例如,[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 + +示例 1: + +``` +输入:nums = [10,9,2,5,3,7,101,18] +输出:4 +解释:最长递增子序列是 [2,3,7,101],因此长度为 4 。 +``` + +示例 2: + +``` +输入:nums = [0,1,0,3,2,3] +输出:4 +``` + +示例 3: + +``` +输入:nums = [7,7,7,7,7,7,7] +输出:1 +``` + + +提示: + +- 1 <= nums.length <= 2500 + +- -104 <= nums[i] <= 104 + + + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/longest-increasing-subsequence +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解: + +解题思路: + +``` +dp[i]代表一nums[i]为结尾的升序字串最大长度 +dp[i]= [0, i-1] 里小于nums[i]数加1,最大的就是dp[i] +``` + +实现代码: + +``` +class Solution { + public int lengthOfLIS(int[] nums) { + + int dp[] =new int[nums.length]; + int res=0; + Arrays.fill(dp,1); + + for(int i = 0; i < nums.length; i++){ + for(int j = 0; j < i; j++){ + if(nums[j] < nums[i]) + dp[i] = Math.max(dp[i],dp[j]+1);// + + } + } + + res = 0; + for(int i = 0;i < dp.length; i++){ + if(dp[i] > res) + res = dp[i]; + } + return res; + } +} +``` + diff --git "a/leetcode/309. \346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md" "b/leetcode/309. \346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md" new file mode 100644 index 0000000..1a9c27a --- /dev/null +++ "b/leetcode/309. \346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md" @@ -0,0 +1,55 @@ +# [309. 最佳买卖股票时机含冷冻期](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/) + +## 题目描述 + +给定一个整数数组,其中第 i 个元素代表了第 i 天的股票价格 。 + +设计一个算法计算出最大利润。在满足以下约束条件下,你可以尽可能地完成更多的交易(多次买卖一支股票): + +你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。 +卖出股票后,你无法在第二天买入股票 (即冷冻期为 1 天)。 +**示例:** + +``` +输入: [1,2,3,0,2] +输出: 3 +解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出] +``` + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +每次 sell 之后要等一天才能继续交易。只要把这个特点融入上一题的状态转移方程即可: + +``` +dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]) +dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i]) +解释:第 i 天选择 buy 的时候,要从 i-2 的状态转移,而不是 i-1 。 +``` + +```java +class Solution { + public int maxProfit(int[] prices) { + int len = prices.length; + + int dp_i_0 = 0, dp_i_1 = -prices[0]; + int dp_pre_0 = 0; + for(int i = 0; i< len; i++) { + int tmp = dp_i_0; + + dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]); + // dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]) + dp_i_1 = Math.max(dp_i_1, dp_pre_0 - prices[i]); + // dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i]) + dp_pre_0 = tmp; + } + return dp_i_0; + } +} +``` + diff --git "a/leetcode/322.\351\233\266\351\222\261\345\205\221\346\215\242.md" "b/leetcode/322.\351\233\266\351\222\261\345\205\221\346\215\242.md" new file mode 100644 index 0000000..abcea69 --- /dev/null +++ "b/leetcode/322.\351\233\266\351\222\261\345\205\221\346\215\242.md" @@ -0,0 +1,119 @@ +# 322 [零钱兑换](https://leetcode-cn.com/problems/coin-change/) + +题目: + +给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额,返回 -1。 + +你可以认为每种硬币的数量是无限的。 + + + +示例 1: + +``` +输入:coins = [1, 2, 5], amount = 11 +输出:3 +解释:11 = 5 + 5 + 1 +``` + + +示例 2: + +``` +输入:coins = [2], amount = 3 +输出:-1 +``` + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/coin-change +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + +## 解题思路 + +**递归:** + +``` +大金额通过递归获得小金额的硬币个数 + 1; +``` + +**动态规划:** + +``` +小金额通过迭代逐步获得大金额的硬币数 +``` + + + +## 递归 + 备忘录 + +```java + +class Solution { + + public int coinChange(int[] coins, int amount) { + int[] memo = new int[amount + 1]; + return change(coins, amount, memo); + } + public int change(int[] coins, int amount, int[] memo){ + + if(amount == 0) + return 0; + if(amount < 0) + return -1; + + if(memo[amount] != 0) + return memo[amount]; + + int res = amount + 1; + int subproblem; + + for(int coin: coins){ + subproblem = change(coins, amount - coin, memo); + if(subproblem == -1) + continue; + + res = Math.min(res, 1 + subproblem); + } + + if(res == amount + 1){ + memo[amount] = -1; + } + else + memo[amount] = res; + + return memo[amount]; + } +} +``` + + + +## 动态规划 + 备忘录 + +```java +class Solution { + + public int coinChange(int[] coins, int amount) { + int max = amount + 1; + int[] memo = new int[max]; + + memo[0] = 0; + for(int i =1; i < max; i++){ + memo[i] = max; + } + + for(int i=1; i < max; i++){ + for(int coin: coins){ + if((i-coin) < 0) + continue; + + memo[i] = Math.min(memo[i], 1 + memo[i-coin]); + } + } + if(memo[amount] == max) + return -1; + return memo[amount]; + } +} +``` + diff --git "a/leetcode/438. \346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" "b/leetcode/438. \346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" new file mode 100644 index 0000000..77ea584 --- /dev/null +++ "b/leetcode/438. \346\211\276\345\210\260\345\255\227\347\254\246\344\270\262\344\270\255\346\211\200\346\234\211\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" @@ -0,0 +1,122 @@ +# [438. 找到字符串中所有字母异位词](https://leetcode-cn.com/problems/find-all-anagrams-in-a-string/) + +## 题目描述 + +给定一个字符串 s 和一个非空字符串 p,找到 s 中所有是 p 的字母异位词的子串,返回这些子串的起始索引。 + +字符串只包含小写英文字母,并且字符串 s 和 p 的长度都不超过 20100。 + +说明: + +- 字母异位词指字母相同,但排列不同的字符串。 + +- 不考虑答案输出的顺序。 + + + + + +**示例 1:** + +``` +输入: +s: "cbaebabacd" p: "abc" + +输出: +[0, 6] + +解释: +起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。 +起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。 +``` + + +示例 2: + +``` +输入: +s: "abab" p: "ab" + +输出: +[0, 1, 2] + +解释: +起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。 +起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。 +起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。 +``` + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/find-all-anagrams-in-a-string +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + + + +```java +class Solution { + public List findAnagrams(String s, String p) { + List res = new ArrayList<>(); + /* s为空,或长度小于p */ + if(s.length() == 0 || s.length() < p.length()) + return res; + + int[] window = new int[26]; + int[] needs = new int[26]; + + int valid = 0; + /* 统计目标字符 */ + for(int i = 0; i < p.length(); i++){ + needs[p.charAt(i) - 'a'] +=1; + } + int char_cnt = 0; + /* 计算目标字母种类数量 */ + for(int need: needs){ + if(need > 0) + char_cnt++; + } + /* 构建长度为 p.length()的初始窗口 */ + int left = 0, right = p.length() - 1; + for(int i = 0; i < p.length(); i++){ + int c = s.charAt(i) - 'a'; + if(needs[c] > 0){ + window[c]++; + if(window[c] == needs[c]) + valid++; + } + + } + if(valid == char_cnt) + res.add(left); + + /* 构滑动窗口,更新窗口内的数据 */ + while(right < s.length() - 1){ + /* 更新右边界 */ + right++; + int c = s.charAt(right) - 'a'; + + if(needs[c] > 0){ + window[c]++; + if(window[c] == needs[c]) + valid++; + } + + /* 更新左边界 */ + c = s.charAt(left) - 'a'; + left++; + if(needs[c] > 0){ + if(window[c] == needs[c]) + valid--; + window[c]--; + } + if(valid == char_cnt) + res.add(left); + } + return res; + } +} +``` + diff --git "a/leetcode/46. \345\205\250\346\216\222\345\210\227.md" "b/leetcode/46. \345\205\250\346\216\222\345\210\227.md" new file mode 100644 index 0000000..4e07e91 --- /dev/null +++ "b/leetcode/46. \345\205\250\346\216\222\345\210\227.md" @@ -0,0 +1,74 @@ +# [46. 全排列](https://leetcode-cn.com/problems/permutations/) + +给定一个 没有重复 数字的序列,返回其所有可能的全排列。 + +示例: + +``` +输入: [1,2,3] +输出: +[ + [1,2,3], + [1,3,2], + [2,1,3], + [2,3,1], + [3,1,2], + [3,2,1] +] +``` + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/permutations +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +**思路框架:** + +``` +result = [] +def backtrack(路径, 选择列表): + if 满足结束条件: + result.add(路径) + return + + for 选择 in 选择列表: + 做选择 + backtrack(路径, 选择列表) + 撤销选择 +``` + +**算法代码:** + +```java +class Solution { + public List> result = new LinkedList<>(); + public List> permute(int[] nums) { + LinkedList road = new LinkedList(); + + backtrack(road, nums); + return result; + } + + public void backtrack(LinkedList road, int[] nums){ + if(road.size() == nums.length){ + result.add(new ArrayList(road)); + return; + } + + for(int i = 0; i < nums.length; i++){ + if(road.contains(nums[i])) + continue; + + road.add(nums[i]); + backtrack(road, nums); + + road.removeLast(); + } + + } +} +``` + diff --git "a/leetcode/509. \346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md" "b/leetcode/509. \346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md" new file mode 100644 index 0000000..bf8f025 --- /dev/null +++ "b/leetcode/509. \346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md" @@ -0,0 +1,94 @@ +# 斐波那契数 + +斐波那契数,通常用 F(n) 表示,形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始,后面的每一项数字都是前面两项数字的和。也就是: + +``` +F(0) = 0,F(1) = 1 +F(n) = F(n - 1) + F(n - 2),其中 n > 1 +``` + + +给你 n ,请计算 F(n) 。 + + + +示例 1: + +``` +输入:2 +输出:1 +解释:F(2) = F(1) + F(0) = 1 + 0 = 1 +``` + +**示例 2:** + +``` +输入:3 +输出:2 +解释:F(3) = F(2) + F(1) = 1 + 1 = 2 +``` + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/fibonacci-number +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +### 递归解法 + +```java +class Solution { + + public int fib(int n) { + + int[] memo = new int[n + 1]; + + return helper(memo,n); + } + + public int helper(int[] memo, int n){ + + if(n == 0) return 0; + if(n == 1) return 1; + + if(memo[n] != 0) + return memo[n]; + + memo[n] = fib(n -1) + fib(n-2); + + return memo[n]; + } +} +``` + + + +### 动态规划解法 + +```java +class Solution { + + public int fib(int n) { + + int pre, curr, acc; + + if(n == 0) + return 0; + if(n == 1) + return 1; + + pre = 0; + curr = 1; + + for(int i = 2; i <= n; i++){ + acc = pre + curr; + pre = curr; + curr = acc; + } + return curr; + } +} +``` + diff --git "a/leetcode/53. \346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.md" "b/leetcode/53. \346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.md" new file mode 100644 index 0000000..b67d1c7 --- /dev/null +++ "b/leetcode/53. \346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.md" @@ -0,0 +1,90 @@ +# [53. 最大子序和](https://leetcode-cn.com/problems/maximum-subarray/) + +## 题目描述 + +给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。 + + + +示例 1: + +``` +输入:nums = [-2,1,-3,4,-1,2,1,-5,4] +输出:6 +解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。 +``` + +示例 2: + +``` +输入:nums = [1] +输出:1 +``` + +示例 3: + +``` +输入:nums = [0] +输出:0 +``` + +示例 4: + +``` +输入:nums = [-1] +输出:-1 +``` + +示例 5: + +``` +输入:nums = [-100000] +输出:-100000 +``` + + +提示: + +- 1 <= nums.length <= 3 * 104 + +- -105 <= nums[i] <= 105 + + + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/maximum-subarray +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +解题思路 + +``` +dp是以当前nums[i]为结尾的最大子序 +dp[i] 是nums[i]自己,或者加上dp[i-1] +``` + +实现代码 + +``` +class Solution { + public int maxSubArray(int[] nums) { + int len = nums.length; + if(len == 0) + return len; + + int[] dp = new int[len]; + + dp[0] = nums[0]; + int res = dp[0]; + for(int i = 1; i < len; i++){ + dp[i] = Math.max(nums[i], dp[i-1] + nums[i]);// dp[i] 是nums[i]或者加上dp[i-1] + res = Math.max(res, dp[i]);//遍历寻找最大的dp + } + return res; + } +} +``` + diff --git "a/leetcode/704. \344\272\214\345\210\206\346\237\245\346\211\276.md" "b/leetcode/704. \344\272\214\345\210\206\346\237\245\346\211\276.md" new file mode 100644 index 0000000..0a6a41a --- /dev/null +++ "b/leetcode/704. \344\272\214\345\210\206\346\237\245\346\211\276.md" @@ -0,0 +1,62 @@ +# [704. 二分查找](https://leetcode-cn.com/problems/binary-search/) + +## 题目描述 + +给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。 + +**示例 1:** + +``` +输入: nums = [-1,0,3,5,9,12], target = 9 +输出: 4 +解释: 9 出现在 nums 中并且下标为 4 +``` + +**示例 2:** + +``` +输入: nums = [-1,0,3,5,9,12], target = 2 +输出: -1 +解释: 2 不存在 nums 中因此返回 -1 +``` + +**提示:** + +1. 你可以假设 nums 中的所有元素是不重复的。 +2. n 将在 [1, 10000]之间。 +3. nums 的每个元素都将在 [-9999, 9999]之间。 + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/binary-search +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +```java +class Solution { + public int search(int[] nums, int target) { + int left, right, mid; + left = 0; + right = nums.length - 1; + + while(left <= right){ + mid = left + (right - left)/2; + + /* 搜索 右半区间 */ + if(nums[mid] < target) + left = mid + 1; + /* 搜索 左半区间 */ + if(nums[mid] > target) + right = mid - 1; + /* 找到目标target */ + if(nums[mid] == target) + return mid; + } + /* 未找到目标target */ + return -1; + } +} +``` + diff --git "a/leetcode/714. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.md" "b/leetcode/714. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.md" new file mode 100644 index 0000000..283b1e7 --- /dev/null +++ "b/leetcode/714. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.md" @@ -0,0 +1,67 @@ +# [714. 买卖股票的最佳时机含手续费](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/) + +## 题目描述 + +给定一个整数数组 prices,其中第 i 个元素代表了第 i 天的股票价格 ;非负整数 fee 代表了交易股票的手续费用。 + +你可以无限次地完成交易,但是你每笔交易都需要付手续费。如果你已经购买了一个股票,在卖出它之前你就不能再继续购买股票了。 + +返回获得利润的最大值。 + +**注意:** + +​ 这里的一笔交易指买入持有并卖出股票的整个过程,每笔交易你只需要为支付一次手续费。 + +**示例 1:** + +``` +输入: prices = [1, 3, 2, 8, 4, 9], fee = 2 +输出: 8 +解释: 能够达到的最大利润: +在此处买入 prices[0] = 1 +在此处卖出 prices[3] = 8 +在此处买入 prices[4] = 4 +在此处卖出 prices[5] = 9 +总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8. +``` + +**注意:** + +- 0 < prices.length <= 50000. +- 0 < prices[i] < 50000. +- 0 <= fee < 50000. + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +每次交易要支付手续费,只要把手续费从利润中减去即可。改写方程: + +``` +dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]) +dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i] - fee) +解释:相当于买入股票的价格升高了。 +在第一个式子里减也是一样的,相当于卖出股票的价格减小了。 +``` + +```java +class Solution { + public int maxProfit(int[] prices, int fee) { + int len = prices.length; + int dp_i_0 = 0, dp_i_1 = -prices[0]; + + for(int i = 0; i < len; i++) { + int tmp = dp_i_0; + + dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i] - fee); + dp_i_1 = Math.max(dp_i_1, tmp - prices[i]); + } + return dp_i_0; + } +} +``` + diff --git "a/leetcode/752. \346\211\223\345\274\200\350\275\254\347\233\230\351\224\201.md" "b/leetcode/752. \346\211\223\345\274\200\350\275\254\347\233\230\351\224\201.md" new file mode 100644 index 0000000..9b9b2cb --- /dev/null +++ "b/leetcode/752. \346\211\223\345\274\200\350\275\254\347\233\230\351\224\201.md" @@ -0,0 +1,133 @@ +# [752. 打开转盘锁](https://leetcode-cn.com/problems/open-the-lock/) + +你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转:例如把 '9' 变为 '0','0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。 + +锁的初始数字为 '0000' ,一个代表四个拨轮的数字的字符串。 + +列表 deadends 包含了一组死亡数字,一旦拨轮的数字和列表里的任何一个元素相同,这个锁将会被永久锁定,无法再被旋转。 + +字符串 target 代表可以解锁的数字,你需要给出最小的旋转次数,如果无论如何不能解锁,返回 -1。 + +**示例 1:** + +``` +输入:deadends = ["0201","0101","0102","1212","2002"], target = "0202" +输出:6 +解释: +可能的移动序列为 "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202"。 +注意 "0000" -> "0001" -> "0002" -> "0102" -> "0202" 这样的序列是不能解锁的, +因为当拨动到 "0102" 时这个锁就会被锁定。 +``` + +**示例 2:** + +``` +输入: deadends = ["8888"], target = "0009" +输出:1 +解释: +把最后一位反向旋转一次即可 "0000" -> "0009"。 +``` + +**示例 3:** + +``` +输入: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888" +输出:-1 +解释: +无法旋转到目标数字且不被锁定。 +``` + +**示例 4:** + +``` +输入: deadends = ["0000"], target = "8888" +输出:-1 +``` + +**提示:** + +1. 死亡列表 deadends 的长度范围为 [1, 500]。 +2. 目标数字 target 不会在 deadends 之中。 +3. 每个 deadends 和 target 中的字符串的数字会在 10,000 个可能的情况 '0000' 到 '9999' 中产生。 + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/open-the-lock +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + + + +**代码:** + +```java +class Solution { + public int openLock(String[] deadends, String target) { + + if(target.equals("0000") || target == null) + return 0; + + // Set visited = new LinkedList + Queue queue = new LinkedList<>(); + HashSet visited = new HashSet(); + + int depth = 0; + //把死亡数字加入已访问, + for(String deads : deadends){ + visited.add(deads); + } + queue.offer("0000"); + + while(!queue.isEmpty()){ + int b = queue.size(); + /* 遍历队列里的每一个元素 */ + for(int i = 0; i < b; i++){ + String cur = queue.poll(); + /* 防止重复访问 */ + if(visited.contains(cur)) + continue; + + /* 判断 是否到达终点*/ + if(cur.equals(target)) + return depth; + + /* 对每个元素的每一位的状态进行检查 */ + for(int j = 0; j < 4; j++){ + /* 状态 +1 */ + String up = plusOne(cur, j); + if(!visited.contains(up)) + queue.offer(up); + + /* 状态 -1 */ + String down = minusOne(cur, j); + if(!visited.contains(down)) + queue.offer(down); + } + visited.add(cur); + } + depth++; + } + return -1; + } + + public String plusOne(String s, int n){ + char[] ch = s.toCharArray(); + if(ch[n] == '9') + ch[n] = '0'; + else + ch[n] +=1; + return new String(ch); + } + public String minusOne(String s, int n){ + char[] ch = s.toCharArray(); + if(ch[n] == '0') + ch[n] = '9'; + else + ch[n] -=1; + return new String(ch); + } +} +``` + diff --git "a/leetcode/76. \346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" "b/leetcode/76. \346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" new file mode 100644 index 0000000..f54a78d --- /dev/null +++ "b/leetcode/76. \346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" @@ -0,0 +1,108 @@ +# [76. 最小覆盖子串](https://leetcode-cn.com/problems/minimum-window-substring/) + +## 题目 + +给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串,则返回空字符串 "" 。 + +注意:如果 s 中存在这样的子串,我们保证它是唯一的答案。 + + + +示例 1: + +``` +输入:s = "ADOBECODEBANC", t = "ABC" +输出:"BANC" +``` + + +示例 2: + +``` +输入:s = "a", t = "a" +输出:"a" +``` + + +提示: + +- 1 <= s.length, t.length <= 105 +- s 和 t 由英文字母组成 + +**进阶:** + +​ 你能设计一个在 o(n) 时间内解决此问题的算法吗? + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/minimum-window-substring +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + + + +## 题解 + +```java +class Solution { + public String minWindow(String s, String t) { + + int len = t.length(); + int[] need = new int[128]; + int[] window = new int[128]; + int char_cnt = 0; //字符的种数 + + for(int i = 0; i < len; i++) + /* 统计目标字符 每个类别的数量 */ + need[t.charAt(i)]++; + for(int i = 0; i < 128; i++){ + window[i] = 0; + if(need[i] > 0) + char_cnt++; + } + + int left = 0, right = 0; + int valid = 0; + int start=0; + len = Integer.MAX_VALUE; + + + while (right < s.length()){ + /* c是将要移入窗口的字符 */ + char c = s.charAt(right); + /* 窗口右边界右移 */ + right++; + + /* 进行窗口内数据的一系列更新 */ + if(need[c] > 0){ + window[c]++; + if(window[c] == need[c]) + valid++; + } + + /* 判断窗口左边界是否收缩 */ + while (valid == char_cnt){ + /* 更新最小覆盖子串 */ + if (right - left < len){ + len = right - left; + start = left; + } + + /* c是将要移出窗口的字符 */ + char d = s.charAt(left); + /* 窗口左边界右移 */ + left++; + + /* 进行窗口内数据的一系列更新 */ + if(need[d] > 0){ + if(window[d] == need[d]) + valid--; + window[d]--; + } + } + } + if (len == Integer.MAX_VALUE) + return ""; + return s.substring(start, start + len); + } +} +``` + diff --git "a/leetcode/LC25.K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250.java" "b/leetcode/LC25.K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250.java" new file mode 100644 index 0000000..e0c363e --- /dev/null +++ "b/leetcode/LC25.K \344\270\252\344\270\200\347\273\204\347\277\273\350\275\254\351\223\276\350\241\250.java" @@ -0,0 +1,68 @@ +/* +題目:25. K 个一组翻转链表 +给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。 +k 是一个正整数,它的值小于或等于链表的长度。 +如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。  + +示例: +给你这个链表:1->2->3->4->5 +当 k = 2 时,应当返回: 2->1->4->3->5 +当 k = 3 时,应当返回: 3->2->1->4->5 + +来源:力扣(LeetCode) +链接:https://leetcode-cn.com/problems/reverse-nodes-in-k-group +著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。 + */ + /* 題解 +将链表分为已翻转、待翻转和未翻转三部分,待翻转的k个节点作为子链表, +pre->子链表前一个,next->子链表后一个 start->子链表第一个, end->子链表最后一个, +翻转子链表, +连接三部分链表 + */ + +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode(int x) { val = x; } + * } + */ + +class Solution { + public ListNode reverseKGroup(ListNode head, int k) { + ListNode dummy = new ListNode(0); + dummy.next = head; + + ListNode pre = dummy; + ListNode end = dummy; + + while(end.next != null){ + //选k个 + for(int i = 0; i < k && end != null; i++) end = end.next; + if(end == null) break; + ListNode start = pre.next; + ListNode next = end.next; + end.next = null; + //翻转 + pre.next = Reverse(start); + + start.next = next; + pre = start; + end = pre; + } + return dummy.next; + } + public ListNode Reverse(ListNode head){ + ListNode pre = null; + ListNode current = head; + + while(current != null){ + ListNode temp = current.next; + current.next = pre; + pre = current; + current = temp; + } + return pre; + } +} \ No newline at end of file diff --git "a/\345\255\227\347\254\246\344\270\262.md" "b/\345\255\227\347\254\246\344\270\262.md" new file mode 100644 index 0000000..75f4ad7 --- /dev/null +++ "b/\345\255\227\347\254\246\344\270\262.md" @@ -0,0 +1,301 @@ +## 一、字符串面试题特点: + +1. 广泛性 + + - 字符串可以看作字符类型数组:与**数组排序、查找、调整**有关 + - 很多其他类型是面试题可以看作字符串类型是面试题 + + 注意:用Java实现字符串类型的题目时,需要掌握StringBuffer,StringBuilder类 和 toCharArray方法 + +2. 需要掌握的概念 + + - 回文 + - 字串(连续) + - 子序列(不连续) + - 前缀树(Trie树) + - 后缀树和后缀数组 + - 匹配 + - 字典序 + +3. 基本的操作 + + 1. 与数组相关的操作:增删改查 + 2. 字符的替换 + 3. 字符串的旋转 + + + +## 二、字符串题目的常见类型 + +1. **规则判断** + - 判断字符串是否符合整数的规则 + - 判断字符串是否符合浮点数的规则 + - 判断字符串是否符合回文字符串的规则 + - 。。。等等 +2. **数字运算** + - int 和 long 类型表达整数范围有限,所有经常用字符串实现大整数 + - 与大整数相关的加减乘除操作,需要模拟笔算的过程 +3. **与数组操作有关的类型** + - 与数组有关的排序、查找和交换操作 + - 快速排序的划分过程需要掌握和改写 +4. **字符计数** + - 哈希表 + - 固定长度数组;C/C++ (长度256),Java(长度65536) + - 滑动窗口问题、寻找无重复字符字串问题、计算变位词问题 +5. **动态规划类型** + - 最长公共子串 + - 最长公共子序列 + - 最长回文子串 + - 最长回文子序列 + - 。。。等 +6. **搜索类型** + - 宽度优先搜索 + - 深度优先搜索 +7. **使用高级算法与数据结构解决的问题** + - Manacher算法解决最长回文子串问题 + - KMP算法解决字符串匹配问题 + - 前缀树结构 + - 后缀树和后缀数组 + - **通常面试中很少出现** ,代码实现比较复杂 + + + +## 三、案例 + +#### 案例一、查找是否存在子树 + +![image-20200822110138742](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20200822110138742.png) + + + +##### 1. **普通解法**: 二叉树遍历 + 匹配问题 + +考察 t1 中一每个节点为头节点的字树是否与 t2 一致 + +普通解法的时间复杂度为 O(N * M),N 代表 t1 节点数,M 代表 t2节点数 + + + +##### 2. 最优解:二叉树序列化 + KMP算法 + +时间复杂度为 O(N + M) + +解题思路如下 + +![image-20200822111145488](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20200822111145488.png) + + + +#### 案例二、互为变形词 + +给定两个字符串str1和str2,如果str1和str2中出现的字符串种类一样且每种字符出现的次数也一样,那么str1与str2互为变形词,请实现函数判断两个字符串是否互为变形词 + +举例: + +str1= ”123“,str2=”231“,返回true; + +str1= ”123“,str2=”2331“,返回false; + +##### 解法: + +使用哈希表做字符统计 + +![image-20201216152430045](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201216152430045.png) + +可以使用固定长度的数组代替哈希表结构,世家复杂度为O(N),额外空间复杂度为O(N) + + + +#### 案例三、旋转词 + +如果一个字符串str,把字符串str前面任意的部分挪到后面去形成的字符串叫做str的旋转词。比如str=”1234“,str的旋转词有”1234“,”2341“,”3412“,”4123“。给定两个字符串a和b,请判断a和b是否互为旋转词。 + +举例: + +a=”cdab“,b=”abcd“。返回true; + +a=”1ab2“,b=”ab12“。返回false; + +a=”2ab1“,b=”ab12“。返回true; + +##### 解法: + +最优解时间复杂度为O(N) + +1. 判断str1与str2长度是否相等 +2. 如果长度相等,生成 **str1 + str1** 的大字符串 +3. 用KMP算法判断大字符串是否包含str2 + +**举例说明:** + +str1=”1 2 3 4“ + +str1 + str1 = ”1 2 3 4 1 2 3 4“ + +如果str1长度为N,在 str1 + str1 的字符串中,任意一个长度为N字串都是str1 是旋转词。 + + + +#### 案例四、字符串中单词间逆序 + +给定一个字符串str,请在单词间做逆序调整 + +**举例:** + +”pig loves dog“ 逆序成 ”dog loves pig“ + +"I'm a student." 逆序成 "student. a I'm" + +##### 解法:局部逆序 + +1. 实现将字符串局部所有字符串逆序的函数 f + +2. 利用 f 将字符串所有字符逆序 + + ”pig loves dog“ --> "god sevol gip" + +3. 找到逆序后的字符串中每一个单词的区域,利用 f 将每一个单词的区域逆序 + + "god sevol gip" --> ”dog loves pig“ + +#### 案例五、字符串移动子串 + +给定一个字符串str,和一个整数 i ,i 代表str中的位置,将str[0...i]移到右侧,str[i+1...N-1]移到左侧。 + +**举例:** + +str=”ABCDE“,i=2;将str调整为 ” DEABC“ + +要求,时间复杂度为O(N),额外空间复杂度为O(1). + +##### 解法:局部逆序 + +1. 将 str[0..i] 部分字符逆序 + + ”A B C D E“ --> ”C B A D E“ + +2. 将 str[i+1...N-1] 部分字符逆序 + + ”C B A D E“ --> ”C B A E D“ + +3. 将 str整体的字符逆序 + + ”C B A E D“ --> ”D E A B C“ + + + +#### 案例六、字符串拼接,字典序最小 + +给定一个字符串类型的数组strs,请找到一种拼接顺序,使得将所有字符串拼接起来组成的大字符串是所有可能性中字典序最小的,并返回这个大字符串。 + +**举例:** + +strs=[”abc“, "de"],可以拼接成 ”abcde“,也可以拼接成 ”deabc“,但是前者字典序更小,所以返回 ”abcde“。 + +strs=["b",“ba”],可以拼接成 ”bba“,也可以拼接成 ”bab“,但是后者字典序更小,所以返回 ”bab“。 + +##### 解法:实质是一种排序的实现 + +最优解时间复杂度为O(N*logN) + +**方案一、****(错误的)** + +根据单独每个字符串的字典序排序 + +![image-20201216161214358](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201216161214358.png) + + + +**方案二、把拼接后的大字符串进行比较** + +str1和str2按照如下方式进行比较 + +如果 str1 + str2 < str2 + str1,则str1放在前面;否则,str2放在前面。 + + + +#### 案例七、字符串替换 + +给定一个字符串str,将其中所以的空格字符串替换成 “%20”,假设str后面有足够的空间 + +**举例:** + +str=“a b c” + +##### 解法: + +1. 遍历str,发现空格的数量为2;所以str在替换后,长度为 5 + 2*2 = 9 +2. 从下标为8的位置开始拷贝,遇到字符直接拷贝,遇到空格则替换成相应的字符串,直到遇到第一个字符停止。过程如下: + +![image-20201216162237855](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201216162237855.png) + +![image-20201216162301314](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201216162301314.png) + +![image-20201216162335848](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201216162335848.png) + +![image-20201216162357599](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201216162357599.png) + + + +#### 案例八、括号配对 + +给定一个字符串str,判断是不是整体有效的括号字符串 + +**举例:** + +str= “()”,返回true。 + +str= “(()())”,返回true。 + +str= “(())”,返回true。 + +str= “())”,返回false。 + +str= “()(”,返回false。 + +str= “()a()”,返回false。 + +##### 解法: + +1. 整型变量num,代表 ”(“ 出现的次数与 ")" 出现的次数的差值。 +2. 遍历过程中,如果遇到 ”(“ 则 num++; +3. 遍历过程中,如果遇到 ”)“ 则 num--; +4. 遍历过程中,如果 num < 0,则直接返回 false; +5. 如果一直每出现情况4,则一直遍历下去; +6. 遍历完成后,如果 num==0,则返回true,否则返回false。 + + + +#### 案例九、求最长无重复字符字串长度 + +给定一个字符串str,返回str的最长无重复字符字串长度 + + **举例:** + +str = ”abcd“,返回4; + +str = ”abcb“,最长无重复字符字串为 ”abc“ ,返回3。 + + + +##### 解法: + +最优解,时间复杂度为O(N),额外时间复杂度为O(N)。 + +**求解过程:** + +求出以str中每个字符结尾的情况下,最长无重复字符字串的长度,并在其中找出最大值返回。 + +所需变量: + +- 哈希表map --> 统计了每种字符之前出现的位置 +- 整型变量pre --> 代表以s[i-1]结尾情况下,最长无重复字串的长度 + +情况一 + +![image-20201216170656623](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201216170656623.png) + +情况二 + +![image-20201216170751120](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201216170751120.png) + diff --git "a/\345\267\246\347\245\236\347\256\227\346\263\225\347\254\224\350\256\260/\345\267\246\347\245\236\345\210\235\347\272\247\347\256\227\346\263\225\347\254\224\350\256\260.md" "b/\345\267\246\347\245\236\347\256\227\346\263\225\347\254\224\350\256\260/\345\267\246\347\245\236\345\210\235\347\272\247\347\256\227\346\263\225\347\254\224\350\256\260.md" new file mode 100644 index 0000000..1bdf128 --- /dev/null +++ "b/\345\267\246\347\245\236\347\256\227\346\263\225\347\254\224\350\256\260/\345\267\246\347\245\236\345\210\235\347\272\247\347\256\227\346\263\225\347\254\224\350\256\260.md" @@ -0,0 +1,610 @@ +# 左神算法笔记-初级 + +###### 行列有序且递增,找数X: + +方法:从右上角开始找,比X大了,往左找,比X小了,往下找;越界了或到左下角了,则X不存在。 + +###### 判断一个链表是否为回文结构 + +【 题目】 给定一个链表的头节点head, 请判断该链表是否为回 +文结构。 例如: 1->2->1, 返回true。 1->2->2->1, 返回true。15->6->15, 返回true。 1->2->3, 返回false。 + +``` +Code_11_IsPalindromeList +``` + +**解法1**:辅助栈,**时间O(N),空间O(N)** + +全逆序,进行比较 + +> - 使用一个辅助栈,遍历链表,数据入栈; +> - 二次遍历链表,同时数据出栈,逐个进行比较; +> - 全部相等则为回文; + +**解法2**:快慢指针法,**时间O(N),空间O(N/2)** + +后半段逆序(**入栈**),与前半段比较 + +> - 慢指针走一步,快指针走两步; +> - 当快指针为空时,慢指针到达中点,慢指针数据开始入栈 +> - 再次遍历链表,同时数据出栈,逐个进行比较; +> - 全部相等则为回文; + +**进阶:** 如果链表长度为N, 时间复杂度达到O(N), 额外空间复杂度达到O(1) + +**最优解:**快慢指针法,**时间O(N),空间O(1)** + +后半段逆序(**使链表逆序**),与前半段比较 + +> - 慢指针走一步,快指针走两步; +> - 当快指针为空时,慢指针到达中点,慢指针出开始使链表逆序;例如 1 -> 2 -> 3 <- 4 <- 5 +> - 从两端遍历链表,逐个数据进行比较; +> - 全部相等则为回文; + + + +###### 将单向链表按某值划分成左边小、 中间相等、 右边大的形式 (荷兰国旗问题) + +【 题目】 给定一个单向链表的头节点head, 节点的值类型是整型, 再给定一个整 数pivot。 实现一个调整链表的函数, 将链表调整为左部分都是值小于 pivot的节点, 中间部分都是值等于pivot的节点, 右部分都是值大于 pivot的节点。 +除这个要求外, 对调整后的节点顺序没有更多的要求。 例如: 链表9->0->4->5->1, pivot=3。 调整后链表可以是1->0->4->9->5, 也可以是0->1->9->5->4。 总之, 满 足左部分都是小于3的节点, 中间部分都是等于3的节点( 本例中这个部分为空) , 右部分都是大于3的节点即可。 对某部分内部的节点顺序不做 要求。 + +**解法1:** (荷兰国旗问题) + +> - 把节点存成数组,用荷兰国旗问题的方法划分; +> - 划分完把数组串成链表。 + + + +**进阶:** 在原问题的要求之上再增加如下两个要求。 +在左、 中、 右三个部分的内部也做顺序要求, 要求每部分里的节点从左 到右的 +顺序与原链表中节点的先后次序一致。 例如: 链表9->0->4->5->1, pivot=3。 +调整后的链表是0->1->9->4->5。 在满足原问题要求的同时, 左部分节点从左到 +右为0、 1。 在原链表中也 是先出现0, 后出现1; 中间部分在本例中为空, 不再 +讨论; 右部分节点 从左到右为9、 4、 5。 在原链表中也是先出现9, 然后出现4, +最后出现5。 +如果链表长度为N, 时间复杂度请达到O(N), 额外空间复杂度请达到O(1)。 + +**解法:** 时间O(N), 空间O(1) + +> - 使用less与end1,equal与end2,more与end3,构建三个空链表; +> - 遍历链表,根据less、equal、more,将节点插入对应链表中; +> - 将三个链表依次链接起来; + +![image-20201024104814175](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201024104814175.png) + + + +###### 复制含有随机指针节点的链表 + +【 题目】 一种特殊的链表节点类描述如下: +public class Node { public int value; public Node next; + +public Node rand; + +public Node(int data) { this.value = data; } +} + +Node类中的value是节点值, next指针和正常单链表中next指针的意义一 样, 都指向下一个节点, rand指针是Node类中新增的指针, 这个指针可 能指向链表中的任意一个节点, 也可能指向null。 给定一个由Node节点类型组成的无环单链表的头节点head, 请实现一个 函数完成这个链表中所有结构的复制, 并返回复制的新链表的头节点。 + + + + **进阶:**不使用额外的数据结构, 只用有限几个变量, 且在时间复杂度为 O(N)内完成原问题要实现的函数。 + + + +###### 两个单链表相交的一系列问题 + +【 题目】 在本题中, 单链表可能有环, 也可能无环。 给定两个单链表的头节点 head1和head2, 这两个链表可能相交, 也可能不相交。 请实现一个函数, 如果两个链表相交, 请返回相交的第一个节点; 如果不相交, 返回null 即可。 要求: 如果链表1的长度为N, 链表2的长度为M, 时间复杂度请达到 O(N+M), 额外空间复杂度请达到O(1)。 + +**子问题1**. 判断单链表是否有环,有则输出第一个入环的节点 + +**解法1:**用Hashset/map + +> - 遍历链表,逐个判断set 中是否存在?不存在则存入key; +> +> - 若遇到null,则无环。 +> +> - 第一个重复的节点就是第一个入环的节点; +> +> + +**解法2:**快慢指针法 + +> - 慢指针走一步,快指针走两步; +> - 若快指针遇到null,则无环。 +> - 若两个指针相遇时,快指针从头节点开始遍历,快慢指针每次都走一步; +> - 两个指针再次相遇时,该节点就是第一个入环的节点。 + + + +**子问题2.** 判断两个无环单链表是否相交 + +**解法1:**用Hashset/map + +> - 遍历链表1存入map中; +> - 遍历链表2,判断节点是否存在map中; +> - 若不存在,则两链表不相交; +> - 第一个存在的节点即为相交的第一个节点。 + +**解法2:** + +> - 遍历两个链表获得len1、end1和len2、end2; +> - 若end1 != end2, 则不相交; +> - 把长的链表移动多出来的长度,然后两个链表同时遍历,第一个相遇的节点就是相交的第一个节点。 + + + +**子问题3**. 判断两个有环链表是否相交,相交则返回相交的第一个节点 + +分析:此时只存在以下三种情况 + +![image-20201024120803329](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201024120803329.png) + +**解法:** + +> - 通过子问题的方法分别获得两个链表的头节点head和第一个入环节点loop; +> - 若 loop1 = loop2,两链表为拓扑结构2,则用子问题2的方法获得head到loop的链表的相交的第一个节点。 +> - 若 loop1 != loop2,两链表为拓扑结构1或者3; +> - 让 loop1继续遍历; +> - 若遇到 loop2,则两链表为拓扑结构3,相交的第一个节点为 loop1 或 loop2; +> - 若未遇到 loop2,则两链表为拓扑结构1,两链表不相交。 + + + +###### 二叉树前序、中序、后序遍历 + +**递归:** + +```java +public static void OrderRecur(Node head) { + if (head == null) { + return; + } + System.out.print(head.value + " "); // prepreOrderRecur + preOrderRecur(head.left); + //System.out.print(head.value + " "); // inpreOrderRecur + preOrderRecur(head.right); + //System.out.print(head.value + " "); // pospreOrderRecur + } +``` + + + +**非递归:** 使用辅助栈 + +**前序遍历** + +> - 头节点入栈 +> - 出栈一个节点,该节点的**右孩子、左孩子依次入栈**; +> - 直到结束。 + +```java +Stack stack = new Stack(); +stack.add(head); +while (!stack.isEmpty()) { + head = stack.pop(); + System.out.print(head.value + " "); + if (head.right != null) { + stack.push(head.right); + } + if (head.left != null) { + stack.push(head.left); + } +} +``` + +**中序遍历** + +> - 当前节点不为空,节点入栈,然后访问其左孩子; +> - 当前节点为空,出栈一个节点,打印节点,然后访问其右孩子; + +```java +while (!stack.isEmpty() || head != null) { + if (head != null) { + stack.push(head); + head = head.left; + } else { + head = stack.pop(); + System.out.print(head.value + " "); + head = head.right; + } +``` + +**后序遍历** + +> - 头节点入栈s1; +> - 当s1不为空,出栈一个节点,入栈s2; +> - 若左孩子不空,则入栈s1; +> - 若右孩子不空,则入栈s1; +> - 当s1为空时,s2全部出栈,依次打印。 + +```java +Stack s1 = new Stack(); +Stack s2 = new Stack(); +s1.push(head); +while (!s1.isEmpty()) { + head = s1.pop(); + s2.push(head); + if (head.left != null) { + s1.push(head.left); + } + if (head.right != null) { + s1.push(head.right); + } +} +while (!s2.isEmpty()) { + System.out.print(s2.pop().value + " "); +} +``` + + + +###### 在二叉树中找到一个节点的后继节点 + +【 题目】 现在有一种新的二叉树节点类型如下: + +```java +public class Node { + public int value; + public Node left; + public Node right; + public Node parent; + public Node(int data) { + this.value = data; + } +} +``` + +该结构比普通二叉树节点结构多了一个指向父节点的parent指针。 假设有一 棵Node类型的节点组成的二叉树, 树中每个节点的parent指针都正确地指向 自己的父节点, 头节点的parent指向null。 只给一个在二叉树中的某个节点 node, 请实现返回node的后继节点的函数。 在二叉树的中序遍历的序列中, node的下一个节点叫作node的后继节点。 + +**分析:** + +1. 有右子树时,其后继节点为其右子树上最左边的节点; +2. 无右子树时, 判断当前节点是否为其父节点的左孩子,若不是则往父节点继续找;若是则此父节点为所求后继节点。 + +```java +if (node.right != null) { + return getLeftMost(node.right); +} else { + Node parent = node.parent; + while (parent != null && parent.left != node) { + node = parent; + parent = node.parent; + } + return parent; +} +``` + + + +**拓展**:寻找一个节点的前驱 + +**分析:** + +1. 有左子树时,其前驱节点为其左子树的最右边的节点; +2. 无左子树时,判断当前节点是否为其父节点的右孩子,若不是则往父节点继续找;若是则次父节点为所求前驱。 + + + +###### 二叉树的序列化和反序列化 + +```Code_04_SerializeAndReconstructTree``` + +**二叉树的序列化** + +分析: + +> - 遍历二叉树 +> - 不空,输出 "值_" ; +> - 空,输出 "#_"。 + +```java +public static Node reconByPreString(String preStr) { + String[] values = preStr.split("!"); + Queue queue = new LinkedList(); + for (int i = 0; i != values.length; i++) { + queue.offer(values[i]); + } + return reconPreOrder(queue); +} +``` + + + +**二叉树的反序列化** + +分析:如何序列化的就如何反序列化 + +```java +public static Node reconPreOrder(Queue queue) { + String value = queue.poll(); + if (value.equals("#")) { + return null; + } + Node head = new Node(Integer.valueOf(value)); + head.left = reconPreOrder(queue); + head.right = reconPreOrder(queue); + return head; +} +``` + + + +###### 判断一棵二叉树是否是平衡二叉树 + +==**二叉树通用递归套路**== 树型DP + +``` +列出可能性; +确定返回值类型; +递归{ + (决策过程) + 边界返回; + 得到子树信息; + 整合子树信息; + 加工出我的信息; + 往上返回; +} +``` + +```java +public static int getHeight(Node head, int level, boolean[] res) { + if (head == null) { + return level; + } + int lH = getHeight(head.left, level + 1, res); + if (!res[0]) { + return level; + } + int rH = getHeight(head.right, level + 1, res); + if (!res[0]) { + return level; + } + if (Math.abs(lH - rH) > 1) { + res[0] = false; + } + return Math.max(lH, rH); +} +``` + + + +###### 判断一棵树是否是搜索二叉树、 判断一棵树是否是完全二叉树 + +**判断一棵树是否是搜索二叉树** + +**分析:** + +> - 中序遍历,每个元素都比前一个元素大。 +> - 非递归版本比递归版本好改,在把打印元素改为与前元素比较; + + + +**判断一棵树是否是完全二叉树** + +**分析:**判断条件 + +> - 如果只有右孩子,直接返回false; +> - 从第一个孩子不全的节点的下一个节点开始,之后全是叶子节点。 + + + +4 + +1110 + + + +###### 已知一棵完全二叉树, 求其节点的个数 + +要求: 时间复杂度低于O(N), N为这棵树的节点个数 + +**分析:** + +> - +> - 若右子树到达了最底层,则左子树为满二叉树,除右子树外节点数为 2^n ;然后递归右子树; +> - 若右子树未到达最底层,则右子树为满二叉树,除左子树外节点数为 2^n;然后递归左子树; +> - 时间O((logN)^2) + +```java +public static int bs(Node node, int level, int h) { + // level 节点Node所在层,h 树的总高度 + if (level == h) { + return 1; + } + if (mostLeftLevel(node.right, level + 1) == h) { + return (1 << (h - level)) + bs(node.right, level + 1, h); + } else { + return (1 << (h - level - 1)) + bs(node.left, level + 1, h); + } +} +``` + + + +##### 初6 + +哈希函数 + +例如:大数据文件,查重,哈希函数进行分流 + + + +###### 6.1 设计RandomPool结构 + +【 题目】 设计一种结构, 在该结构中有如下三个功能: + +insert(key): 将某个key加入到该结构, 做到不重复加入。 + +delete(key): 将原本在结构中的某个key移除。 + +getRandom():等概率随机返回结构中的任何一个key。 + +【 要求】 Insert、delete和 getRandom方法的时间复杂度都是O(1) + +​ + +###### 6.2 布隆过滤器 + +用于解决爬虫去重,黑名单问题 + +有小的错误率 + + + +**黑名单问题** + +**哈希方法:** + +- URL -> hash -> hash code % m -> 0 ~ m-1 的位置(bit) + +**布隆过滤器:** + +- URL -> k 个 hash -> 描黑对应k个bit -> 生成黑名单 +- 查黑名单:URL -> k 个 hash -> 获得对应k个bit -> 全黑则在黑名单;不全黑则不在黑名单 + +注: + +1. bit 类型数组长度m与**样本量**、**失误率**有关 +2. bit 数组长度m为 $m = - (n*ln p)/(ln2)^2$ ,p为预期失误率,n为样本量 +3. hash函数个数k 为 k = ln2 * m / n ,经典值为13 +4. 真实失误率 + + + +###### 一致性哈希 + +应用:所有需要集群化抗压力的,都进行了一致性哈希的改造 + +![image-20201025170815269](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201025170815269.png) + + + +添加机器,数据迁移代价极低 + +![image-20201025171451071](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201025171451071.png) + + + +出现负载均衡问题 + +1. 初始机器负载不均衡 +2. 新增机器后负载不均衡 + + + +解决方法: + +引入虚拟节点,每个物理机器对应N个虚拟节点,由路由表决定虚拟节点所对应的物理机器。 + +![image-20201025172644261](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201025172644261.png) + + + + + +##### 基7 + +###### 认识并查集结构 + +1. 快速查找两个元素是否属于一个集合,isSameSet(A, B) +2. 合并两个元素各自的所属的集合,union(A, B) + + + +查找与合并52 + +![image-20201028155335801](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201028155335801.png) + + + +###### 岛问题(难) + +【题目】一个矩阵中只有0和1两种值, 每个位置都可以和自己的上、 下、 左、 右四个位置相连, 如果有一片1连在一起, 这个部分叫做一个岛, 求一个矩阵中有多少个岛? +举例: +0 0 1 0 1 0 +1 1 1 0 1 0 +1 0 0 1 0 0 +0 0 0 0 0 0 +这个矩阵中有三个岛。 + + + +**解法1: DFS思想,感染函数** + +> - 遍历每一个节点; +> - 当前节点为1,则进入感染函数; +> - 感染函数:节点为1则感染为2,然后递归地对其上下左右节点进行感染;其他情况则跳过; +> - 感染结束,岛的数量加1; +> - 继续遍历下一个节点。 + +![image-20201028161719919](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201028161719919.png) + +```java +public static int countIslands(int[][] m) { + if (m == null || m[0] == null) { + return 0; + } + int N = m.length; + int M = m[0].length; + int res = 0; + for (int i = 0; i < N; i++) { + for (int j = 0; j < M; j++) { + if (m[i][j] == 1) { + res++; + infect(m, i, j, N, M); + } + } + } + return res; +} + +public static void infect(int[][] m, int i, int j, int N, int M) { + if (i < 0 || i >= N || j < 0 || j >= M || m[i][j] != 1) { + return; + } + m[i][j] = 2; + infect(m, i + 1, j, N, M); + infect(m, i - 1, j, N, M); + infect(m, i, j + 1, N, M); + infect(m, i, j - 1, N, M); +} +``` + + + +**解法2:** 并行计算,并查集 + +> - 分块;并行计算每块的岛的数量 +> - 边界处理;使用并查集的方法,相邻节点为1且不是同一集合,则合并集合,岛数量-1;相邻节点为1且是同一集合或者节点值不同,则跳过。 + +![image-20201028170457291](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201028170457291.png) + + + + + +###### 前缀树 + +介绍前缀树 +何为前缀树? 如何生成前缀树? + +> - 字符串加的过程中,总是从头节点开始; +> +> - 依次看有没有沿途的路,如果有则复用,如果没有则新建 + +![image-20201028171035600](C:\Users\chiwai lee\AppData\Roaming\Typora\typora-user-images\image-20201028171035600.png) + + + +例子: +一个字符串类型的数组arr1, 另一个字符串类型的数组arr2。 + +1. arr2中有哪些字符, 是arr1中出现的? 请打印 +2. arr2中有哪些字符, 是作为arr1中某个字符串前缀出现的? 请 + 打印 + + + +###### 贪心策略 + diff --git "a/\345\267\246\347\245\236\347\256\227\346\263\225\347\254\224\350\256\260/\347\273\217\345\205\270\351\235\242\350\257\225\351\242\230.md" "b/\345\267\246\347\245\236\347\256\227\346\263\225\347\254\224\350\256\260/\347\273\217\345\205\270\351\235\242\350\257\225\351\242\230.md" new file mode 100644 index 0000000..fefc268 --- /dev/null +++ "b/\345\267\246\347\245\236\347\256\227\346\263\225\347\254\224\350\256\260/\347\273\217\345\205\270\351\235\242\350\257\225\351\242\230.md" @@ -0,0 +1,47 @@ +## 题一 + +**题目:** + + + +**题解:** + + + +**注释:** + + + +## 题二 + +**题目:** + +有一个长度为m的字符串aim,一个长度为n的字符串str,str是否存在长度的为m连续子串,且与aim具有相同的字符,字符顺序可以任意,若存在返回一个子串的开头的位置,若不存在则返回-1 + + + +**题解:** + +1. (==**不得分**==)遍历str字符串取长度为m的子串,排序后与排序后的aim作比较。时间复杂度为 O(n^3 * logN) +2. 字符串转char数组(toCharArray()),用count[256]记录str1字符出现的次数,遍历str2,对应位置减一,若出现负数,则str1与str2非同源异构;若没出现负数,则为同源异构.。时间复杂度 O(mn) +3. (**最优解**)建立一张欠债表,长度为m的窗口往右滑动,进一个字符,欠债表对应位置减一,出一个加一,出现负数时无效点数(inValidTimes)记录加一;负数转正时无效点数减一;R为右边界, + + + +**注释:** + + + +## 题三 + +**题目:** + +输入一个int类型的值N,构造一个长度为N的数组arr并返回。 + +要求:对任意的 I < k < j,都满足 arr[i] + arr[j] != arr[k] * 2 + +**题解:** + + + +**注释:** \ No newline at end of file diff --git "a/\345\270\270\350\200\203/NC140 \346\216\222\345\272\217.java" "b/\345\270\270\350\200\203/NC140 \346\216\222\345\272\217.java" new file mode 100644 index 0000000..65b848c --- /dev/null +++ "b/\345\270\270\350\200\203/NC140 \346\216\222\345\272\217.java" @@ -0,0 +1,49 @@ +import java.util.*; + + +public class Solution { + /** + * 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可 + * 将给定数组排序 + * @param arr int整型一维数组 待排序的数组 + * @return int整型一维数组 + */ + public int[] MySort (int[] arr) { + // write code here + quickSort(arr, 0, arr.length-1); + return arr; + } + + public void quickSort(int[] arr, int left, int right){ + + if(left < right){ + int point = partition(arr, left, right); + + quickSort(arr, left, point - 1); + quickSort(arr, point+ 1, right); + } + } + + public int partition(int[] arr, int left, int right){ + int partition_point = arr[left]; + + while(left < right){ + while(left < right && arr[right] >= partition_point){ + right--; + } + swap(arr, left, right); + + while(left < right && arr[left] < partition_point){ + left++; + } + swap(arr, left, right); + } + //返回分割点 + return left; + } + private void swap(int[] arr, int i, int j) { + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } +} \ No newline at end of file diff --git "a/\345\270\270\350\200\203/NC140 \346\216\222\345\272\217.md" "b/\345\270\270\350\200\203/NC140 \346\216\222\345\272\217.md" new file mode 100644 index 0000000..aa4fe8f --- /dev/null +++ "b/\345\270\270\350\200\203/NC140 \346\216\222\345\272\217.md" @@ -0,0 +1,74 @@ +## NC140 排序 + +### 题目描述 + +给定一个数组,请你编写一个函数,返回该数组排序后的形式。 + +**题解:** + +- **快速排序QuickSort**,O(nlogn),不稳定 +- **归并排序MergeSort**,O(nlogn),稳定 + +https://www.nowcoder.com/practice/2baf799ea0594abd974d37139de27896?tpId=190&tqId=36114&rp=1&ru=%2Factivity%2Foj&qru=%2Fta%2Fjob-code-high-rd%2Fquestion-ranking&tab=answerKey + + + +### **快速排序QuickSort** + +```java +import java.util.*; + +public class Solution { + /** + * 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可 + * 将给定数组排序 + * @param arr int整型一维数组 待排序的数组 + * @return int整型一维数组 + */ + public int[] MySort (int[] arr) { + // write code here + quickSort(arr, 0, arr.length-1); + return arr; + } + // 快排 + public void quickSort(int[] arr, int left, int right){ + + if(left < right){ + //分割数组,第一个元素作为分割点 + int point = partition(arr, left, right); + //递归调用,对左子数组进行快排 + quickSort(arr, left, point - 1); + //递归调用,对右子数组进行快排 + quickSort(arr, point+ 1, right); + } + } + //按分割点划分,左小右大 + public int partition(int[] arr, int left, int right){ + //第一个元素作为分割点 + int partition_point = arr[left]; + + while(left < right){ + //从最右边开始寻找第一个小于分割点的元素 + while(left < right && arr[right] >= partition_point){ + right--; + } + //交换 + swap(arr, left, right); + //从最左边开始寻找第一个大于分割点的元素 + while(left < right && arr[left] < partition_point){ + left++; + } + swap(arr, left, right); + } + //返回分割点 + return left; + } + //交换元素 + private void swap(int[] arr, int i, int j) { + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } +} +``` + diff --git "a/\345\270\270\350\200\203/NC4 \345\210\244\346\226\255\351\223\276\350\241\250\346\230\257\345\220\246\346\234\211\347\216\257.md" "b/\345\270\270\350\200\203/NC4 \345\210\244\346\226\255\351\223\276\350\241\250\346\230\257\345\220\246\346\234\211\347\216\257.md" new file mode 100644 index 0000000..a30e641 --- /dev/null +++ "b/\345\270\270\350\200\203/NC4 \345\210\244\346\226\255\351\223\276\350\241\250\346\230\257\345\220\246\346\234\211\347\216\257.md" @@ -0,0 +1,26 @@ +## NC4 判断链表中是否有环 + +**题目描述:** + +判断给定的链表中是否有环。如果有环则返回true,否则返回false。 + +你能给出空间复杂度![img](https://www.nowcoder.com/equation?tex=O(1)%5C)的解法么? + +**题解:** + +- **快慢指针法**,指针相遇则有环; +- **存放到集合中**, 节点重复则有环,Set set = new HashSet<>(); +- **逐个删除**,把节点next只想自己,出现cur = cur.next则有环; + + + +### **快慢指针法** + + + +### **存放到集合中** + + + +### **逐个删除** + diff --git "a/\345\270\270\350\200\203/NC50 \351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271k\344\270\252\344\270\200\347\273\204\347\277\273\350\275\254.java" "b/\345\270\270\350\200\203/NC50 \351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271k\344\270\252\344\270\200\347\273\204\347\277\273\350\275\254.java" new file mode 100644 index 0000000..644bd05 --- /dev/null +++ "b/\345\270\270\350\200\203/NC50 \351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271k\344\270\252\344\270\200\347\273\204\347\277\273\350\275\254.java" @@ -0,0 +1,54 @@ +import java.util.*; + +/* + * public class ListNode { + * int val; + * ListNode next = null; + * } + */ + +public class Solution { + /** + * + * @param head ListNode类 + * @param k int整型 + * @return ListNode类 + */ + public ListNode reverseKGroup (ListNode head, int k) { + // write code here + if(head == null || head.next == null || k==1) + return head; + ListNode pre = new ListNode(0); + ListNode cur = new ListNode(0); + ListNode tmp = null; + int len = 0; + ListNode res = new ListNode(0); + res.next = head; + pre = res; + cur = head; + + while(head != null){ + len++; + head = head.next; + } + //分段使用头插法将链表反序 + for(int i = 0; i < len/k; i++){ + //pre作为每一小段链表的头节点,负责衔接 + for(int j = 1; j < k; j++){ + tmp = cur.next; + cur.next = tmp.next; + //相当于头插法,注意: + //temp.next = cur是错误的,temp需要连接的不是前一节点,而是子序列的头节点 + tmp.next = pre.next; + pre.next = tmp; +// cur = tmp; + } + //每个子序列反序完成后,pre,cur需要更新至下一子序列的头部 + pre = cur; + cur = cur.next; + } + return res.next; + } + + +} \ No newline at end of file diff --git "a/\345\270\270\350\200\203/temp-test.java" "b/\345\270\270\350\200\203/temp-test.java" new file mode 100644 index 0000000..06f6e59 --- /dev/null +++ "b/\345\270\270\350\200\203/temp-test.java" @@ -0,0 +1,28 @@ +class Solution { + public List> result = new LinkedList<>(); + public List> permute(int[] nums) { + LinkedList road = new LinkedList(); + + backtrack(road, nums); + return result; + } + + public void backtrack(List road, int[] nums){ + if(road.size() == nums.length){ + result.add(new ArrayList(road)); + return; + } + int num; + for(int i = 0; i < nums.length; i++){ + num = nums[i]; + if(road.contains(num)) + continue; + + road.add(num); + backtrack(road, nums); + + road.remove(num); + } + + } +} \ No newline at end of file diff --git "a/\347\256\227\346\263\225\345\260\217\346\212\204/\350\247\243\351\242\230\345\245\227\350\267\257\346\241\206\346\236\266.md" "b/\347\256\227\346\263\225\345\260\217\346\212\204/\350\247\243\351\242\230\345\245\227\350\267\257\346\241\206\346\236\266.md" new file mode 100644 index 0000000..3455d50 --- /dev/null +++ "b/\347\256\227\346\263\225\345\260\217\346\212\204/\350\247\243\351\242\230\345\245\227\350\267\257\346\241\206\346\236\266.md" @@ -0,0 +1,278 @@ +# 解题套路与框架 + + + +## 动态规划 + +动态规划三要素: + +- **重叠子问题** + +- **最优子结构** + +- ==**状态转移方程**==(最难) + + + +辅助思考状态转移方程的思维框架: + +**明确 base case -> 明确「状态」-> 明确「选择」 -> 定义 dp 数组/函数的含义**。 + +**动态规划算法的框架:** + +```python +# 初始化 base case +dp[0][0][...] = base +# 进行状态转移 +for 状态1 in 状态1的所有取值: + for 状态2 in 状态2的所有取值: + for ... + dp[状态1][状态2][...] = 求最值(选择1,选择2...) +``` + +**动态规划问题最困难的就是写出这个暴力解,即状态转移方程。只要写出暴力解,优化方法无非是用==备忘录==或者 ==DP table==** + +注: + +但凡遇到需要递归的问题,最好都画出递归树,这对你分析算法的复杂度,寻找算法低效的原因都有巨大帮助。 + + + +## 回溯算法 + +回溯算法其实就是我们常说的 DFS 算法,本质上就是一种暴力穷举算法。**解决一个回溯问题,实际上就是一个决策树的遍历过程**。 + +你只需要思考 3 个问题: + +1、路径:也就是已经做出的选择。 + +2、选择列表:也就是你当前可以做的选择。 + +3、结束条件:也就是到达决策树底层,无法再做选择的条件。 + +**回溯算法的框架:** + +```python +result = [] +def backtrack(路径, 选择列表): + if 满足结束条件: + result.add(路径) + return + + for 选择 in 选择列表: + 做选择 + backtrack(路径, 选择列表) + 撤销选择 +``` + +**其核心就是 for 循环里面的递归,在递归调用之前「做选择」,在递归调用之后「撤销选择」**,特别简单。 + +**写 `backtrack` 函数时,需要维护走过的「路径」和当前可以做的「选择列表」,当触发「结束条件」时,将「路径」记入结果集**。 + + + + + +## BFS算法 + +**问题的本质就是让你在一幅「图」中找到从起点 `start` 到终点 `target` 的最近距离。** + +**BFS算法的框架:** + +```java +// 计算从起点 start 到终点 target 的最近距离 +int BFS(Node start, Node target) { + Queue q; // 核心数据结构 + Set visited; // 避免走回头路 + + q.offer(start); // 将起点加入队列 + visited.add(start); + int step = 0; // 记录扩散的步数 + + while (q not empty) { + int sz = q.size(); + /* 将当前队列中的所有节点向四周扩散 */ + for (int i = 0; i < sz; i++) { + Node cur = q.poll(); + /* 划重点:这里判断是否到达终点 */ + if (cur is target) + return step; + /* 将 cur 的相邻节点加入队列 */ + for (Node x : cur.adj()){ + if (x not in visited) { + q.offer(x); + visited.add(x); + } + } + } + /* 划重点:更新步数在这里 */ + step++; + } +} +``` + +BFS 算法还有一种稍微高级一点的优化思路:**双向 BFS**,可以进一步提高算法的效率。 + +**传统的 BFS 框架就是从起点开始向四周扩散,遇到终点时停止;而双向 BFS 则是从起点和终点同时开始扩散,当两边有交集的时候停止**。 + +**不过,双向 BFS 也有局限,因为你必须知道终点在哪里**。 + + + +## 二分查找算法 + +**思路很简单,细节是魔鬼**。二分查找真正的坑根本就不是整型溢出的 bug那个细节问题,而是在于**到底要给 `mid` 加一还是减一,while 里到底用 `<=` 还是 `<`**。 + +![img](https://labuladong.github.io/algo/pictures/%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE/poem.png) + + + +**二分查找框架:** + +```java +int binarySearch(int[] nums, int target) { + int left = 0, right = ...; + + while(...) { + int mid = left + (right - left) / 2; + if (nums[mid] == target) { + ... + } else if (nums[mid] < target) { + left = ... + } else if (nums[mid] > target) { + right = ... + } + } + return ...; +} +``` + +**一个技巧是:不要出现 else,而是把所有情况用 else if 写清楚,这样可以清楚地展现所有细节**。 + + + +## 滑动窗口算法 + +![img](https://labuladong.github.io/algo/pictures/slidingwindow/poem.png) + +关于双指针的**快慢指针**和**左右指针**的用法,可以参见前文 [双指针技巧汇总](https://labuladong.github.io/algo/算法思维系列/双指针技巧.html) + +**滑动窗口算法的代码框架:** + +```java +/* 滑动窗口算法框架 */ +void slidingWindow(string s, string t) { + unordered_map need, window; + for (char c : t) need[c]++; + + int left = 0, right = 0; + int valid = 0; + while (right < s.size()) { + // c 是将移入窗口的字符 + char c = s[right]; + // 右移窗口 + right++; + // 进行窗口内数据的一系列更新 + ... + + /*** debug 输出的位置 ***/ + printf("window: [%d, %d)\n", left, right); + /********************/ + + // 判断左侧窗口是否要收缩 + while (window needs shrink) { + // d 是将移出窗口的字符 + char d = s[left]; + // 左移窗口 + left++; + // 进行窗口内数据的一系列更新 + ... + } + } +} +``` + +**其中两处 `...` 表示的更新窗口数据的地方,到时候直接往里面填就行了** + + + +## 股票买卖 + +### 穷举框架 + +要穷举所有「状态」,穷举的目的是根据对应的「选择」更新状态。 + +``` +for 状态1 in 状态1的所有取值: + for 状态2 in 状态2的所有取值: + for ... + dp[状态1][状态2][...] = 择优(选择1,选择2...) +``` + +**这个问题的「状态」有三个**,第一个是天数,第二个是允许交易的最大次数,第三个是当前的持有状态(即之前说的 rest 的状态,我们不妨用 1 表示持有,0 表示没有持有)。然后我们用一个三维数组就可以装下这几种状态的全部组合: + +``` +dp[i][k][0 or 1] +0 <= i <= n-1, 1 <= k <= K +n 为天数,大 K 为最多交易数 +此问题共 n × K × 2 种状态,全部穷举就能搞定。 + +for 0 <= i < n: + for 1 <= k <= K: + for s in {0, 1}: + dp[i][k][s] = max(buy, sell, rest) +``` + +用自然语言描述出每一个状态的含义,比如说 `dp[3][2][1]` 的含义就是:今天是第三天,我现在手上持有着股票,至今最多进行 2 次交易。 + +我们想求的最终答案是 dp\[n - 1]\[K][0],即最后一天,最多允许 K 次交易,最多获得多少利润。 + +### 状态转移框架 + +**状态转移图** + +![image-20210408094643784](C:\Users\chiwailee\AppData\Roaming\Typora\typora-user-images\image-20210408094643784.png) + +通过这个图可以很清楚地看到,每种状态(0 和 1)是如何转移而来的。根据这个图,我们来写一下状态转移方程: + +``` +dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]) + max( 选择 rest , 选择 sell ) + +解释:今天我没有持有股票,有两种可能: +要么是我昨天就没有持有,然后今天选择 rest,所以我今天还是没有持有; +要么是我昨天持有股票,但是今天我 sell 了,所以我今天没有持有股票了。 + +dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]) + max( 选择 rest , 选择 buy ) + +解释:今天我持有着股票,有两种可能: +要么我昨天就持有着股票,然后今天选择 rest,所以我今天还持有着股票; +要么我昨天本没有持有,但今天我选择 buy,所以今天我就持有股票了。 +``` + +**状态转移方程:** + +``` +base case: +dp[-1][k][0] = dp[i][0][0] = 0 +dp[-1][k][1] = dp[i][0][1] = -infinity + +状态转移方程: +dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]) +dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]) +``` + +**注意:**状态转移方程,新状态只和相邻的一个状态有关,其实不用整个 dp 数组,只需要一个变量储存相邻的那个状态就足够了,这样可以把空间复杂度降到 O(1) + +```java +tmp = dp_i_0; +// dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]) +dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]); +// dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i]) +dp_i_1 = Math.max(dp_i_1, tmp - prices[i]); +``` + + + +## 算法 \ No newline at end of file diff --git "a/\351\207\215\347\202\271\347\261\273\345\236\213.md" "b/\351\207\215\347\202\271\347\261\273\345\236\213.md" new file mode 100644 index 0000000..13906e9 --- /dev/null +++ "b/\351\207\215\347\202\271\347\261\273\345\236\213.md" @@ -0,0 +1,12 @@ +## 编程题重点类型 + + + +1. 字符串处理(排序,特定位置增删改查,比较) +2. 数组 +3. 动态规划 +4. 最短路径 +5. 链表 +6. 栈 +7. 队列 +8. 数学计算 \ No newline at end of file