1 数组

1.1 二分查找

第一种写法：我们定义 target 是在一个在左闭右闭的区间里，也就是[left, right] 。区间的定义这就决定了二分法的代码应该如何写，因为定义target在[left, right]区间，所以有如下三点：

• while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=。
• if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1。
• if (nums[middle] < target) left 要赋值为 middle + 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间开始下标位置就是 middle + 1。

第二种写法：如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]。

1.2 双指针法

删除元素、移动数组元素、比较元素等涉及到数组的同时操作

• 要知道数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。
• 一般采用双指针法，快指针遍历目标值，慢指针实现记录更新后数组最右端（新数组长度）

1.3 滑动窗口

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

（个人感觉滑动窗口其实就是一种双指针的运用，只不过针对的题型不一样，滑动窗口一般针对连续一个范围（窗口）的数据的和之类的题）。

滑动窗口需要关注的问题：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

1.4 模拟行为

螺旋矩阵：模拟顺时针画矩阵的过程

• 填充上行从左到右
• 填充右列从上到下
• 填充下行从右到左
• 填充左列从下到

2 链表

2.1 构造链表

public class ListNode {// 结点的值int val;// 下一个结点ListNode next;// 节点的构造函数(无参)public ListNode() {}// 节点的构造函数(有一个参数)public ListNode(int val) {this.val = val;}// 节点的构造函数(有两个参数)public ListNode(int val, ListNode next) {this.val = val;this.next = next;}
}

2.2 删除链表元素

这里就涉及如下链表操作的两种方式：

• 直接使用原来的链表来进行删除操作。
• 设置一个虚拟头结点在进行删除操作。（主要方便用于移除头节点）

2.3 设计链表

• 获取链表第index个节点的数值
• 在链表的最前面插入一个节点
• 在链表的最后面插入一个节点
• 在链表第index个节点前面插入一个节点
• 删除链表的第index个节点

单链表

//单链表
class ListNode {int val;ListNode next;ListNode(){}ListNode(int val) {this.val=val;}
}
class MyLinkedList {//size存储链表元素的个数int size;//虚拟头结点ListNode head;//初始化链表public MyLinkedList() {size = 0;head = new ListNode(0);}//获取第index个节点的数值public int get(int index) {//如果index非法，返回-1if (index < 0 || index >= size) {return -1;}ListNode currentNode = head;//包含一个虚拟头节点，所以查找第 index+1 个节点for (int i = 0; i <= index; i++) {currentNode = currentNode.next;}return currentNode.val;}//在链表最前面插入一个节点public void addAtHead(int val) {addAtIndex(0, val);}//在链表的最后插入一个节点public void addAtTail(int val) {addAtIndex(size, val);}// 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点// 如果 index 大于链表的长度，则返回空public void addAtIndex(int index, int val) {if (index > size) {return;}if (index < 0) {index = 0;}size++;//找到要插入节点的前驱ListNode pred = head;for (int i = 0; i < index; i++) {pred = pred.next;}ListNode toAdd = new ListNode(val);toAdd.next = pred.next;pred.next = toAdd;}//删除第index个节点public void deleteAtIndex(int index) {if (index < 0 || index >= size) {return;}size--;ListNode pred = head;for (int i = 0; i < index; i++) {pred = pred.next;}pred.next = pred.next.next;}
}

双链表

class MyLinkedList {class ListNode {int val;ListNode next,prev;ListNode(int x) {val = x;}}int size;ListNode head,tail;//Sentinel node/** 初始化双向链表. */public MyLinkedList() {size = 0;head = new ListNode(0);tail = new ListNode(0);head.next = tail;tail.prev = head;}/** 获取链表第index个节点的数值.，如果不存在，返回-1*/public int get(int index) {if(index < 0 || index >= size){return -1;}ListNode cur = head;// 通过判断 index < (size - 1) / 2 来决定是从头结点还是尾节点遍历，提高效率if(index < (size - 1) / 2){for(int i = 0; i <= index; i++){cur = cur.next;}            }else{cur = tail;for(int i = 0; i <= size - index - 1; i++){cur = cur.prev;}}return cur.val;}/** 在链表的最前面插入一个节点. */public void addAtHead(int val) {ListNode cur = head;ListNode newNode = new ListNode(val);newNode.next = cur.next;cur.next.prev = newNode;cur.next = newNode;newNode.prev = cur;size++;}/** 在链表的最后面插入一个节点. */public void addAtTail(int val) {ListNode cur = tail;ListNode newNode = new ListNode(val);newNode.next = tail;newNode.prev = cur.prev;cur.prev.next = newNode;cur.prev = newNode;size++;}/** 在链表第index个节点前面插入一个节点，如果index等于链表长度，则加在末尾，如果大于链表长度，则不加入，如果小于0，则加在链表头部 */public void addAtIndex(int index, int val) {if(index > size){return;}if(index < 0){index = 0;}ListNode cur = head;for(int i = 0; i < index; i++){cur = cur.next;}ListNode newNode = new ListNode(val);newNode.next = cur.next;cur.next.prev = newNode;newNode.prev = cur;cur.next = newNode;size++;}/** 删除链表的第index个节点 */public void deleteAtIndex(int index) {if(index >= size || index < 0){return;}ListNode cur = head;for(int i = 0; i < index; i++){cur = cur.next;}cur.next.next.prev = cur;cur.next = cur.next.next;size--;}
}

2.4 翻转链表

// 双指针
class Solution {public ListNode reverseList(ListNode head) {ListNode prev = null;ListNode cur = head;ListNode temp = null;while (cur != null) {temp = cur.next;// 保存下一个节点cur.next = prev;prev = cur;cur = temp;}return prev;}
}

2.5 两两交换链表中的节点

// 虚拟头结点
class Solution {public ListNode swapPairs(ListNode head) {ListNode dummyNode = new ListNode(0);dummyNode.next = head;ListNode prev = dummyNode;while (prev.next != null && prev.next.next != null) {ListNode temp = head.next.next; // 缓存 nextprev.next = head.next;          // 将 prev 的 next 改为 head 的 nexthead.next.next = head;          // 将 head.next(prev.next) 的next，指向 headhead.next = temp;               // 将head 的 next 接上缓存的tempprev = head;                    // 步进1位head = head.next;               // 步进1位}return dummyNode.next;}
}

// 递归版本
class Solution {public ListNode swapPairs(ListNode head) {// base case 退出提交if(head == null || head.next == null) return head;// 获取当前节点的下一个节点ListNode next = head.next;// 进行递归ListNode newNode = swapPairs(next.next);// 这里进行交换next.next = head;head.next = newNode;return next;}
} 

2.6 删除链表中的第N个节点

• 双指针的经典应用，如果要删除倒数第n个节点，让fast移动n+1步，然后让fast和slow同时移动，直到fast指向链表末尾，删掉slow所指向的节点就可以了。
• PS：（为什么fast移动n+1步呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作））。

class Solution {public ListNode removeNthFromEnd(ListNode head, int n) {ListNode dummy = new ListNode(-1);dummy.next = head;ListNode slow = dummy;ListNode fast = dummy;while (n-- > 0) {fast = fast.next;}// 记住 待删除节点slow 的上一节点ListNode prev = null;while (fast != null) {prev = slow;slow = slow.next;fast = fast.next;}// 上一节点的next指针绕过 待删除节点slow 直接指向slow的下一节点prev.next = slow.next;// 释放 待删除节点slow 的next指针, 这句删掉也能ACslow.next = null;return dummy.next;}
}

2.7 链表相交

当求两个链表是否相交的时候，若相交，必然从某一结点开始后面的节点都相同，且相同部分的节点数必然小于等于A/B链表中较小的一个长度。因此，我们求出两个链表的长度，并求出两个链表长度的差值，然后让较长的链表表头移动到和较短链表头部对齐的位置（如图）。

此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。 否则循环退出返回空指针。

public class Solution {public ListNode getIntersectionNode(ListNode headA, ListNode headB) {ListNode curA = headA;ListNode curB = headB;int lenA = 0, lenB = 0;while (curA != null) { // 求链表A的长度lenA++;curA = curA.next;}while (curB != null) { // 求链表B的长度lenB++;curB = curB.next;}curA = headA;curB = headB;// 让curA为最长链表的头，lenA为其长度if (lenB > lenA) {//1. swap (lenA, lenB);int tmpLen = lenA;lenA = lenB;lenB = tmpLen;//2. swap (curA, curB);ListNode tmpNode = curA;curA = curB;curB = tmpNode;}// 求长度差int gap = lenA - lenB;// 让curA和curB在同一起点上（末尾位置对齐）while (gap-- > 0) {curA = curA.next;}// 遍历curA 和 curB，遇到相同则直接返回while (curA != null) {if (curA == curB) {return curA;}curA = curA.next;curB = curB.next;}return null;}
}

2.8 环形链表

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

主要考察两知识点：

• 判断链表是否环
• 如果有环，如何找到这个环的入口

2.8.1 判断链表是否有环

使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。

2.8.2 找到这个环的入口

相遇时： slow指针走过的节点数为 :  x + y， fast指针走过的节点数 ：x + y + n (y + z)，因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2 ：(x + y) * 2 = x + y + n (y + z)，两边消掉一个（x+y）:  x + y = n (y + z)，因为要找环形的入口，那么要求的是x，因为x表示头结点到环形入口节点的的距离。将x单独放在左面：x = n (y + z) - y，整理公式之后为如下公式：x = (n - 1) (y + z) + z ，这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。

3 哈希表

一般哈希表都是用来快速判断一个元素是否出现集合里。哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

常见的三种哈希结构

• 数组：当需要保存的值知道最大值时，可以用数组来代替哈希表，比如只有小写字母或大写字母。
• set （集合）：当所存数值无界限的时候，用set，和数组一样，只能存值。

//创建Set集合
Set<Integer> record = new HashSet<>();
//判断Set集合是否包含value
record.contains(value)
//添加元素到集合
record.add(value);
//删除元素
record.remove();
//计算大小
record.size();

• map(映射）：可以存键值对，且长度无限制，但是开销大。

//创建Map
Map<Integer, String> hashmap = new HashMap<Integer, String>();
//判断hashmap是否包含key键​
hashmap.containsKey(key);
//判断hashmap是否包含value值
hashmap.containsValue();
//添加键值
hashmap.put(key,value);
​//移除map中key
hashmap.remove(key);
//清楚map
hashmap.clear();
//map大小
hashmap.size();
//判断是否为空
hashmap.isEmpty();
//获取指定key的value，如果没有这个key，则返回默认值；
getOrDefault(key,默认值);

4 字符串

StringBuffer字符串缓冲区（线程安全）方法：

• append：向序列中追加元素
• reverse：将序列中元素反转
• delete(int start, int end)：移除此序列的子字符串中的字符
• deleteCharAt(int a)：删除指定下标的字符
• insert（位置，元素）：向序列中指定位置插入元素
• replace（int start, int end, String str）：用指定的str替换序列中start到end的字符
• capacity()：返回当前容量
• int length()：返回长度（字符数）
• charAt(int index)：返回指定索引处值
• indexOf(String str)：返回第一次出现该字符的索引
• int indexOf(String str, int fromIndex)：从指定下标开始，返回第一次出现该字符的索引
• int lastIndexOf(String str)：返回最右边出现的指定子字符串在此字符串中的索引
• substring(int start, int end)：返回一个新的 String，它包含此序列当前所包含的字符子序列
• toString()：返回此序列中数据的字符串表示形式

String字符串常用操作：

• length()：返回字符串长度
• string1.concat(string2)：连接字符串string1和string2
• charAt(int index)：返回指定索引处的字符
• setCharAt(index,String)；将index处的字符替换为String
• endsWith(String s)：判断是否以某字符结束
• startsWith(String s)：是否以指定前缀开始
• equals(Object s)：将字符串与指定对象做比较，是否相等
• indexOf(String s)：返回指定字符串在字符串中第一次出现的位置
• split(String s)：根据指定的正则表达式匹配拆分字符串，返回字符串数组
• substring(int a,int b)：返回从a到b新的字符串
• toCharArray()：将字符串转换为字符数组
• trim()：去除字符串首尾空格
• contains(char s)：判断是否包含指定的字符系列
• isEmpty()：判断字符串是否为空

LinkedList常用操作：

• add() / addLast) / offer() / offerLast()：在末尾添加元素
• add(index , object)：在指定下表处添加元素
• addFirst() / offerFirst()：在头部添加元素
• removeFirst()：移除头部元素
• remove / removeLast()：移除末尾元素
• getFirst()：获取头部元素
• get / getLast()：获取末尾元素
• poll() ：删除并返回第一个元素
• peek()：返回第一个元素
• size()：返回链表元素个数

ArrayList常用操作：

• add():添加元素
• clear():清楚所有元素
• contains():是否包含某个元素
• get():获得某个元素
• indexOf():返回指定值索引
• remove():移除元素
• size():列表大小
• isEmpty():是否为空
• subList():截取列表
• set():设置值
• sort():排序
• toArray():将 arraylist 转换为数组
• toString():将 arraylist 转换为字符串

ArrayDeque常用方法：

• addFirst(E e)在数组前面添加元素
• addLast(E e)在数组后面添加元素
• offerFirst(E e) 在数组前面添加元素，并返回是否添加成功
• offerLast(E e) 在数组后天添加元素，并返回是否添加成功
• removeFirst()删除第一个元素，并返回删除元素的值,如果元素为null，将抛出异常
• pollFirst()删除第一个元素，并返回删除元素的值，如果元素为null，将返回null
• removeLast()删除最后一个元素，并返回删除元素的值，如果为null，将抛出异常
• pollLast()删除最后一个元素，并返回删除元素的值，如果为null，将返回null
• removeFirstOccurrence(Object o) 删除第一次出现的指定元素
• removeLastOccurrence(Object o) 删除最后一次出现的指定元素
• getFirst() 获取第一个元素,如果没有将抛出异常
• getLast() 获取最后一个元素，如果没有将抛出异常
• add(E e) 在队列尾部添加一个元素
• offer(E e) 在队列尾部添加一个元素，并返回是否成功
• remove() 删除队列中第一个元素，并返回该元素的值，如果元素为null，将抛出异常(其实底层调用的是removeFirst())
• poll()  删除队列中第一个元素，并返回该元素的值,如果元素为null，将返回null(其实调用的是pollFirst())
• element() 获取第一个元素，如果没有将抛出异常
• peek() 获取第一个元素，如果返回null

Stack(栈)常用方法：

• empty() ：测试栈是否为空
• peek( )：查看堆栈顶部的对象，但不从堆栈中移除它
• pop( )：移除堆栈顶部的对象，并作为此函数的值返回该对象
• push(Object element)：把项压入堆栈顶部
• search(Object element)：返回对象在堆栈中的位置，以 1 为基数

5 栈与队列

队列是先进先出，栈是先进后出。

栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。

5.1 用栈实现队列

• push(x) -- 将一个元素放入队列的尾部。
• pop() -- 从队列首部移除元素。
• peek() -- 返回队列首部的元素。
• empty() -- 返回队列是否为空。

class MyQueue {Stack<Integer> stackIn;Stack<Integer> stackOut;/** Initialize your data structure here. */public MyQueue() {stackIn = new Stack<>(); // 负责进栈stackOut = new Stack<>(); // 负责出栈}/** Push element x to the back of queue. */public void push(int x) {stackIn.push(x);}/** Removes the element from in front of queue and returns that element. */public int pop() {    dumpstackIn();return stackOut.pop();}/** Get the front element. */public int peek() {dumpstackIn();return stackOut.peek();}/** Returns whether the queue is empty. */public boolean empty() {return stackIn.isEmpty() && stackOut.isEmpty();}// 如果stackOut为空，那么将stackIn中的元素全部放到stackOut中private void dumpstackIn(){if (!stackOut.isEmpty()) return; while (!stackIn.isEmpty()){stackOut.push(stackIn.pop());}}
}

5.2 用队列实现栈

• push(x) -- 元素 x 入栈
• pop() -- 移除栈顶元素
• top() -- 获取栈顶元素
• empty() -- 返回栈是否为空

Deque 接口继承了 Queue 接口，所以 Queue 中的 add、poll、peek 等效于 Deque 中的 addLast、pollFirst、peekFirst。

用两个Queue实现

class MyStack {Queue<Integer> queue1; // 和栈中保持一样元素的队列Queue<Integer> queue2; // 辅助队列/** Initialize your data structure here. */public MyStack() {queue1 = new LinkedList<>();queue2 = new LinkedList<>();}/** Push element x onto stack. */public void push(int x) {queue2.offer(x); // 先放在辅助队列中while (!queue1.isEmpty()){queue2.offer(queue1.poll());}Queue<Integer> queueTemp;queueTemp = queue1;queue1 = queue2;queue2 = queueTemp; // 最后交换queue1和queue2，将元素都放到queue1中}/** Removes the element on top of the stack and returns that element. */public int pop() {return queue1.poll(); // 因为queue1中的元素和栈中的保持一致，所以这个和下面两个的操作只看queue1即可}/** Get the top element. */public int top() {return queue1.peek();}/** Returns whether the stack is empty. */public boolean empty() {return queue1.isEmpty();}
}

用两个Deque 实现

class MyStack {// Deque 接口继承了 Queue 接口// 所以 Queue 中的 add、poll、peek等效于 Deque 中的 addLast、pollFirst、peekFirstDeque<Integer> que1; // 和栈中保持一样元素的队列Deque<Integer> que2; // 辅助队列/** Initialize your data structure here. */public MyStack() {que1 = new ArrayDeque<>();que2 = new ArrayDeque<>();}/** Push element x onto stack. */public void push(int x) {que1.addLast(x);}/** Removes the element on top of the stack and returns that element. */public int pop() {int size = que1.size();size--;// 将 que1 导入 que2 ，但留下最后一个值while (size-- > 0) {que2.addLast(que1.peekFirst());que1.pollFirst();}int res = que1.pollFirst();// 将 que2 对象的引用赋给了 que1 ，此时 que1，que2 指向同一个队列que1 = que2;// 如果直接操作 que2，que1 也会受到影响，所以为 que2 分配一个新的空间que2 = new ArrayDeque<>();return res;}/** Get the top element. */public int top() {return que1.peekLast();}/** Returns whether the stack is empty. */public boolean empty() {return que1.isEmpty();}
}

用一个 Deque 实现

class MyStack {// Deque 接口继承了 Queue 接口// 所以 Queue 中的 add、poll、peek等效于 Deque 中的 addLast、pollFirst、peekFirstDeque<Integer> que1;/** Initialize your data structure here. */public MyStack() {que1 = new ArrayDeque<>();}/** Push element x onto stack. */public void push(int x) {que1.addLast(x);}/** Removes the element on top of the stack and returns that element. */public int pop() {int size = que1.size();size--;// 将 que1 导入 que2 ，但留下最后一个值while (size-- > 0) {que1.addLast(que1.peekFirst());que1.pollFirst();}int res = que1.pollFirst();return res;}/** Get the top element. */public int top() {return que1.peekLast();}/** Returns whether the stack is empty. */public boolean empty() {return que1.isEmpty();}
}

6 二叉树

6.1 二叉树定义

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;}
}

6.2 二叉树的深度优先遍历方式

深度优先遍历

• 前序遍历（递归法，迭代法）
• 中序遍历（递归法，迭代法）
• 后序遍历（递归法，迭代法）

6.2.1 递归写法

递归三要素：

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型

2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。

3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

二叉树的前中后序遍历： 

// 前序遍历·递归·LC144_二叉树的前序遍历
class Solution {public List<Integer> preorderTraversal(TreeNode root) {List<Integer> result = new ArrayList<Integer>();preorder(root, result);return result;}public void preorder(TreeNode root, List<Integer> result) {if (root == null) {return;}result.add(root.val);preorder(root.left, result);preorder(root.right, result);}
}
// 中序遍历·递归·LC94_二叉树的中序遍历
class Solution {public List<Integer> inorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();inorder(root, res);return res;}void inorder(TreeNode root, List<Integer> list) {if (root == null) {return;}inorder(root.left, list);list.add(root.val);             // 注意这一句inorder(root.right, list);}
}
// 后序遍历·递归·LC145_二叉树的后序遍历
class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();postorder(root, res);return res;}void postorder(TreeNode root, List<Integer> list) {if (root == null) {return;}postorder(root.left, list);postorder(root.right, list);list.add(root.val);             // 注意这一句}
}

6.2.2 迭代写法（栈的思想，模拟递归）

用栈模拟递归，使用迭代法完成二叉树前中后序遍历：

// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
class Solution {public List<Integer> preorderTraversal(TreeNode root) {List<Integer> result = new ArrayList<>();if (root == null){return result;}Stack<TreeNode> stack = new Stack<>();stack.push(root);while (!stack.isEmpty()){TreeNode node = stack.pop();result.add(node.val);if (node.right != null){stack.push(node.right);}if (node.left != null){stack.push(node.left);}}return result;}
}// 中序遍历顺序: 左-中-右 入栈顺序： 左-右
class Solution {public List<Integer> inorderTraversal(TreeNode root) {List<Integer> result = new ArrayList<>();if (root == null){return result;}Stack<TreeNode> stack = new Stack<>();TreeNode cur = root;while (cur != null || !stack.isEmpty()){if (cur != null){stack.push(cur);cur = cur.left;}else{cur = stack.pop();result.add(cur.val);cur = cur.right;}}return result;}
}// 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> result = new ArrayList<>();if (root == null){return result;}Stack<TreeNode> stack = new Stack<>();stack.push(root);while (!stack.isEmpty()){TreeNode node = stack.pop();result.add(node.val);if (node.left != null){stack.push(node.left);}if (node.right != null){stack.push(node.right);}}Collections.reverse(result);return result;}
}

6.2.3 统一迭代法

统一迭代法前序遍历：

class Solution {public List<Integer> preorderTraversal(TreeNode root) {List<Integer> result = new LinkedList<>();Stack<TreeNode> st = new Stack<>();if (root != null) st.push(root);while (!st.empty()) {TreeNode node = st.peek();if (node != null) {st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）st.push(node);                          // 添加中节点st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。} else { // 只有遇到空节点的时候，才将下一个节点放进结果集st.pop();           // 将空节点弹出node = st.peek();    // 重新取出栈中元素st.pop();result.add(node.val); // 加入到结果集}}return result;}
}

统一迭代法中序遍历：

class Solution {
public List<Integer> inorderTraversal(TreeNode root) {List<Integer> result = new LinkedList<>();Stack<TreeNode> st = new Stack<>();if (root != null) st.push(root);while (!st.empty()) {TreeNode node = st.peek();if (node != null) {st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）st.push(node);                          // 添加中节点st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）} else { // 只有遇到空节点的时候，才将下一个节点放进结果集st.pop();           // 将空节点弹出node = st.peek();    // 重新取出栈中元素st.pop();result.add(node.val); // 加入到结果集}}return result;
}
}

统一迭代法后序遍历：

class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> result = new LinkedList<>();Stack<TreeNode> st = new Stack<>();if (root != null) st.push(root);while (!st.empty()) {TreeNode node = st.peek();if (node != null) {st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中st.push(node);                          // 添加中节点st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）         } else { // 只有遇到空节点的时候，才将下一个节点放进结果集st.pop();           // 将空节点弹出node = st.peek();    // 重新取出栈中元素st.pop();result.add(node.val); // 加入到结果集}}return result;}
}

6.3 二叉树的广度优先遍历方式

广度优先遍历

• 层序遍历（迭代法）

class Solution {public List<List<Integer>> resList = new ArrayList<List<Integer>>();public List<List<Integer>> levelOrder(TreeNode root) {checkFun02(root);return resList;} //BFS--迭代方式--借助队列public void checkFun02(TreeNode node) {if (node == null) return;Queue<TreeNode> que = new LinkedList<TreeNode>();que.offer(node);while (!que.isEmpty()) {List<Integer> itemList = new ArrayList<Integer>();int len = que.size();while (len > 0) {TreeNode tmpNode = que.poll();itemList.add(tmpNode.val);if (tmpNode.left != null) que.offer(tmpNode.left);if (tmpNode.right != null) que.offer(tmpNode.right);len--;}resList.add(itemList);}}
}

6.4 二叉树求深度和高度

• 求二叉树深度和高度的时候，用递归遍历法是有技巧的。
• 因为求深度可以从上到下去查 所以需要前序遍历（中左右），而高度只能从下到上去查，所以只能后序遍历（左右中）。

总结一下：从上往下用前序，从下往上用后续，一般需要依靠子节点来判断父节点的状态的问题，都是采用后序遍历。

6.5 递归函数是否需要返回值

递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

• 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。
• 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。
• 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。

6.6 构建二叉树

构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。

用数组构建二叉树，本质就是寻找分割点(一般有序数组是寻找中间点，一般都构建的是平衡二叉搜索树)，分割点作为当前节点，然后递归左区间和右区间。

前序和中序可以唯一确定一棵二叉树，后序和中序可以唯一确定一棵二叉树，而前序和后序却不行。

6.7 二叉搜索树

二叉搜索树，用中序遍历是一个递增序列。在二叉树中通过两个前后指针 pre 和 cur 作比较，会经常用到。

二叉搜索树的特性：

• 节点的左子树只包含小于当前节点的数。
• 节点的右子树只包含大于当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

6.8 二叉树递归顺序

• 涉及到二叉树的构造，无论普通二叉树还是二叉搜索树一定前序，都是先构造中节点。
• 求普通二叉树的属性，一般是后序，一般要通过递归函数的返回值做计算。

• 求二叉搜索树的属性，一定是中序了，要不白瞎了有序性了。

7 回溯算法

回溯法，一般可以解决如下几种问题：

• 组合问题：N个数里面按一定规则找出k个数的集合
• 切割问题：一个字符串按一定规则有几种切割方式
• 子集问题：一个N个数的集合里有多少符合条件的子集
• 排列问题：N个数按一定规则全排列，有几种排列方式
• 棋盘问题：N皇后，解数独等等

回溯法解决的问题都可以抽象为树形结构，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。

回溯算法模板框架如下：

void backtracking(参数) {if (终止条件) {存放结果;return;}for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {处理节点;backtracking(路径，选择列表); // 递归回溯，撤销处理结果}
}

7.1 组合问题

组合问题：回溯法解决k层for循环嵌套的问题。

组合问题需要在递归中调整for循环的起始值，也就是说开始值不断后移。

7.1.1 一个集合 & 元素不可以重复使用 & 元素不重复

给定n个数，每个数只能用一次，递归层数为指定 k

组合问题的剪枝：

来举一个例子，n = 4，k = 4 的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。

通过图可以看出，如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

剪枝优化过程：

1. 已经选择的元素个数：path.size();
2. 还需要的元素个数为: k - path.size();

3. 在集合n中至多要从该起始位置 : n - (k - path.size()) + 1，开始遍历。

7.1.2 一个集合 & 元素可以重复使用 & 元素不重复

给定 n 个无重复的数，数字可以重复使用，递归层数不定

7.1.3 一个集合 & 元素不能重复使用 & 元素重复

重复元素去重

所谓去重，其实就是使用过的元素不能重复选取。都知道组合问题可以抽象为树形结构，那么“使用过”在这个树形结构上是有两个维度的，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。没有理解这两个层面上的“使用过” 是造成大家没有彻底理解去重的根本原因。

所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。

此处要加一个used数组，用来记录同一树枝上的元素是否使用过。

如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。

• used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
• used[i - 1] == false，说明同一树层candidates[i - 1]使用过

使用used标记数组

class Solution {List<List<Integer>> lists = new ArrayList<>();Deque<Integer> deque = new LinkedList<>();int sum = 0;public List<List<Integer>> combinationSum2(int[] candidates, int target) {//为了将重复的数字都放到一起，所以先进行排序Arrays.sort(candidates);//加标志数组，用来辅助判断同层节点是否已经遍历boolean[] used = new boolean[candidates.length];backTracking(candidates, target, 0, used);return lists;}public void backTracking(int[] arr, int target, int index, boolean[] used) {if (sum == target) {lists.add(new ArrayList(deque));return;}for (int i = index; i < arr.length && arr[i] + sum <= target; i++) {//出现重复节点，同层的第一个节点已经被访问过，所以直接跳过if (i > 0 && arr[i] == arr[i - 1] && !used[i - 1]) {continue;}used[i] = true;sum += arr[i];deque.push(arr[i]);//每个节点仅能选择一次，所以从下一位开始backTracking(arr, target, i + 1, used);int temp = deque.pop();used[i] = false;sum -= temp;}}
}

不使用used标记数组

class Solution {List<List<Integer>> res = new ArrayList<>();LinkedList<Integer> path = new LinkedList<>();int sum = 0;public List<List<Integer>> combinationSum2( int[] candidates, int target ) {//为了将重复的数字都放到一起，所以先进行排序Arrays.sort( candidates );backTracking( candidates, target, 0 );return res;}private void backTracking( int[] candidates, int target, int start ) {if ( sum == target ) {res.add( new ArrayList<>( path ) );return;}for ( int i = start; i < candidates.length && sum + candidates[i] <= target; i++ ) {//正确剔除重复解的办法//跳过同一树层使用过的元素if ( i > start && candidates[i] == candidates[i - 1] ) {continue;}sum += candidates[i];path.add( candidates[i] );// i+1 代表当前组内元素只选取一次backTracking( candidates, target, i + 1 );int temp = path.getLast();sum -= temp;path.removeLast();}}
}

7.1.4 多个集合求子集

组合问题，什么时候需要startIndex

如果是一个集合来求组合的话，就需要startIndex，如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex。

示例: 输入："23" 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]

class Solution {//设置全局列表存储最后的结果List<String> list = new ArrayList<>();public List<String> letterCombinations(String digits) {if (digits == null || digits.length() == 0) {return list;}//初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};//迭代处理backTracking(digits, numString, 0);return list;}//每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuildStringBuilder temp = new StringBuilder();//比如digits如果为"23",num 为0，则str表示2对应的 abcpublic void backTracking(String digits, String[] numString, int num) {//遍历全部一次记录一次得到的字符串if (num == digits.length()) {list.add(temp.toString());return;}//str 表示当前num对应的字符串String str = numString[digits.charAt(num) - '0'];for (int i = 0; i < str.length(); i++) {temp.append(str.charAt(i));//cbackTracking(digits, numString, num + 1);//剔除末尾的继续尝试temp.deleteCharAt(temp.length() - 1);}}
}

7.2 分割问题

其实切割问题类似组合问题。

例如对于字符串abcdef：

• 组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中在选组第三个.....。
• 切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中在切割第三段.....。

7.2.1 分割回文串

我列出如下几个难点：

• 切割问题可以抽象为组合问题
• 如何模拟那些切割线
• 切割问题中递归如何终止
• 在递归循环中如何截取子串
• 如何判断回文

class Solution {List<List<String>> lists = new ArrayList<>();Deque<String> deque = new LinkedList<>();public List<List<String>> partition(String s) {backTracking(s, 0);return lists;}private void backTracking(String s, int startIndex) {//如果起始位置大于s的大小，说明找到了一组分割方案if (startIndex >= s.length()) {lists.add(new ArrayList(deque));return;}for (int i = startIndex; i < s.length(); i++) {//如果是回文子串，则记录if (isPalindrome(s, startIndex, i)) {String str = s.substring(startIndex, i + 1);deque.addLast(str);} else {continue;    //不是回文串，不再递归，接着循环}//起始位置后移，保证不重复backTracking(s, i + 1);deque.removeLast();}}//判断是否是回文串private boolean isPalindrome(String s, int startIndex, int end) {for (int i = startIndex, j = end; i < j; i++, j--) {if (s.charAt(i) != s.charAt(j)) {return false;}}return true;}
}

7.2.2 复原IP地址

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。每个整数位于 0 到 255 之间组成，且不能含有前导 0。

判断切割子串是否合法，主要考虑到如下三点：

• 段位以0为开头的数字不合法
• 段位里有非正整数字符不合法
• 段位如果大于255了不合法

本题剪枝操作和上一题略有不同，上一题判断为非回文子串，for循环依旧进行，只是不再递归，而本题一旦判断出所切割字符串不合法，则直接终止for循环和递归两个操作。

class Solution {List<String> result = new ArrayList<>();public List<String> restoreIpAddresses(String s) {if (s.length() > 12) return result; // 算是剪枝了backTrack(s, 0, 0);return result;}// startIndex: 搜索的起始位置， pointNum:添加逗点的数量private void backTrack(String s, int startIndex, int pointNum) {if (pointNum == 3) {// 逗点数量为3时，分隔结束// 判断第四段⼦字符串是否合法，如果合法就放进result中if (isValid(s,startIndex,s.length()-1)) {result.add(s);}return;}for (int i = startIndex; i < s.length(); i++) {if (isValid(s, startIndex, i)) {s = s.substring(0, i + 1) + "." + s.substring(i + 1);    //在str的后⾯插⼊⼀个逗点pointNum++;backTrack(s, i + 2, pointNum);// 插⼊逗点之后下⼀个⼦串的起始位置为i+2pointNum--;// 回溯s = s.substring(0, i + 1) + s.substring(i + 2);// 回溯删掉逗点} else {break;}}}// 判断字符串s在左闭⼜闭区间[start, end]所组成的数字是否合法private Boolean isValid(String s, int start, int end) {if (start > end) {return false;}if (s.charAt(start) == '0' && start != end) { // 0开头的数字不合法return false;}int num = 0;for (int i = start; i <= end; i++) {if (s.charAt(i) > '9' || s.charAt(i) < '0') { // 遇到⾮数字字符不合法return false;}num = num * 10 + (s.charAt(i) - '0');if (num > 255) { // 如果⼤于255了不合法return false;}}return true;}
}

7.3 子集问题

子集问题和组合问题相似，如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！组合和子集问题每次取元素是一个一个取，而分割问题则是范围式的截取。

子集问题的集合也是无序的，那么既然是无序，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始！

7.3.1 一个集合 & 无重复元素 & 元素不重复使用

输入: nums = [1,2,3]   输出: [ [3],   [1],   [2],   [1,2,3],   [1,3],   [2,3],   [1,2],   [] ]

可以看出遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合。

class Solution {List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果public List<List<Integer>> subsets(int[] nums) {if (nums.length == 0){result.add(new ArrayList<>());return result;}subsetsHelper(nums, 0);return result;}private void subsetsHelper(int[] nums, int startIndex){result.add(new ArrayList<>(path));//「遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合」。if (startIndex >= nums.length){ //终止条件可不加return;}for (int i = startIndex; i < nums.length; i++){path.add(nums[i]);subsetsHelper(nums, i + 1);path.removeLast();}}
}

7.3.2 一个集合 & 包含重复元素 & 元素不重复使用

• 输入: [1,2,2]    输出: [ [2], [1], [1,2,2], [2,2], [1,2], [] ]

包含重复元素的去重方法都是一个套路，主要是“树层去重”和“树枝去重”，树层去重主要是在for循环中（横向）去重，而树枝去重是在递归（纵向）去重，一般去重都是树枝去重，保证不回有重复子序列。（去重一般对集合先排序）

使用used数组

class Solution {List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果boolean[] used;public List<List<Integer>> subsetsWithDup(int[] nums) {if (nums.length == 0){result.add(path);return result;}Arrays.sort(nums);used = new boolean[nums.length];subsetsWithDupHelper(nums, 0);return result;}private void subsetsWithDupHelper(int[] nums, int startIndex){result.add(new ArrayList<>(path));if (startIndex >= nums.length){return;}for (int i = startIndex; i < nums.length; i++){if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){continue;}path.add(nums[i]);used[i] = true;subsetsWithDupHelper(nums, i + 1);path.removeLast();used[i] = false;}}
}

不使用used数组

class Solution {List<List<Integer>> res = new ArrayList<>();LinkedList<Integer> path = new LinkedList<>();public List<List<Integer>> subsetsWithDup( int[] nums ) {Arrays.sort( nums );subsetsWithDupHelper( nums, 0 );return res;}private void subsetsWithDupHelper( int[] nums, int start ) {res.add( new ArrayList<>( path ) );for ( int i = start; i < nums.length; i++ ) {// 跳过当前树层使用过的、相同的元素if ( i > start && nums[i - 1] == nums[i] ) {continue;}path.add( nums[i] );subsetsWithDupHelper( nums, i + 1 );path.removeLast();}}}

7.3.3  递增子序列

• 输入: [4, 7 ,6 , 7]
• 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 7, 7], [6, 7], [7,7]]
• 数字范围：[-100,100]

class Solution {private List<Integer> path = new ArrayList<>();private List<List<Integer>> res = new ArrayList<>();public List<List<Integer>> findSubsequences(int[] nums) {backtracking(nums,0);return res;}private void backtracking (int[] nums, int start) {if (path.size() > 1) {res.add(new ArrayList<>(path));}int[] used = new int[201];   //每层for循环都新建一个数组，用以记录元素是都在该层被使用过for (int i = start; i < nums.length; i++) {if (!path.isEmpty() && nums[i] < path.get(path.size() - 1) ||(used[nums[i] + 100] == 1)) continue;used[nums[i] + 100] = 1;path.add(nums[i]);backtracking(nums, i + 1);path.remove(path.size() - 1);}}
}

7.3.4 去重是否需要使用used数组

• 当递归的时候下一个startIndex是i+1而不是0的时候，不需要使用used数组，此时可以判断   nums[i - 1] == nums[i] 来跳过相同元素；
• 如果要是全排列的话（不同顺序相同元素看作不同子集），每次要从0开始遍历，为了跳过已入栈的元素，需要使用used。

7.4 排列问题

排列问题与组合问题最大的区别在于：组合不在意顺序，只要元素相同，就是同一个子集；而排列则讲究顺序，相同元素不同顺序，看作不同子集。

7.4.1 全排列 & 无重复元素

• 输入: [1,2,3]
• 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

此处需要用到used数组：used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次。

排列问题的不同：

• 每层都是从0开始搜索而不是startIndex
• 需要used数组记录path里都放了哪些元素了

使用used数组

class Solution {List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果boolean[] used;public List<List<Integer>> permute(int[] nums) {if (nums.length == 0){return result;}used = new boolean[nums.length];permuteHelper(nums);return result;}private void permuteHelper(int[] nums){if (path.size() == nums.length){result.add(new ArrayList<>(path));return;}for (int i = 0; i < nums.length; i++){if (used[i]){continue;}used[i] = true;path.add(nums[i]);permuteHelper(nums);path.removeLast();used[i] = false;}}
}

不使用used数组，而通过判断已记录中元素是否包含当前元素（当没有重复元素）

class Solution {List<List<Integer>> result = new ArrayList<>();LinkedList<Integer> path = new LinkedList<>();public List<List<Integer>> permute(int[] nums) {if (nums.length == 0) return result;backtrack(nums, path);return result;}public void backtrack(int[] nums, LinkedList<Integer> path) {if (path.size() == nums.length) {result.add(new ArrayList<>(path));}for (int i =0; i < nums.length; i++) {// 如果path中已有，则跳过if (path.contains(nums[i])) {continue;} path.add(nums[i]);backtrack(nums, path);path.removeLast();}}
}

7.4.2 全排列 & 包含重复元素

• 输入：nums = [1,1,2]
• 输出： [[1,1,2], [1,2,1], [2,1,1]]

全排列去重问题要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。

对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高！

树层去重

树枝去重

class Solution {//存放结果List<List<Integer>> result = new ArrayList<>();//暂存结果List<Integer> path = new ArrayList<>();public List<List<Integer>> permuteUnique(int[] nums) {boolean[] used = new boolean[nums.length];Arrays.fill(used, false);Arrays.sort(nums);backTrack(nums, used);return result;}private void backTrack(int[] nums, boolean[] used) {if (path.size() == nums.length) {result.add(new ArrayList<>(path));return;}for (int i = 0; i < nums.length; i++) {// used[i - 1] == true，说明同⼀树⽀nums[i - 1]使⽤过// used[i - 1] == false，说明同⼀树层nums[i - 1]使⽤过// 如果同⼀树层nums[i - 1]使⽤过则直接跳过if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {continue;}//如果同⼀树⽀nums[i]没使⽤过开始处理if (used[i] == false) {used[i] = true;//标记同⼀树⽀nums[i]使⽤过，防止同一树枝重复使用path.add(nums[i]);backTrack(nums, used);path.remove(path.size() - 1);//回溯，说明同⼀树层nums[i]使⽤过，防止下一树层重复used[i] = false;//回溯}}}
}

7.5 安排行程问题（图论结合回溯）

提示：

• 如果存在多种有效的行程，请你按字符自然排序返回最小的行程组合。例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前
• 所有的机场都用三个大写字母表示（机场代码）。
• 假定所有机票至少存在一种合理的行程。
• 所有的机票必须都用一次 且 只能用一次。

示例：

• 输入：[["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
• 输出：["JFK","ATL","JFK","SFO","ATL","SFO"]
• 解释：另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"]。但是它自然排序更大更靠后。

这道题目有几个难点：

1. 一个行程中，如果航班处理不好容易变成一个圈，成为死循环
2. 有多种解法，字母序靠前排在前面，让很多同学望而退步，如何该记录映射关系呢 ？
3. 使用回溯法（也可以说深搜） 的话，那么终止条件是什么呢？
4. 搜索的过程中，如何遍历一个机场所对应的所有机场。

class Solution {private Deque<String> res;private Map<String, Map<String, Integer>> map;private boolean backTracking(int ticketNum){if(res.size() == ticketNum + 1){return true;}String last = res.getLast();if(map.containsKey(last)){//防止出现nullfor(Map.Entry<String, Integer> target : map.get(last).entrySet()){int count = target.getValue();if(count > 0){res.add(target.getKey());target.setValue(count - 1);if(backTracking(ticketNum)) return true;res.removeLast();target.setValue(count);}}}return false;}public List<String> findItinerary(List<List<String>> tickets) {map = new HashMap<String, Map<String, Integer>>();res = new LinkedList<>();for(List<String> t : tickets){Map<String, Integer> temp;if(map.containsKey(t.get(0))){temp = map.get(t.get(0));temp.put(t.get(1), temp.getOrDefault(t.get(1), 0) + 1);}else{temp = new TreeMap<>();//升序Maptemp.put(t.get(1), 1);}map.put(t.get(0), temp);}res.add("JFK");backTracking(tickets.size());return new ArrayList<>(res);}
}

7.6 棋盘问题

7.6.1 N皇后

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

• 输入：n = 4
• 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]

约束条件：

1. 不能同行
2. 不能同列
3. 不能同斜线

二维矩阵中矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度。

class Solution {List<List<String>> res = new ArrayList<>();public List<List<String>> solveNQueens(int n) {char[][] chessboard = new char[n][n];for (char[] c : chessboard) {Arrays.fill(c, '.');           //先将二维数组都用 . 填充}backTrack(n, 0, chessboard);return res;}public void backTrack(int n, int row, char[][] chessboard) {if (row == n) {res.add(Array2List(chessboard));         //将字符串列表存入总的列表return;}for (int col = 0;col < n; ++col) {if (isValid (row, col, n, chessboard)) {chessboard[row][col] = 'Q';backTrack(n, row+1, chessboard);chessboard[row][col] = '.';}}}public List Array2List(char[][] chessboard) {List<String> list = new ArrayList<>();for (char[] c : chessboard) {list.add(String.copyValueOf(c));    //将数组的每一行变为字符串，存入列表}return list;}public boolean isValid(int row, int col, int n, char[][] chessboard) {// 检查列for (int i=0; i<row; ++i) { // 相当于剪枝if (chessboard[i][col] == 'Q') {return false;}}// 检查45度对角线for (int i=row-1, j=col-1; i>=0 && j>=0; i--, j--) {if (chessboard[i][j] == 'Q') {return false;}}// 检查135度对角线for (int i=row-1, j=col+1; i>=0 && j<=n-1; i--, j++) {if (chessboard[i][j] == 'Q') {return false;}}return true;}
}

7.6.2 解数独

一个数独的解法需遵循如下规则： 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。 空白格用 '.' 表示。

棋盘搜索问题可以使用回溯法暴力搜索，只不过这次我们要做的是二维递归。（也就是两个for循环嵌套着递归）

判断棋盘是否合法有如下三个维度：

• 同行是否重复
• 同列是否重复
• 9宫格里是否重复

class Solution {public void solveSudoku(char[][] board) {solveSudokuHelper(board);}private boolean solveSudokuHelper(char[][] board){//「一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，// 一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！」for (int i = 0; i < 9; i++){ // 遍历行for (int j = 0; j < 9; j++){ // 遍历列if (board[i][j] != '.'){ // 跳过原始数字continue;}for (char k = '1'; k <= '9'; k++){ // (i, j) 这个位置放k是否合适if (isValidSudoku(i, j, k, board)){board[i][j] = k;if (solveSudokuHelper(board)){ // 如果找到合适一组立刻返回return true;}board[i][j] = '.';}}// 9个数都试完了，都不行，那么就返回falsereturn false;// 因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！// 那么会直接返回， 「这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！」}}// 遍历完没有返回false，说明找到了合适棋盘位置了return true;}/*** 判断棋盘是否合法有如下三个维度:*     同行是否重复*     同列是否重复*     9宫格里是否重复*/private boolean isValidSudoku(int row, int col, char val, char[][] board){// 同行是否重复for (int i = 0; i < 9; i++){if (board[row][i] == val){return false;}}// 同列是否重复for (int j = 0; j < 9; j++){if (board[j][col] == val){return false;}}// 9宫格里是否重复int startRow = (row / 3) * 3;int startCol = (col / 3) * 3;for (int i = startRow; i < startRow + 3; i++){for (int j = startCol; j < startCol + 3; j++){if (board[i][j] == val){return false;}}}return true;}
}

8 贪心算法

什么是贪心

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

什么时候用贪心

说实话贪心算法并没有固定的套路。如何通过局部最优，推出整体最优，那么就可以用贪心。如何能看出局部最优是否能推出整体最优呢？这个没有固定的策略，需要自己手动模拟并思考有没有反例，如果没有范例，就试一试贪心策略，如果不可行，可能需要动态规划。

一般数学证明有如下两种方法：

• 数学归纳法
• 反证法

贪心算法一般分为如下四步：

• 将问题分解为若干个子问题
• 找出适合的贪心策略
• 求解每一个子问题的最优解
• 将局部最优解堆叠成全局最优解

8.1 摆动序列

给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

• 输入: [1,17,5,10,13,15,10,5,16,8]
• 输出: 7
• 解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。

8.1.1 贪心算法

• 局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。
• 整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

class Solution {public int wiggleMaxLength(int[] nums) {if (nums.length <= 1) {return nums.length;}//当前差值int curDiff = 0;//上一个差值int preDiff = 0;int count = 1;for (int i = 1; i < nums.length; i++) {//得到当前差值curDiff = nums[i] - nums[i - 1];//如果当前差值和上一个差值为一正一负//等于0的情况表示初始时的preDiffif ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)) {count++;preDiff = curDiff;}}return count;}
}

8.1.2 动态规划

对于我们当前考虑的这个数，要么是作为山峰（即nums[i] > nums[i-1]），要么是作为山谷（即nums[i] < nums[i - 1]）。

• 设dp状态dp[i][0]，表示考虑前i个数，第i个数作为山峰的摆动子序列的最长长度
• 设dp状态dp[i][1]，表示考虑前i个数，第i个数作为山谷的摆动子序列的最长长度

则转移方程为：

• dp[i][0] = max(dp[i][0], dp[j][1] + 1)，其中0 < j < i且nums[j] < nums[i]，表示将nums[i]接到前面某个山谷后面，作为山峰。
• dp[i][1] = max(dp[i][1], dp[j][0] + 1)，其中0 < j < i且nums[j] > nums[i]，表示将nums[i]接到前面某个山峰后面，作为山谷。

class Solution {public int wiggleMaxLength(int[] nums) {// 0 i 作为波峰的最大长度// 1 i 作为波谷的最大长度int dp[][] = new int[nums.length][2];dp[0][0] = dp[0][1] = 1;for (int i = 1; i < nums.length; i++){//i 自己可以成为波峰或者波谷dp[i][0] = dp[i][1] = 1;for (int j = 0; j < i; j++){if (nums[j] > nums[i]){// i 是波谷dp[i][1] = Math.max(dp[i][1], dp[j][0] + 1);}if (nums[j] < nums[i]){// i 是波峰dp[i][0] = Math.max(dp[i][0], dp[j][1] + 1);}}}return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);}
}

8.2 最大子序和

示例: 输入: [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

8.2.1 贪心解法

局部最优的情况下，并记录最大的“连续和”，可以推出全局最优。这相当于是暴力解法中的不断调整最大子序和区间的起始位置。

class Solution {public int maxSubArray(int[] nums) {if (nums.length == 1){return nums[0];}int sum = Integer.MIN_VALUE;int count = 0;for (int i = 0; i < nums.length; i++){count += nums[i];sum = Math.max(sum, count); // 取区间累计的最大值（相当于不断确定最大子序终止位置）if (count <= 0){count = 0; // 相当于重置最大子序起始位置，因为遇到负数一定是拉低总和}}return sum;}
}

8.2.2 动态规划

class Solution {public int maxSubArray(int[] nums) {int ans = Integer.MIN_VALUE;int[] dp = new int[nums.length];dp[0] = nums[0];ans = dp[0];for (int i = 1; i < nums.length; i++){dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);ans = Math.max(dp[i], ans);}return ans;}
}

8.3 买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

• 输入: [7,1,5,3,6,4]
• 输出: 7

8.3.1 贪心算法

把利润分解为每天为单位的维度，收集正利润的区间，就是股票买卖的区间，而我们只需要关注最终利润，不需要记录区间。

局部最优：收集每天的正利润，全局最优：求得最大利润。

class Solution {public int maxProfit(int[] prices) {int result = 0;for (int i = 1; i < prices.length; i++) {result += Math.max(prices[i] - prices[i - 1], 0);}return result;}
}

8.3.2 动态规划

class Solution { // 动态规划public int maxProfit(int[] prices) {// [天数][是否持有股票]int[][] dp = new int[prices.length][2];// base casedp[0][0] = 0;dp[0][1] = -prices[0];for (int i = 1; i < prices.length; i++) {// dp公式dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);}return dp[prices.length - 1][0];}
}

8.4 卖股票的最佳时机 & 有手续费

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

示例 1: 输入: prices = [1, 3, 2, 8, 4, 9], fee = 2 输出: 8

8.4.1 贪心算法

• 买入日期：其实很好想，遇到更低点就记录一下。
• 卖出日期：这个就不好算了，但也没有必要算出准确的卖出日期，只要当前价格大于（最低价格+手续费），就可以收获利润，至于准确的卖出日期，就是连续收获利润区间里的最后一天（并不需要计算是具体哪一天）。

所以我们在做收获利润操作的时候其实有三种情况：

• 情况一：收获利润的这一天并不是收获利润区间里的最后一天（不是真正的卖出，相当于持有股票），所以后面要继续收获利润。
• 情况二：前一天是收获利润区间里的最后一天（相当于真正的卖出了），今天要重新记录最小价格了。
• 情况三：不作操作，保持原有状态（买入，卖出，不买不卖）

class Solution {public int maxProfit(int[] prices, int fee) {int buy = prices[0] + fee;int sum = 0;for (int p : prices) {if (p + fee < buy) {buy = p + fee;} else if (p > buy){sum += p - buy;buy = p;}}return sum;}
}

8.4.2 动态规划

class Solution { // 动态规划public int maxProfit(int[] prices, int fee) {if (prices == null || prices.length < 2) {return 0;}int[][] dp = new int[prices.length][2];// bad casedp[0][0] = 0;dp[0][1] = -prices[0];for (int i = 1; i < prices.length; i++) {dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i] - fee);dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);}return dp[prices.length - 1][0];}
}

8.5 跳跃游戏

给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置。

• 输入: [2,3,1,1,4]     输出: true
• 输入: [3,2,1,0,4]     输出: false

每次移动取最大跳跃步数（得到最大的覆盖范围），每移动一个单位，就更新最大覆盖范围。

贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。

class Solution {public boolean canJump(int[] nums) {if (nums.length == 1) {return true;}//覆盖范围, 初始覆盖范围应该是0，因为下面的迭代是从下标0开始的int coverRange = 0;//在覆盖范围内更新最大的覆盖范围for (int i = 0; i <= coverRange; i++) {coverRange = Math.max(coverRange, i + nums[i]);if (coverRange >= nums.length - 1) {return true;}}return false;}
}

8.6 跳跃游戏2

给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。你的目标是使用最少的跳跃次数到达数组的最后一个位置。

• 输入: [2,3,1,1,4]      输出: 2

贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最小步数。

所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最小步数！

这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。

class Solution {public int jump(int[] nums) {if (nums == null || nums.length == 0 || nums.length == 1) {return 0;}//记录跳跃的次数int count=0;//当前的覆盖最大区域int curDistance = 0;//最大的覆盖区域int maxDistance = 0;for (int i = 0; i < nums.length; i++) {//在可覆盖区域内更新最大的覆盖区域maxDistance = Math.max(maxDistance,i+nums[i]);//说明当前一步，再跳一步就到达了末尾if (maxDistance>=nums.length-1){count++;break;}//走到当前覆盖的最大区域时，更新下一步可达的最大区域if (i==curDistance){curDistance = maxDistance;count++;}}return count;}
}

8.7 K次取反后最大化的数组和

给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。（我们可以多次选择同一个索引 i。）

• 输入：A = [2,-3,-1,5,-4], K = 2             输出：13
• 解释：选择索引 (1, 4) ，然后 A 变为 [2,3,-1,5,4]。

那么本题的解题步骤为：

• 第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
• 第二步：从前向后遍历，遇到负数将其变为正数，同时K--
• 第三步：如果K还大于0，那么反复转变数值最小的元素，将K用完
• 第四步：求和

class Solution {public int largestSumAfterKNegations(int[] nums, int K) {// 将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小nums = IntStream.of(nums).boxed().sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1)).mapToInt(Integer::intValue).toArray();int len = nums.length;       for (int i = 0; i < len; i++) {//从前向后遍历，遇到负数将其变为正数，同时K--if (nums[i] < 0 && K > 0) {nums[i] = -nums[i];K--;}}// 如果K还大于0，那么反复转变数值最小的元素，将K用完if (K % 2 == 1) nums[len - 1] = -nums[len - 1];return Arrays.stream(nums).sum();}
}

8.8 分发糖果（从左到右+从右到左）

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

• 每个孩子至少分配到 1 个糖果。
• 相邻的孩子中，评分高的孩子必须获得更多的糖果。

• 输入: [1,0,2]            输出: 5
• 解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。

这道题目一定是要确定一边之后，再确定另一边，例如比较每一个孩子的左边，然后再比较右边，如果两边一起考虑一定会顾此失彼。

那么本题我采用了两次贪心的策略：

• 一次是从左到右遍历，只比较右边孩子评分比左边大的情况。
• 一次是从右到左遍历，只比较左边孩子评分比右边大的情况。

class Solution {/** 分两个阶段 1、起点下标1 从左往右，只要 右边 比 左边 大，右边的糖果=左边 + 12、起点下标 ratings.length - 2 从右往左， 只要左边 比 右边 大，此时 左边的糖果应该 取本身的糖果数（符合比它左边大） 和 右边糖果数 + 1 二者的最大值，这样才符合 它比它左边的大，也比它右边大*/public int candy(int[] ratings) {int[] candyVec = new int[ratings.length];candyVec[0] = 1;for (int i = 1; i < ratings.length; i++) {if (ratings[i] > ratings[i - 1]) {candyVec[i] = candyVec[i - 1] + 1;} else {candyVec[i] = 1;}}for (int i = ratings.length - 2; i >= 0; i--) {if (ratings[i] > ratings[i + 1]) {candyVec[i] = Math.max(candyVec[i], candyVec[i + 1] + 1);}}int ans = 0;for (int s : candyVec) {ans += s;}return ans;}
}

8.9 根据身高重建队列

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

• 输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
• 输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]

本题也有两个维度，此时要先确定一个维度，然后在考虑另外一个维度。

按照身高排序之后，优先按身高高的people的k来插入，后序插入节点也不会影响前面已经插入的节点，最终按照k的规则完成了队列。

• 局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性
• 全局最优：最后都做完插入操作，整个队列满足题目队列属性

插入的过程：

• 插入[7,0]：[[7,0]]
• 插入[7,1]：[[7,0],[7,1]]
• 插入[6,1]：[[7,0],[6,1],[7,1]]
• 插入[5,0]：[[5,0],[7,0],[6,1],[7,1]]
• 插入[5,2]：[[5,0],[7,0],[5,2],[6,1],[7,1]]
• 插入[4,4]：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]

class Solution {public int[][] reconstructQueue(int[][] people) {// 身高从大到小排（身高相同k小的站前面）Arrays.sort(people, (a, b) -> {if (a[0] == b[0]) return a[1] - b[1];    //如果身高相等，则让最终前面人数少的排在前面return b[0] - a[0];                     //如果身高不等，则按从大到小排列});LinkedList<int[]> que = new LinkedList<>();for (int[] p : people) {que.add(p[1],p);}return que.toArray(new int[people.length][]);}
}

8.10 用最少数量的箭引爆气球

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

• 输入：points = [[10,16],[2,8],[1,6],[7,12]]           输出：2
• 解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球

为了让气球尽可能的重叠，需要对数组进行排序。如果气球重叠了，重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭。

class Solution {public int findMinArrowShots(int[][] points) {if (points.length == 0) return 0;Arrays.sort(points, (o1, o2) -> Integer.compare(o1[0], o2[0]));int count = 1;for (int i = 1; i < points.length; i++) {if (points[i][0] > points[i - 1][1]) {count++;} else {points[i][1] = Math.min(points[i][1],points[i - 1][1]);}}return count;}
}

8.11 无重叠区间

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

• 输入: [ [1,2], [2,3], [3,4], [1,3] ]                  输出: 1
• 解释: 移除 [1,3] 后，剩下的区间没有重叠。

我来按照右边界排序，从左向右记录非交叉区间的个数。最后用区间总数减去非交叉区间的个数就是需要移除的区间个数了。

class Solution {public int eraseOverlapIntervals(int[][] intervals) {Arrays.sort(intervals,(a,b)->{return Integer.compare(a[0],b[0]);});int remove = 0;int pre = intervals[0][1];for(int i=1;i<intervals.length;i++){if(pre>intervals[i][0]) {remove++;pre = Math.min(pre,intervals[i][1]);}else pre = intervals[i][1];}return remove;}
}

8.12划分字母区间

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。

• 输入：S = "ababcbacadefegdehijhklij"     输出：[9,7,8]
• 解释： 划分结果为 "ababcbaca", "defegde", "hijhklij"。 每个字母最多出现在一个片段中。 像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。

在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。

class Solution {public List<Integer> partitionLabels(String S) {List<Integer> list = new LinkedList<>();int[] edge = new int[26];char[] chars = S.toCharArray();for (int i = 0; i < chars.length; i++) {edge[chars[i] - 'a'] = i;}int idx = 0;int last = -1;for (int i = 0; i < chars.length; i++) {idx = Math.max(idx,edge[chars[i] - 'a']);if (i == idx) {list.add(i - last);last = i;}}return list;}
}

8.13 监控二叉树

给定一个二叉树，我们在树的节点上安装摄像头。节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。计算监控树的所有节点所需的最小摄像头数量。

根据题意，摄像头不能放在叶子节点上，需要放在叶子节点的父节点上。所以我们要从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！

有如下三种：

• 该节点无覆盖      用0表示
• 本节点有摄像头    用1表示
• 本节点有覆盖       用2表示

class Solution {private int count = 0;public int minCameraCover(TreeNode root) {if (trval(root) == 0) count++;return count;}private int trval(TreeNode root) {if (root == null) return -1;int left = trval(root.left);int right = trval(root.right);if (left == 0 || right == 0) {count++;return 2;}if (left == 2 || right == 2) {return 1;}return 0;}
}

9 动态规划（Dynamic Programming）

如果某一问题有很多重叠子问题，使用动态规划是最有效的。动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的。

动态规划的解题步骤

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

9.1 基础动态规划

9.1.1 不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？

• 输入：m = 3, n = 7
• 输出：28

/*** 1. 确定dp数组下标含义 dp[i][j] 到每一个坐标可能的路径种类* 2. 递推公式 dp[i][j] = dp[i-1][j] + dp[i][j-1]* 3. 初始化 dp[i][0]=1 dp[0][i]=1 初始化横竖就可* 4. 遍历顺序 一行一行遍历* 5. 推导结果*/public static int uniquePaths(int m, int n) {int[][] dp = new int[m][n];//初始化for (int i = 0; i < m; i++) {dp[i][0] = 1;}for (int i = 0; i < n; i++) {dp[0][i] = 1;}for (int i = 1; i < m; i++) {for (int j = 1; j < n; j++) {dp[i][j] = dp[i-1][j]+dp[i][j-1];}}return dp[m-1][n-1];}

9.1.2 不同路径 II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

• 输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]            输出：2

当有障碍物的时候，障碍物的地方保持初始化状态，也就是全0。初始化第一行和第一列的时候，遇到障碍物，后面的都不需要初始化了。、

class Solution {public int uniquePathsWithObstacles(int[][] obstacleGrid) {int n = obstacleGrid.length, m = obstacleGrid[0].length;int[][] dp = new int[n][m];for (int i = 0; i < m; i++) {if (obstacleGrid[0][i] == 1) break; //一旦遇到障碍，后续都到不了dp[0][i] = 1;}for (int i = 0; i < n; i++) {if (obstacleGrid[i][0] == 1) break; 一旦遇到障碍，后续都到不了dp[i][0] = 1;}for (int i = 1; i < n; i++) {for (int j = 1; j < m; j++) {if (obstacleGrid[i][j] == 1) continue;     //遇到障碍物，跳过dp[i][j] = dp[i - 1][j] + dp[i][j - 1];}}return dp[n - 1][m - 1];}
}

9.1.3 整数拆分

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。

• 输入: 10                             输出: 36
• 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
• 说明: 你可以假设 n 不小于 2 且不大于 58。

dp[i]：分拆数字i，可以得到的最大乘积为dp[i]

dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j))

初始化dp[2] = 1

class Solution {public int integerBreak(int n) {//dp[i]为正整数i拆分结果的最大乘积int[] dp = new int[n+1]; dp[2] = 1;for (int i = 3; i <= n; ++i) {for (int j = 1; j < i - 1; ++j) {//j*(i-j)代表把i拆分为j和i-j两个数相乘//j*dp[i-j]代表把i拆分成j和继续把(i-j)这个数拆分，取(i-j)拆分结果中的最大乘积与j相乘
//每次都要再次比较一下dp[i],是因为要找到最优的那个j，使得dp[i]最大dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));}}return dp[n];}
}

9.1.4 不同的二叉搜索树

给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？

dp[3] = dp[0] * dp[2] + dp[1] * dp[1] + dp[2] * dp[0]

class Solution {public int numTrees(int n) {//初始化 dp 数组int[] dp = new int[n + 1];//初始化0个节点和1个节点的情况dp[0] = 1;dp[1] = 1;for (int i = 2; i <= n; i++) {for (int j = 1; j <= i; j++) {//对于第i个节点，需要考虑1作为根节点直到i作为根节点的情况，所以需要累加//一共i个节点，对于根节点j时,左子树的节点个数为j-1，右子树的节点个数为i-jdp[i] += dp[j - 1] * dp[i - j];}}return dp[n];}
}

9.2 0-1背包

关于背包问题

有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

问背包能背的物品最大价值是多少？

1 dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

 2 确定递推公式

• 不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以被背包内的价值依然和前面相同。)
• 放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
• 所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

3 dp数组如何初始化

• 当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。
• 当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。

其实从递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出dp[i][j] 是由左上方数值推导出来了，那么 其他下标初始为什么数值都可以，因为都会被覆盖。统一把dp数组统一初始为0，更方便一些。

public static void main(string[] args) {int[] weight = {1, 3, 4};int[] value = {15, 20, 30};int bagsize = 4;testweightbagproblem(weight, value, bagsize);}public static void testweightbagproblem(int[] weight, int[] value, int bagsize){int wlen = weight.length, value0 = 0;//定义dp数组：dp[i][j]表示背包容量为j时，前i个物品能获得的最大价值int[][] dp = new int[wlen + 1][bagsize + 1];//初始化：背包容量为0时，能获得的价值都为0for (int i = 0; i <= wlen; i++){dp[i][0] = value0;}//遍历顺序：先遍历物品，再遍历背包容量for (int i = 1; i <= wlen; i++){for (int j = 1; j <= bagsize; j++){if (j < weight[i - 1]){dp[i][j] = dp[i - 1][j];}else{dp[i][j] = math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);}}}//打印dp数组for (int i = 0; i <= wlen; i++){for (int j = 0; j <= bagsize; j++){system.out.print(dp[i][j] + " ");}system.out.print("\n");}}

一维dp数组（滚动数组）

• 在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])；
• 其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i])；
• 与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）。

1、确定dp数组的定义

• 在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

2、一维dp数组的递推公式

• dp[j]可以通过dp[j - weight[i]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最大价值。
• dp[j - weight[i]] + value[i] 表示 容量为 （j - 物品i重量） 的背包 加上 物品i的价值。（也就是容量为 j 的背包，放入物品 i 了之后的价值即：dp[j]）
• 此时dp[j]有两个选择，一个是取自己dp[j] 相当于 二维dp数组中的dp[i-1][j]，即不放物品 i，一个是取dp[j - weight[i]] + value[i]，即放物品 i，指定是取最大的，毕竟是求最大价值，

3、一维dp数组如何初始化

关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]，那么dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0。那么dp数组除了下标0的位置，初始为0。

dp数组在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数那么非0下标都初始化为0就可以了。

4、一维dp数组遍历顺序

二维dp遍历的时候，背包容量是从小到大，而一维dp遍历的时候，背包是从大到小。

倒序遍历是为了保证物品i只被放入一次！。但如果一旦正序遍历了，那么物品0就会被重复加入多次！

再来看看两个嵌套for循环的顺序，代码中是先遍历物品嵌套遍历背包容量，那可不可以先遍历背包容量嵌套遍历物品呢？不可以！

因为一维dp的写法，背包容量一定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。

 public static void main(String[] args) {int[] weight = {1, 3, 4};int[] value = {15, 20, 30};int bagWight = 4;testWeightBagProblem(weight, value, bagWight);}public static void testWeightBagProblem(int[] weight, int[] value, int bagWeight){int wLen = weight.length;//定义dp数组：dp[j]表示背包容量为j时，能获得的最大价值int[] dp = new int[bagWeight + 1];//遍历顺序：先遍历物品，再遍历背包容量for (int i = 0; i < wLen; i++){for (int j = bagWeight; j >= weight[i]; j--){dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);}}//打印dp数组for (int j = 0; j <= bagWeight; j++){System.out.print(dp[j] + " ");}}

9.2.1 分割等和子集

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

• 示例 1: 输入: [1, 5, 11, 5]         输出: true         解释: 数组可以分割成 [1, 5, 5] 和 [11]
• 示例 2: 输入: [1, 2, 3, 5]         输出: false         解释: 数组不能分割成两个元素和相等的子集

只有确定了如下四点，才能把01背包问题套到本题上来。

• 背包的体积为sum / 2
• 背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
• 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
• 背包中每一个元素是不可重复放入。

1、确定dp数组以及下标的含义

dp[j]表示 背包总容量是j，最大可以凑成j的子集总和为dp[j]

2、确定递推公式

dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);

3、dp数组如何初始化

dp[0]一定是0。题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。这样才能让dp数组在递归公式的过程中取的最大的价值，而不是被初始值覆盖了。

4、确定遍历顺序

物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历

class Solution {public boolean canPartition(int[] nums) {if(nums == null || nums.length == 0) return false;int n = nums.length;int sum = 0;for(int num : nums){sum += num;}//总和为奇数，不能平分if(sum % 2 != 0) return false;int target = sum / 2;int[] dp = new int[target + 1];for(int i = 0; i < n; i++){for(int j = target; j >= nums[i]; j--){//物品 i 的重量是 nums[i]，其价值也是 nums[i]dp[j] = Math.max(dp[j], dp[j-nums[i]] + nums[i]);}}return dp[target] == target;}
}

class Solution {public boolean canPartition(int[] nums) {int sum = 0;for (int i = 0; i < nums.length; i++) {sum += nums[i];}if (sum % 2 == 1)return false;int target = sum / 2;//dp[i][j]代表可装物品为0-i，背包容量为j的情况下，背包内容量的最大价值int[][] dp = new int[nums.length][target + 1];//初始化,dp[0][j]的最大价值nums[0](if j > weight[i])//dp[i][0]均为0，不用初始化for (int j = nums[0]; j <= target; j++) {dp[0][j] = nums[0];}//遍历物品，遍历背包//递推公式:for (int i = 1; i < nums.length; i++) {for (int j = 0; j <= target; j++) {//背包容量可以容纳nums[i]if (j >= nums[i]) {dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);} else {dp[i][j] = dp[i - 1][j];}}}return dp[nums.length - 1][target] == target;}
}

9.2.2 最后一块石头的重量

有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎； 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。 最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

1、确定dp数组以及下标的含义

dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背dp[j]这么重的石头。

2、确定递推公式

本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);

3、dp数组如何初始化

如何初始化dp[j]呢，因为重量都不会是负数，所以dp[j]都初始化为0就可以了，这样在递归公式dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);中dp[j]才不会初始值所覆盖。

4、确定遍历顺序

如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！

5、举例推导dp数组

class Solution {public int lastStoneWeightII(int[] stones) {int sum = 0;for (int i : stones) {sum += i;}int target = sum >> 1;//初始化dp数组int[] dp = new int[target + 1];for (int i = 0; i < stones.length; i++) {//采用倒序for (int j = target; j >= stones[i]; j--) {//两种情况，要么放，要么不放dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);}}return sum - 2 * dp[target];}
}

class Solution {public int lastStoneWeightII(int[] stones) {int sum = 0;for (int s : stones) {sum += s;}int target = sum / 2;//初始化，dp[i][j]为可以放0-i物品，背包容量为j的情况下背包中的最大价值int[][] dp = new int[stones.length][target + 1];//dp[i][0]默认初始化为0//dp[0][j]取决于stones[0]for (int j = stones[0]; j <= target; j++) {dp[0][j] = stones[0];}for (int i = 1; i < stones.length; i++) {for (int j = 1; j <= target; j++) {//注意是等于if (j >= stones[i]) {//不放:dp[i - 1][j] 放:dp[i - 1][j - stones[i]] + stones[i]dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - stones[i]] + stones[i]);} else {dp[i][j] = dp[i - 1][j];}}}System.out.println(dp[stones.length - 1][target]);return (sum - dp[stones.length - 1][target]) - dp[stones.length - 1][target];}
}

9.2.3 目标和

给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

示例：输入：nums: [1, 1, 1, 1, 1], S: 3                        输出：5

解释：
-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

既然为target，那么就一定有 left组合 - right组合 = target。left + right等于sum，而sum是固定的。公式来了， left - (sum - left) = target -> left = (target + sum)/2 。target是固定的，sum是固定的，left就可以求出来。此时问题就是在集合nums中找出和为left的组合（可用回溯法求）。

1、确定dp数组以及下标的含义

dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法

2、确定递推公式

• 已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 dp[5]。
• 已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 dp[5]。
• 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 dp[5]
• 已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 dp[5]
• 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 dp[5]

凑整dp[5]有多少方法呢，也就是把 所有的 dp[j - nums[i]] 累加起来。

dp[j] += dp[j - nums[i]]

3、dp数组如何初始化

从递归公式可以看出，在初始化的时候dp[0] 一定要初始化为1，因为dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递归结果将都是0。dp[j]其他下标对应的数值应该初始化为0

4、确定遍历顺序

对于01背包问题一维dp的遍历，nums放在外循环，target在内循环，且内循环倒序。

5、举例推导dp数组

输入：nums: [1, 1, 1, 1, 1], S: 3

bagSize = (S + sum) / 2 = (3 + 5) / 2 = 4

 求装满背包有几种方法的情况下，递推公式一般为：dp[j] += dp[j - nums[i]]

class Solution {public int findTargetSumWays(int[] nums, int target) {int sum = 0;for (int i = 0; i < nums.length; i++) sum += nums[i];if ((target + sum) % 2 != 0) return 0;int size = (target + sum) / 2;if(size < 0) size = -size;int[] dp = new int[size + 1];dp[0] = 1;for (int i = 0; i < nums.length; i++) {for (int j = size; j >= nums[i]; j--) {dp[j] += dp[j - nums[i]];}}return dp[size];}
}

9.2.4 一和零（两个维度的背包）

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的大小，该子集中 最多 有 m 个 0 和 n 个 1 。

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3 输出：4

解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。

本题中strs 数组里的元素就是物品，每个物品都是一个！而m 和 n相当于是一个背包，两个维度的背包。

1、确定dp数组（dp table）以及下标的含义

dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。

2、确定递推公式

• dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。
• dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。然后我们在遍历的过程中，取dp[i][j]的最大值。所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1)；此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])；对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。

3、dp数组如何初始化

因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。

4、确定遍历顺序

外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历，物品就是strs里的字符串，背包容量就是题目描述中的m和n。

5、举例推导dp数组

以输入：["10","0001","111001","1","0"]，m = 3，n = 3为例

class Solution {public int findMaxForm(String[] strs, int m, int n) {//dp[i][j]表示i个0和j个1时的最大子集int[][] dp = new int[m + 1][n + 1];int oneNum, zeroNum;for (String str : strs) {oneNum = 0;zeroNum = 0;for (char ch : str.toCharArray()) {if (ch == '0') {zeroNum++;} else {oneNum++;}}//倒序遍历for (int i = m; i >= zeroNum; i--) {for (int j = n; j >= oneNum; j--) {dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);}}}return dp[m][n];}
}

9.3 完全背包

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。

• 完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。

例子：背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

每件商品都有无限个！

与0-1背包相比：

1、完全背包和 0-1 背包唯一的区别在于：0-1背包遍历背包需要按照从大到小的顺序，而完全背包因为可以重复利用，则是按照从小到大的顺序。

2、0-1背包中，两个for循环，物品必须放在外卖，背包容量大小放在里面，颠倒的话就会造成背包只能放一个物品的错误，而对于完全背包（纯完全背包）来说，一维dp数组的两个for循环的顺序无所谓。

• 遍历物品在外层循环，遍历背包容量在内层循环，状态如图：

遍历背包容量在外层循环，遍历物品在内层循环，状态如图：

//先遍历物品，再遍历背包
private static void testCompletePack(){int[] weight = {1, 3, 4};int[] value = {15, 20, 30};int bagWeight = 4;int[] dp = new int[bagWeight + 1];for (int i = 0; i < weight.length; i++){ // 遍历物品for (int j = weight[i]; j <= bagWeight; j++){ // 遍历背包容量dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);}}for (int maxValue : dp){System.out.println(maxValue + "   ");}
}//先遍历背包，再遍历物品
private static void testCompletePackAnotherWay(){int[] weight = {1, 3, 4};int[] value = {15, 20, 30};int bagWeight = 4;int[] dp = new int[bagWeight + 1];for (int i = 1; i <= bagWeight; i++){ // 遍历背包容量for (int j = 0; j < weight.length; j++){ // 遍历物品if (i - weight[j] >= 0){dp[i] = Math.max(dp[i], dp[i - weight[j]] + value[j]);}}}for (int maxValue : dp){System.out.println(maxValue + "   ");}
}

9.3.1 零钱兑换 II

• 给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。
  • 输入: amount = 5, coins = [1, 2, 5]         输出: 4
  • 解释: 有四种方式可以凑成总金额: 5=5 5=2+2+1 5=2+1+1+1 5=1+1+1+1+1

1、确定dp数组以及下标的含义

• dp[j]：凑成总金额j的货币组合数为dp[j]

2、确定递推公式

• dp[j] （考虑coins[i]的组合总和） 就是所有的dp[j - coins[i]]（不考虑coins[i]）相加。所以递推公式：dp[j] += dp[j - coins[i]]；
• 求装满背包有几种方法，一般公式都是：dp[j] += dp[j - nums[i]];

3、dp数组如何初始化

首先dp[0]一定要为1，dp[0] = 1是 递归公式的基础。

4、确定遍历顺序

纯完全背包求得是能否凑成总和，和凑成总和的元素有没有顺序没关系，即：有顺序也行，没有顺序也行！而本题要求凑成总和的组合数，元素之间要求没有顺序。所以纯完全背包是能凑成总和就行，不用管怎么凑的。本题是求凑出来的方案个数，且每个方案个数是为组合数。

注意

• 外层for循环遍历物品（钱币），内层for遍历背包（金钱总额）这种遍历顺序中dp[j]里计算的是组合数！
• 外层for循环遍历背包（金钱总额），内层for遍历物品（钱币）这种遍历顺序中dp[j]里计算的是排列数！

5、举例推导dp数组

class Solution {public int change(int amount, int[] coins) {//递推表达式int[] dp = new int[amount + 1];//初始化dp数组，表示金额为0时只有一种情况，也就是什么都不装dp[0] = 1;for (int i = 0; i < coins.length; i++) {for (int j = coins[i]; j <= amount; j++) {dp[j] += dp[j - coins[i]];}}return dp[amount];}
}

9.3.2 零钱兑换

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。每种硬币的数量是无限的。

示例 1： 输入：coins = [1, 2, 5], amount = 11         输出：3         解释：11 = 5 + 5 + 1

每种硬币数量无限，可以看出是完全背包问题。

1、确定dp数组以及下标的含义

dp[j]：凑足总额为j所需钱币的最少个数为dp[j]

2、确定递推公式

得到dp[j]（考虑coins[i]），只有一个来源，dp[j - coins[i]]（没有考虑coins[i]）。凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。

递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);

3、dp数组如何初始化

首先凑足总金额为0所需钱币的个数一定是0，那么dp[0] = 0;

考虑到递推公式的特性，dp[j]必须初始化为一个最大的数，否则就会在min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖。

4、确定遍历顺序

本题求钱币最小个数，那么钱币有顺序和没有顺序都可以，都不影响钱币的最小个数。

所以本题并不强调集合是组合还是排列。

• 如果求组合数就是外层for循环遍历物品，内层for遍历背包。
• 如果求排列数就是外层for遍历背包，内层for循环遍历物品。

所以遍历顺序为：遍历顺序为：coins（物品）放在外循环，target（背包）在内循环。且内循环正序。

5、举例推导dp数组

class Solution {public int coinChange(int[] coins, int amount) {int max = Integer.MAX_VALUE;int[] dp = new int[amount + 1];//初始化dp数组为最大值for (int j = 0; j < dp.length; j++) {dp[j] = max;}//当金额为0时需要的硬币数目为0dp[0] = 0;for (int i = 0; i < coins.length; i++) {//正序遍历：完全背包每个硬币可以选择多次for (int j = coins[i]; j <= amount; j++) {//只有dp[j-coins[i]]不是初始最大值时，该位才有选择的必要if (dp[j - coins[i]] != max) {//选择硬币数目最小的情况dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);}}}return dp[amount] == max ? -1 : dp[amount];}
}

9.3.3 排列总和

给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。

顺序不同的序列被视作不同的组合（排列问题）。每个数字可以重复使用。

示例: nums = [1, 2, 3]         target = 4

所有可能的组合为： (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1)

1、确定dp数组以及下标的含义

dp[i]: 凑成目标正整数为i的排列个数为dp[i]

2、确定递推公式

dp[i]（考虑nums[j]）可以由 dp[i - nums[j]]（不考虑nums[j]） 推导出来。因为只要得到nums[j]，排列个数dp[i - nums[j]]，就是dp[i]的一部分。

递推公式：dp[i] += dp[i - nums[j]];

3、dp数组如何初始化

因为递推公式dp[i] += dp[i - nums[j]]的缘故，dp[0]要初始化为1，这样递归其他dp[i]的时候才会有数值基础。非0下标初始化为0，这样才不会影响dp[i]累加所有的dp[i - nums[j]]。

4、确定遍历顺序

本题为排列，且每个数可以重复使用，所以：target（背包）放在外循环，将nums（物品）放在内循环，内循环从前到后遍历。

5、举例来推导dp数组

class Solution {public int combinationSum4(int[] nums, int target) {int[] dp = new int[target + 1];dp[0] = 1;for (int i = 0; i <= target; i++) {for (int j = 0; j < nums.length; j++) {if (i >= nums[j]) {dp[i] += dp[i - nums[j]];}}}return dp[target];}
}

9.3.4 爬楼梯进阶版

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1~m个台阶。你有多少种不同的方法可以爬到楼顶呢？     注意：给定 n 是一个正整数。

1阶，2阶，.... m阶就是物品，楼顶就是背包。这是一个完全背包问题。

1、确定dp数组以及下标的含义

dp[i]：爬到有i个台阶的楼顶，有dp[i]种方法。

2、确定递推公式

求装满背包有几种方法，递推公式一般都是dp[i] += dp[i - nums[j]]；本题呢，dp[i]有几种来源，dp[i - 1]，dp[i - 2]，dp[i - 3] 等等，即：dp[i - j]。

那么递推公式为：dp[i] += dp[i - j]

3、dp数组如何初始化

既然递归公式是 dp[i] += dp[i - j]，那么dp[0] 一定为1，dp[0]是递归中一切数值的基础所在，如果dp[0]是0的话，其他数值都是0了。

4、确定遍历顺序

这是背包里求排列问题，即：1、2 步 和 2、1 步都是上三个台阶，但是这两种方法不一样。

所以需将target放在外循环，将nums放在内循环。内循环需要从前向后遍历。

class Solution {public int climbStairs(int n，int m) {int[] dp = new int[n + 1];int weight = m;dp[0] = 1;for (int i = 1; i <= n; i++) {for (int j = 1; j <= m; j++) {if (i >= j) dp[i] += dp[i - j];}}return dp[n];}
}

4.3.5 完全平方数

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1： 输入：n = 12         输出：3         解释：12 = 4 + 4 + 4

我来把题目翻译一下：完全平方数就是物品（可以无限件使用），凑个正整数n就是背包，问凑满这个背包最少有多少物品？

1、确定dp数组（dp table）以及下标的含义

dp[j]：和为j的完全平方数的最少数量为dp[j]

2、确定递推公式

递推公式：dp[j] = min(dp[j - i * i] + 1, dp[j]);

3、dp数组如何初始化

dp[0]表示 和为0的完全平方数的最小数量，那么dp[0]一定是0。

从递归公式dp[j] = min(dp[j - i * i] + 1, dp[j]);中可以看出每次dp[j]都要选最小的，所以非0下标的dp[j]一定要初始为最大值，这样dp[j]在递推的时候才不会被初始值覆盖。

4、确定遍历顺序

本题把背包和物品放在外面都可以的，因为数字可以重复使用，所以内层循环顺序。

5、举例推导dp数组

class Solution {// 版本一，先遍历物品, 再遍历背包public int numSquares(int n) {int max = Integer.MAX_VALUE;int[] dp = new int[n + 1];//初始化for (int j = 0; j <= n; j++) {dp[j] = max;}//当和为0时，组合的个数为0dp[0] = 0;// 遍历物品for (int i = 1; i * i <= n; i++) {// 遍历背包for (int j = i * i; j <= n; j++) {if (dp[j - i * i] != max) {dp[j] = Math.min(dp[j], dp[j - i * i] + 1);}}}return dp[n];}
}

4.3.6 单词拆分

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

• 示例 2： 输入: s = "applepenapple", wordDict = ["apple", "pen"]         输出: true
• 解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。   注意你可以重复使用字典中的单词。

单词就是物品，字符串s就是背包，单词能否组成字符串s，就是问物品能不能把背包装满。

拆分时可以重复使用字典中的单词，说明就是一个完全背包！

1、确定dp数组以及下标的含义

dp[i] : 字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词。

2、确定递推公式

如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true。（j < i ）。

所以递推公式是 if([j, i] 这个区间的子串出现在字典里 && dp[j]是true) 那么 dp[i] = true。

3、dp数组如何初始化

从递归公式中可以看出，dp[i] 的状态依靠 dp[j]是否为true，那么dp[0]就是递归的根基，dp[0]一定要为true，否则递归下去后面都都是false了。下标非0的dp[i]初始化为false，只要没有被覆盖说明都是不可拆分为一个或多个在字典中出现的单词。

4、确定遍历顺序

本题只要求能不能把背包装满，所以遍历顺序无所谓。

5、举例推导dp[i]

class Solution {public boolean wordBreak(String s, List<String> wordDict) {boolean[] valid = new boolean[s.length() + 1];valid[0] = true;for (int i = 1; i <= s.length(); i++) {for (int j = 0; j < i; j++) {if (wordDict.contains(s.substring(j,i)) && valid[j]) {valid[i] = true;}}}return valid[s.length()];}
}

// 回溯法+记忆化
class Solution {public boolean wordBreak(String s, List<String> wordDict) {Set<String> wordDictSet = new HashSet(wordDict);int[] memory = new int[s.length()];return backTrack(s, wordDictSet, 0, memory);}public boolean backTrack(String s, Set<String> wordDictSet, int startIndex, int[] memory) {// 结束条件if (startIndex >= s.length()) {return true;}if (memory[startIndex] != 0) {// 此处认为：memory[i] = 1 表示可以拼出i 及以后的字符子串， memory[i] = -1 表示不能return memory[startIndex] == 1 ? true : false;}for (int i = startIndex; i < s.length(); ++i) {// 处理 递归 回溯       循环不变量：[startIndex, i + 1)String word = s.substring(startIndex, i + 1);if (wordDictSet.contains(word) && backTrack(s, wordDictSet, i + 1, memory)) {memory[startIndex] = 1;return true;}}memory[startIndex] = -1;return false;}
}

9.4 多重背包

有N种物品和一个容量为V 的背包。第i种物品最多有Mi件可用，每件耗费的空间是Ci ，价值是Wi 。求解将哪些物品装入背包可使这些物品的耗费的空间 总和不超过背包容量，且价值总和最大。

多重背包和01背包是非常像的，每件物品最多有Mi件可用，把Mi件摊开，其实就是一个01背包问题了。

例如：背包最大重量为10。

物品为：

	重量	价值	数量
物品0	1	15	2
物品1	3	20	3
物品2	4	30	2

问背包能背的物品最大价值是多少？

等同于：

public void testMultiPack1(){// 版本一：改变物品数量为01背包格式List<Integer> weight = new ArrayList<>(Arrays.asList(1, 3, 4));List<Integer> value = new ArrayList<>(Arrays.asList(15, 20, 30));List<Integer> nums = new ArrayList<>(Arrays.asList(2, 3, 2));int bagWeight = 10;for (int i = 0; i < nums.size(); i++) {while (nums.get(i) > 1) { // 把物品展开为iweight.add(weight.get(i));value.add(value.get(i));nums.set(i, nums.get(i) - 1);}}int[] dp = new int[bagWeight + 1];for(int i = 0; i < weight.size(); i++) { // 遍历物品for(int j = bagWeight; j >= weight.get(i); j--) { // 遍历背包容量dp[j] = Math.max(dp[j], dp[j - weight.get(i)] + value.get(i));}System.out.println(Arrays.toString(dp));}
}

public void testMultiPack2(){// 版本二：改变遍历个数int[] weight = new int[] {1, 3, 4};int[] value = new int[] {15, 20, 30};int[] nums = new int[] {2, 3, 2};int bagWeight = 10;int[] dp = new int[bagWeight + 1];for(int i = 0; i < weight.length; i++) { // 遍历物品for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量// 以上为01背包，然后加一个遍历个数for (int k = 1; k <= nums[i] && (j - k * weight[i]) >= 0; k++) { // 遍历个数dp[j] = Math.max(dp[j], dp[j - k * weight[i]] + k * value[i]);}System.out.println(Arrays.toString(dp));}}
}

9.5 背包问题总结

问题分类（递推公式）

1、问能否能装满背包（或者最多装多少）：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]); ，对应题目如下：

• 动态规划：1049.最后一块石头的重量 II(opens new window)

2、问装满背包有几种方法：dp[j] += dp[j - nums[i]] ，对应题目如下：

• 动态规划：494.目标和(opens new window)
• 动态规划：518. 零钱兑换 II(opens new window)
• 动态规划：377.组合总和Ⅳ(opens new window)
• 动态规划：70. 爬楼梯进阶版（完全背包）(opens new window)

3、问背包装满最大价值：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]); ，对应题目如下：

• 动态规划：474.一和零(opens new window)

4、问装满背包所有物品的最小个数：dp[j] = min(dp[j - coins[i]] + 1, dp[j]); ，对应题目如下：

• 动态规划：322.零钱兑换(opens new window)
• 动态规划：279.完全平方数

遍历顺序

1、0-1背包

• 二维dp数组01背包先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历。
• 一维dp数组01背包只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。

2、完全背包

纯完全背包的一维dp数组实现，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历。

• 如果求组合数就是外层for循环遍历物品，内层for遍历背包。
• 如果求排列数就是外层for遍历背包，内层for循环遍历物品。

9.6 打家劫舍问题

9.6.1 打家劫舍 I

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

• 示例 1： 输入：[1,2,3,1]         输出：4
• 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。   偷窃到的最高金额 = 1 + 3 = 4 。

动规五部曲：

1、确定dp数组（dp table）以及下标的含义

dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。

2、确定递推公式

决定dp[i]的因素就是第i房间偷还是不偷。

• 如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。
• 如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房，（注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点）

然后dp[i]取最大值，即 dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

3、dp数组如何初始化

从递推公式dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])；可以看出，递推公式的基础就是dp[0] 和 dp[1]，从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值即：dp[1] = max(nums[0], nums[1])；

4、确定遍历顺序

dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历。

5、举例推导dp数组

// 动态规划
class Solution {public int rob(int[] nums) {if (nums == null || nums.length == 0) return 0;if (nums.length == 1) return nums[0];int[] dp = new int[nums.length];dp[0] = nums[0];dp[1] = Math.max(dp[0], nums[1]);for (int i = 2; i < nums.length; i++) {dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);}return dp[nums.length - 1];}
}

9.6.2 打家劫舍II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，能够偷窃到的最高金额。

• 输入：nums = [2,3,2]                 输出：3
• 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

对于一个数组，成环的话主要有如下三种情况：

• 情况一：考虑不包含首尾元素

• 情况二：考虑包含首元素，不包含尾元素

• 情况三：考虑包含尾元素，不包含首元素

而情况二 和 情况三 都包含了情况一了，所以只考虑情况二和情况三就可以了。

所以取情况二和情况三的最大值就行。

class Solution {public int rob(int[] nums) {if (nums == null || nums.length == 0)return 0;int len = nums.length;if (len == 1)return nums[0];return Math.max(robAction(nums, 0, len - 1), robAction(nums, 1, len));}int robAction(int[] nums, int start, int end) {int x = 0, y = 0, z = 0;for (int i = start; i < end; i++) {y = z;                             //dp[i-1]z = Math.max(y, x + nums[i]);      //z为dp[i] x为dp[i-2]x = y;}return z;}
}

9.6.3 打家劫舍 III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

本题一定是要后序遍历，因为通过递归函数的返回值来做下一步计算。

关键是要讨论当前节点抢还是不抢。如果抢了当前节点，两个孩子就不能动，如果没抢当前节点，就可以考虑抢左右孩子。

这道题目算是树形dp的入门题目，因为是在树上进行状态转移，所以要以递归三部曲为框架，其中融合动规五部曲来解题。

class Solution {// 1.递归去偷，超时public int rob(TreeNode root) {if (root == null)return 0;int money = root.val;if (root.left != null) {money += rob(root.left.left) + rob(root.left.right);}if (root.right != null) {money += rob(root.right.left) + rob(root.right.right);}return Math.max(money, rob(root.left) + rob(root.right));}// 2.递归去偷，记录状态// 执行用时：3 ms , 在所有 Java 提交中击败了 56.24% 的用户public int rob1(TreeNode root) {Map<TreeNode, Integer> memo = new HashMap<>();return robAction(root, memo);}int robAction(TreeNode root, Map<TreeNode, Integer> memo) {if (root == null)return 0;if (memo.containsKey(root))return memo.get(root);int money = root.val;if (root.left != null) {money += robAction(root.left.left, memo) + robAction(root.left.right, memo);}if (root.right != null) {money += robAction(root.right.left, memo) + robAction(root.right.right, memo);}int res = Math.max(money, robAction(root.left, memo) + robAction(root.right, memo));memo.put(root, res);return res;}// 3.状态标记递归// 执行用时：0 ms , 在所有 Java 提交中击败了 100% 的用户// 不偷：Max(左孩子不偷，左孩子偷) + Max(又孩子不偷，右孩子偷)// root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) +// Math.max(rob(root.right)[0], rob(root.right)[1])// 偷：左孩子不偷+ 右孩子不偷 + 当前节点偷// root[1] = rob(root.left)[0] + rob(root.right)[0] + root.val;public int rob3(TreeNode root) {int[] res = robAction1(root);return Math.max(res[0], res[1]);}int[] robAction1(TreeNode root) {int res[] = new int[2];if (root == null)return res;int[] left = robAction1(root.left);int[] right = robAction1(root.right);res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]); //0代表不偷该节点res[1] = root.val + left[0] + right[0];  //1代表偷该节点return res;}
}

9.7 买卖股票问题

9.7.1 买卖股票的最佳时机 I

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

输入：[7,1,5,3,6,4]                输出：5

贪心算法求解

class Solution {public int maxProfit(int[] prices) {// 找到一个最小的购入点int low = Integer.MAX_VALUE;// res不断更新，直到数组循环完毕int res = 0;for(int i = 0; i < prices.length; i++){low = Math.min(prices[i], low);res = Math.max(prices[i] - low, res);}return res;}
}

动态规划就求解

1、确定dp数组的下表及含义

dp[i][0] 表示第i天持有股票所得最多现金 ，dp[i][1] 表示第 i 天不持有股票所得最多现金。

2、确定递推公式

dp[i][0] = max(dp[i - 1][0], -prices[i]);   因为只能持有一次股票，所以当第i天买入股票是-prices[i]

dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

3、初始化dp数组

基础都是要从dp[0][0]和dp[0][1]推导出来。dp[0][0] = -prices[0]；dp[0][1] = 0;

4、确定遍历顺序

从递推公式可以看出dp[i]都是有dp[i - 1]推导出来的，那么一定是从前向后遍历。

5、举例推导dp数组

// 解法1
class Solution {public int maxProfit(int[] prices) {if (prices == null || prices.length == 0) return 0;int length = prices.length;// dp[i][0]代表第i天持有股票的最大收益// dp[i][1]代表第i天不持有股票的最大收益int[][] dp = new int[length][2];int result = 0;dp[0][0] = -prices[0];dp[0][1] = 0;for (int i = 1; i < length; i++) {dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);}return dp[length - 1][1];}
}

9.7.2 买卖股票的最佳时机 II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:        输入: [7,1,5,3,6,4]        输出: 7

贪心算法解题：

贪心算法只需要将所有递增的区间累加即为最大获利。

 动态规划解题

与买卖股票最佳时机I除了递推公式不一样，其他完全一样。

• dp[i][0] = max(dp[i - 1][0], dp[i - 1][01]-prices[i]);   因为可以多次持有股票，所以当第i天买入股票是-prices[i]
• dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

// 动态规划
class Solution // 实现1：二维数组存储// 可以将每天持有与否的情况分别用 dp[i][0] 和 dp[i][1] 来进行存储// 时间复杂度：O(n)，空间复杂度：O(n)public int maxProfit(int[] prices) {int n = prices.length;int[][] dp = new int[n][2];     // 创建二维数组存储状态dp[0][0] = 0;                   // 初始状态dp[0][1] = -prices[0];for (int i = 1; i < n; ++i) {dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);    // 第 i 天，没有股票dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);    // 第 i 天，持有股票}return dp[n - 1][0];    // 卖出股票收益高于持有股票收益，因此取[0]}
}

// 优化空间    滚动数组
class Solution {public int maxProfit(int[] prices) {int[] dp = new int[2];// 0表示持有，1表示卖出dp[0] = -prices[0];dp[1] = 0;for(int i = 1; i <= prices.length; i++){// 前一天持有; 既然不限制交易次数，那么再次买股票时，要加上之前的收益dp[0] = Math.max(dp[0], dp[1] - prices[i-1]);// 前一天卖出; 或当天卖出，当天卖出，得先持有dp[1] = Math.max(dp[1], dp[0] + prices[i-1]);}return dp[1];}
}

9.7.3 买卖股票的最佳时机 III

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

• 示例 1: 输入：prices = [3,3,5,0,0,3,1,4]         输出：6

关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。

1、确定dp数组以及下标的含义

一天一共就有五个状态：

1. 没有操作  对应0
2. 第一次买入   对应1
3. 第一次卖出   对应2
4. 第二次买入   对应3
5. 第二次卖出   对应4

dp[i][j]中   i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态 j 所剩最大现金。

2、确定递推公式

• dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);
• dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
• dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
• dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

3、dp数组如何初始化

dp[0][0] = 0;   dp[0][1] = -prices[0];    dp[0][2] = 0;  dp[0][3] = -prices[0];    dp[0][4] = 0;

4、确定遍历顺序

从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

5、举例推导dp数组   以输入[1,2,3,4,5]为例

// 版本一
class Solution {public int maxProfit(int[] prices) {int len = prices.length;// 边界判断, 题目中 length >= 1, 所以可省去if (prices.length == 0) return 0;/** 定义 5 种状态:* 0: 没有操作, 1: 第一次买入, 2: 第一次卖出, 3: 第二次买入, 4: 第二次卖出*/int[][] dp = new int[len][5];dp[0][1] = -prices[0];// 初始化第二次买入的状态是确保 最后结果是最多两次买卖的最大利润dp[0][3] = -prices[0];for (int i = 1; i < len; i++) {dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);dp[i][2] = Math.max(dp[i - 1][2], dp[i][1] + prices[i]);dp[i][3] = Math.max(dp[i - 1][3], dp[i][2] - prices[i]);dp[i][4] = Math.max(dp[i - 1][4], dp[i][3] + prices[i]);}return dp[len - 1][4];}
}// 版本二: 空间优化
class Solution {public int maxProfit(int[] prices) {int[] dp = new int[4]; // 存储两次交易的状态就行了// dp[0]代表第一次交易的买入dp[0] = -prices[0];// dp[1]代表第一次交易的卖出dp[1] = 0;// dp[2]代表第二次交易的买入dp[2] = -prices[0];// dp[3]代表第二次交易的卖出dp[3] = 0;for(int i = 1; i <= prices.length; i++){// 要么保持不变，要么没有就买，有了就卖dp[0] = Math.max(dp[0], -prices[i-1]);dp[1] = Math.max(dp[1], dp[0]+prices[i-1]);// 这已经是第二次交易了，所以得加上前一次交易卖出去的收获dp[2] = Math.max(dp[2], dp[1]-prices[i-1]);dp[3] = Math.max(dp[3], dp[2]+ prices[i-1]);}return dp[3];}
}

9.7.4 买卖股票的最佳时机IV

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

• 示例 1： 输入：k = 2, prices = [2,4,1]         输出：2
• 解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2。

1、确定dp数组以及下标的含义

使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]

j 的状态表示为：

• 0 表示不操作
• 1 第一次买入
• 2 第一次卖出
• 3 第二次买入
• 4 第二次卖出
• .....

除了0以外，偶数就是卖出，奇数就是买入。题目要求是至多有K笔交易，那么j的范围就定义为 2 * k + 1 就可以了。

2、确定递推公式

for (int j = 0; j < 2 * k - 1; j += 2) {dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
}

3、初始化

for (int j = 1; j < 2 * k; j += 2) {dp[0][j] = -prices[0];
}

4、确定遍历顺序

从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

5、举例推导dp数组

以输入[1,2,3,4,5]，k=2为例。

// 版本一: 三维 dp数组
class Solution {public int maxProfit(int k, int[] prices) {if (prices.length == 0) return 0;// [天数][交易次数][是否持有股票]int len = prices.length;int[][][] dp = new int[len][k + 1][2];// dp数组初始化// 初始化所有的交易次数是为确保 最后结果是最多 k 次买卖的最大利润for (int i = 0; i <= k; i++) {dp[0][i][1] = -prices[0];}for (int i = 1; i < len; i++) {for (int j = 1; j <= k; j++) {// dp方程, 0表示不持有/卖出, 1表示持有/买入dp[i][j][0] = Math.max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i]);dp[i][j][1] = Math.max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i]);}}return dp[len - 1][k][0];}
}// 版本二: 二维 dp数组
class Solution {public int maxProfit(int k, int[] prices) {if (prices.length == 0) return 0;// [天数][股票状态]// 股票状态: 奇数表示第 k 次交易持有/买入, 偶数表示第 k 次交易不持有/卖出, 0 表示没有操作int len = prices.length;int[][] dp = new int[len][k*2 + 1];// dp数组的初始化, 与版本一同理for (int i = 1; i < k*2; i += 2) {dp[0][i] = -prices[0];}for (int i = 1; i < len; i++) {for (int j = 0; j < k*2 - 1; j += 2) {dp[i][j + 1] = Math.max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);dp[i][j + 2] = Math.max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);}}return dp[len - 1][k*2];}
}//版本三：一维 dp数组
class Solution {public int maxProfit(int k, int[] prices) {if(prices.length == 0){return 0;}if(k == 0){return 0;}// 其实就是123题的扩展，123题只用记录2次交易的状态// 这里记录k次交易的状态就行了// 每次交易都有买入，卖出两个状态，所以要乘 2int[] dp = new int[2 * k];// 按123题解题格式那样，做一个初始化for(int i = 0; i < dp.length / 2; i++){dp[i * 2] = -prices[0];}for(int i = 1; i <= prices.length; i++){dp[0] = Math.max(dp[0], -prices[i - 1]);dp[1] = Math.max(dp[1], dp[0] + prices[i - 1]);// 还是与123题一样，与123题对照来看// 就很容易啦for(int j = 2; j < dp.length; j += 2){dp[j] = Math.max(dp[j], dp[j - 1] - prices[i-1]);dp[j + 1] = Math.max(dp[j + 1], dp[j] + prices[i - 1]);}}// 返回最后一次交易卖出状态的结果就行了return dp[dp.length - 1];}
}

9.7.5 最佳买卖股票时机含冷冻期

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

• 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
• 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

示例: 输入: [1,2,3,0,2]         输出: 3         解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

动规五部曲

1、确定dp数组以及下标的含义

dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。

区分出如下四个状态：

• 状态一（0）：买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）
• 卖出股票状态，这里就有两种卖出股票状态
  • 状态二（1）：两天前就卖出了股票，正好昨天是冷冻期，今天保持卖出状态；或者早就过了冷冻期，一直保持卖出状态
  • 状态三（2）：今天卖出了股票
• 状态四（3）：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

2、确定递推公式

dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);

dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);

dp[i][2] = dp[i - 1][0] + prices[i];

dp[i][3] = dp[i - 1][2];

3、dp数组如何初始化

dp[0][0] = -prices[0]   dp[0][1]=0  dp[0][2]=0  dp[0][3]=0

4、确定遍历顺序

从递归公式上可以看出，dp[i] 依赖于 dp[i-1]，所以是从前向后遍历。

5、举例推导dp数组

以 [1,2,3,0,2] 为例，dp数组如下：

// 一维数组优化
class Solution {public int maxProfit(int[] prices) {int[] dp=new int[4];dp[0] = -prices[0];dp[1] = 0;for(int i = 1; i <= prices.length; i++){// 使用临时变量来保存dp[0], dp[2]// 因为马上dp[0]和dp[2]的数据都会变 int temp = dp[0];int temp1 = dp[2];dp[0] = Math.max(dp[0], Math.max(dp[3], dp[1]) - prices[i-1]);dp[1] = Math.max(dp[1], dp[3]);dp[2] = temp + prices[i-1];dp[3] = temp1;}return Math.max(dp[3],Math.max(dp[1],dp[2]));}
}

9.7.6 买卖股票的最佳时机含手续费

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。返回获得利润的最大值。

示例 1: 输入: prices = [1, 3, 2, 8, 4, 9],   fee = 2         输出: 8

dp[i][0] 表示第i天持有股票所省最多现金。 dp[i][1] 表示第i天不持有股票所得最多现金。

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);   不持有股票

/*** 卖出时支付手续费* @param prices* @param fee* @return*/
public int maxProfit(int[] prices, int fee) {int len = prices.length;// 0 : 持股（买入）// 1 : 不持股（售出）// dp 定义第i天持股/不持股 所得最多现金int[][] dp = new int[len][2];dp[0][0] = -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][1] = Math.max(dp[i - 1][0] + prices[i] - fee, dp[i - 1][1]);}return Math.max(dp[len - 1][0], dp[len - 1][1]);
}/*** 买入时支付手续费* @param prices* @param fee* @return*/
public int maxProfit(int[] prices, int fee) {int len = prices.length;// 0 : 持股（买入）// 1 : 不持股（售出）// dp 定义第i天持股/不持股 所得最多现金int[][] dp = new int[len][2];// 考虑买入的时候就支付手续费dp[0][0] = -prices[0] - fee;for (int i = 1; i < len; i++) {dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i] - fee);dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);}return Math.max(dp[len - 1][0], dp[len - 1][1]);
}// 一维数组优化
class Solution {public int maxProfit(int[] prices, int fee) {int[] dp = new int[2];dp[0] = -prices[0];dp[1] = 0;for (int i = 1; i <= prices.length; i++) {dp[0] = Math.max(dp[0], dp[1] - prices[i - 1]);dp[1] = Math.max(dp[1], dp[0] + prices[i - 1] - fee);}return dp[1];}
}

9.7.7 股票总结

9.8 子序列问题

9.8.1 最长递增子序列

给你一个整数数组 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 。

1、dp[i]的定义

dp[i]表示i之前包括i的最长上升子序列的长度。

2、状态转移方程

位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。

所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是我们要取dp[j] + 1的最大值。

3、dp[i]的初始化

每一个i，对应的dp[i]（即最长上升子序列）起始大小至少都是1。

4、确定遍历顺序

dp[i] 是有0到i-1各个位置的最长升序子序列 推导而来，那么遍历i一定是从前向后遍历。

j其实就是0到i-1，遍历i的循环在外层，遍历j则在内层

5、举例推导dp数组

class Solution {public int lengthOfLIS(int[] nums) {int[] dp = new int[nums.length];Arrays.fill(dp, 1);for (int i = 0; i < dp.length; i++) {for (int j = 0; j < i; j++) {if (nums[i] > nums[j]) {dp[i] = Math.max(dp[i], dp[j] + 1);}}}int res = 0;for (int i = 0; i < dp.length; i++) {res = Math.max(res, dp[i]);}return res;}
}

9.8.2 最长连续递增序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

示例 1： 输入：nums = [1,3,5,4,7] 输出：3

贪心：

public static int findLengthOfLCIS(int[] nums) {if (nums.length == 0) return 0;int res = 1; // 连续子序列最少也是1int count = 1;for (int i = 0; i < nums.length - 1; i++) {if (nums[i + 1] > nums[i]) { // 连续记录count++;} else { // 不连续，count从头开始count = 1;}if (count > res) res = count;}return res;
}

动规：

 public static int findLengthOfLCIS(int[] nums) {int[] dp = new int[nums.length];for (int i = 0; i < dp.length; i++) {dp[i] = 1;}int res = 1;for (int i = 0; i < nums.length - 1; i++) {if (nums[i + 1] > nums[i]) {dp[i + 1] = dp[i] + 1;}res = res > dp[i + 1] ? res : dp[i + 1];}return res;}

9.8.3 最长重复子数组

给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。

输入： A: [1,2,3,2,1] B: [3,2,1,4,7]         输出：3         解释： 长度最长的公共子数组是 [3, 2, 1] 。

动规五部曲：

1、确定dp数组（dp table）以及下标的含义

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。我们在遍历dp[i][j]的时候i 和 j都要从1开始。

2、确定递推公式

根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;

3、dp数组如何初始化

根据dp[i][j]的定义，dp[i][0] 和dp[0][j]其实都是没有意义的，但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1；所以dp[i][0] 和dp[0][j]初始化为0，dp[0][0]初始为0。

4、确定遍历顺序

把A、B放在外层都行，遍历顺序从前到后。

5、举例推导dp数组

class Solution {public int findLength(int[] nums1, int[] nums2) {int result = 0;int[][] dp = new int[nums1.length + 1][nums2.length + 1];for (int i = 1; i < nums1.length + 1; i++) {for (int j = 1; j < nums2.length + 1; j++) {if (nums1[i - 1] == nums2[j - 1]) {dp[i][j] = dp[i - 1][j - 1] + 1;result = Math.max(result, dp[i][j]);}}}return result;}
}

9.8.4 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。

• 输入：text1 = "abcde", text2 = "ace"                输出：3
• 解释：最长公共子序列是 "ace"，它的长度为 3。

1、确定dp数组（dp table）以及下标的含义

dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]

2、确定递推公式

主要就是两大情况： text1[i - 1] 与 text2[j - 1]相同，text1[i - 1] 与 text2[j - 1]不相同，如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1；如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。

3、dp数组如何初始化

test1[0, i-1]和空串的最长公共子序列自然是0，所以dp[i][0] = 0；同理dp[0][j]也是0。

4、确定遍历顺序

从前到后，从上到下。

5、举例推导dp数组

class Solution {public int longestCommonSubsequence(String text1, String text2) {int[][] dp = new int[text1.length() + 1][text2.length() + 1]; // 先对dp数组做初始化操作for (int i = 1 ; i <= text1.length() ; i++) {char char1 = text1.charAt(i - 1);for (int j = 1; j <= text2.length(); j++) {char char2 = text2.charAt(j - 1);if (char1 == char2) { // 开始列出状态转移方程dp[i][j] = dp[i - 1][j - 1] + 1;} else {dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);}}}return dp[text1.length()][text2.length()];}
}

9.8.5 不相交的线

我们在两条独立的水平线上按给定的顺序写下 A 和 B 中的整数。现在，我们可以绘制一些连接两个数字 A[i] 和 B[j] 的直线，只要 A[i] == B[j]，且我们绘制的直线不与任何其他连线（非水平线）相交。以这种方法绘制线条，并返回我们可以绘制的最大连线数。

本题分析过后，求得就是两个序列的最大公共子序；与上一题完全一样，直接相同代码A出来。

class Solution {public int maxUncrossedLines(int[] A, int[] B) {int [][] dp = new int[A.length+1][B.length+1];for(int i=1;i<=A.length;i++) {for(int j=1;j<=B.length;j++) {if (A[i-1]==B[j-1]) {dp[i][j]=dp[i-1][j-1]+1;}else {dp[i][j]=Math.max(dp[i-1][j], dp[i][j-1]);}}}return dp[A.length][B.length];}
}

9.8.6 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例: 输入: [-2,1,-3,4,-1,2,1,-5,4]         输出: 6         解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

这道题之前用贪心算法已经A过，这里用dp做一下。

动规五部曲如下：

1、确定dp数组（dp table）以及下标的含义

dp[i]：包括下标i之前的最大连续子序列和为dp[i]。

2、确定递推公式

dp[i]只有两个方向可以推出来：

• dp[i - 1] + nums[i]，即：nums[i]加入当前连续子序列和
• nums[i]，即：从头开始计算当前连续子序列和

一定是取最大的，所以 dp[i] = max(dp[i - 1] + nums[i], nums[i]);

3、dp数组如何初始化

从递推公式可以看出来dp[i]是依赖于dp[i - 1]的状态，dp[0]就是递推公式的基础。dp[0] = nums[0]。

4、确定遍历顺序

递推公式中dp[i]依赖于dp[i - 1]的状态，需要从前向后遍历。

5、举例推导dp数组

public static int maxSubArray(int[] nums) {if (nums.length == 0) {return 0;}int res = nums[0];int[] dp = new int[nums.length];dp[0] = nums[0];for (int i = 1; i < nums.length; i++) {dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);res = res > dp[i] ? res : dp[i];}return res;}

9.8.7 判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

示例 1： 输入：s = "abc", t = "ahbgdc"         输出：true

1、确定dp数组（dp table）以及下标的含义

dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。

2、确定递推公式

在确定递推公式的时候，首先要考虑如下两种操作，整理如下：

• if (s[i - 1] == t[j - 1])        t中找到了一个字符在s中也出现了
• if (s[i - 1] != t[j - 1])        相当于t要删除元素，继续匹配

if (s[i - 1] == t[j - 1])，那么dp[i][j] = dp[i - 1][j - 1] + 1;

if (s[i - 1] != t[j - 1])，此时相当于t要删除元素，t如果把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是 看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1];

3、初始化

4、确定遍历顺序

同理从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，那么遍历顺序也应该是从上到下，从左到右

5、举例推导dp数组

class Solution {public boolean isSubsequence(String s, String t) {int length1 = s.length(); int length2 = t.length();int[][] dp = new int[length1+1][length2+1];for(int i = 1; i <= length1; i++){for(int j = 1; j <= length2; j++){if(s.charAt(i-1) == t.charAt(j-1)){dp[i][j] = dp[i-1][j-1] + 1;}else{dp[i][j] = dp[i][j-1];}}}if(dp[length1][length2] == length1){return true;}else{return false;}}
}

9.8.8 不同的子序列

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

1、确定dp数组（dp table）以及下标的含义

dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。

2、确定递推公式

这一类问题，基本是要分析两种情况

• s[i - 1] 与 t[j - 1]相等                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
• s[i - 1] 与 t[j - 1] 不相等                dp[i][j] = dp[i - 1][j];

当s[i - 1] 与 t[j - 1]相等时，dp[i][j]可以有两部分组成。一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。当s[i - 1] 与 t[j - 1]不相等时，dp[i][j]只有一部分组成，不用s[i - 1]来匹配，即：dp[i - 1][j]

3、dp数组如何初始化

dp[i][0]=1        dp[0][j]=0        dp[0][0]=1

4、确定遍历顺序

遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。

5、举例推导dp数组

class Solution {public int numDistinct(String s, String t) {int[][] dp = new int[s.length() + 1][t.length() + 1];for (int i = 0; i < s.length() + 1; i++) {dp[i][0] = 1;}for (int i = 1; i < s.length() + 1; i++) {for (int j = 1; j < t.length() + 1; j++) {if (s.charAt(i - 1) == t.charAt(j - 1)) {dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];}else{dp[i][j] = dp[i - 1][j];}}}return dp[s.length()][t.length()];}
}

9.8.9 两个字符串的删除操作

给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。

• 输入: "sea", "eat"        输出: 2
• 解释: 第一步将"sea"变为"ea"，第二步将"eat"变为"ea"

本题和最长公共子序和基本相同，只要求出两个字符串的最长公共子序列长度即可，那么除了最长公共子序列之外的字符都是必须删除的，最后用两个字符串的总长度减去两个最长公共子序列的长度就是删除的最少步数。

class Solution {public int longestCommonSubsequence(String text1, String text2) {int[][] dp = new int[text1.length() + 1][text2.length() + 1]; // 先对dp数组做初始化操作int m = text1.length();int n = text2.length();for (int i = 1 ; i <= text1.length() ; i++) {char char1 = text1.charAt(i - 1);for (int j = 1; j <= text2.length(); j++) {char char2 = text2.charAt(j - 1);if (char1 == char2) { // 开始列出状态转移方程dp[i][j] = dp[i - 1][j - 1] + 1;} else {dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);}}}return m + n - 2*dp[text1.length()][text2.length()];}
}

9.8.10 编辑距离

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

• 插入一个字符
• 删除一个字符
• 替换一个字符
• 示例 1： 输入：word1 = "horse", word2 = "ros"         输出：3
• 解释： horse -> rorse (将 'h' 替换为 'r') rorse -> rose (删除 'r') rose -> ros (删除 'e')

1、确定dp数组（dp table）以及下标的含义

dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]。

2、确定递推公式

if (word1[i - 1] == word2[j - 1])不操作
if (word1[i - 1] != word2[j - 1])增删换

if (word1[i - 1] == word2[j - 1]) {dp[i][j] = dp[i - 1][j - 1];
}
else {dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
}

3、dp数组如何初始化

dp[i][0] = i;    dp[0][j] = j;

4、确定遍历顺序

从左到右从上到下去遍历。

5、举例推导dp数组

public int minDistance(String word1, String word2) {int m = word1.length();int n = word2.length();int[][] dp = new int[m + 1][n + 1];// 初始化for (int i = 1; i <= m; i++) {dp[i][0] =  i;}for (int j = 1; j <= n; j++) {dp[0][j] = j;}for (int i = 1; i <= m; i++) {for (int j = 1; j <= n; j++) {// 因为dp数组有效位从1开始// 所以当前遍历到的字符串的位置为i-1 | j-1if (word1.charAt(i - 1) == word2.charAt(j - 1)) {dp[i][j] = dp[i - 1][j - 1];} else {dp[i][j] = Math.min(Math.min(dp[i - 1][j - 1], dp[i][j - 1]), dp[i - 1][j]) + 1;}}}return dp[m][n];
}

9.8.11 回文子串

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

输入："aaa"         输出：6         解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

动态规划

1、确定dp数组（dp table）以及下标的含义

布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。

2、确定递推公式

if (s[i] == s[j]) {if (j - i <= 1) { // 情况一 和 情况二result++;dp[i][j] = true;} else if (dp[i + 1][j - 1]) { // 情况三result++;dp[i][j] = true;}
}

3、dp数组如何初始化

dp[i][j]全部初始化为false。

4、确定遍历顺序

首先从递推公式中可以看出，情况三是根据dp[i + 1][j - 1]是否为true，在对dp[i][j]进行赋值true的。

dp[i + 1][j - 1] 在 dp[i][j]的左下角，如图：

如果这矩阵是从上到下，从左到右遍历，那么会用到没有计算过的dp[i + 1][j - 1]，也就是根据不确定是不是回文的区间[i+1,j-1]，来判断了[i,j]是不是回文，那结果一定是不对的。

所以一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。

5、举例推导dp数组

举例，输入："aaa"，dp[i][j]状态如下：

class Solution {public int countSubstrings(String s) {int len, ans = 0;if (s == null || (len = s.length()) < 1) return 0;//dp[i][j]：s字符串下标i到下标j的字串是否是一个回文串，即s[i, j]boolean[][] dp = new boolean[len][len];for (int j = 0; j < len; j++) {for (int i = 0; i <= j; i++) {//当两端字母一样时，才可以两端收缩进一步判断if (s.charAt(i) == s.charAt(j)) {//i++，j--，即两端收缩之后i,j指针指向同一个字符或者i超过j了,必然是一个回文串if (j - i < 3) {dp[i][j] = true;} else {//否则通过收缩之后的字串判断dp[i][j] = dp[i + 1][j - 1];}} else {//两端字符不一样，不是回文串dp[i][j] = false;}}}//遍历每一个字串，统计回文串个数for (int i = 0; i < len; i++) {for (int j = 0; j < len; j++) {if (dp[i][j]) ans++;}}return ans;}
}

 双指针法

本题也可以用双指针法。回文串，确定中心然后向两边扩散看是不是对称的就可以。

在遍历中心点的时候，要注意中心点有两种情况。

一个元素可以作为中心点，两个元素也可以作为中心点。

class Solution {public int countSubstrings(String s) {int len, ans = 0;if (s == null || (len = s.length()) < 1) return 0;//总共有2 * len - 1个中心点for (int i = 0; i < 2 * len - 1; i++) {//通过遍历每个回文中心，向两边扩散，并判断是否回文字串//有两种情况，left == right，right = left + 1，这两种回文中心是不一样的int left = i / 2, right = left + i % 2;while (left >= 0 && right < len && s.charAt(left) == s.charAt(right)) {//如果当前是一个回文串，则记录数量ans++;left--;right++;}}return ans;}
}

9.8.12 最长回文子序列

给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000。

示例 1: 输入: "bbbab"         输出: 4         一个可能的最长回文子序列为 "bbbb"。

本题和上一题略有不同：回文子串是要连续的，回文子序列可不是连续的！

1、确定dp数组（dp table）以及下标的含义

dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。

2、确定递推公式

3、dp数组如何初始化

首先要考虑当i 和j 相同的情况，从递推公式：dp[i][j] = dp[i + 1][j - 1] + 2; 可以看出 递推公式是计算不到 i 和j相同时候的情况。所以需要手动初始化一下，当i与j相同，那么dp[i][j]一定是等于1的，即：一个字符的回文子序列长度就是1。其他情况dp[i][j]初始为0就行，这样递推公式：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]); 中dp[i][j]才不会被初始值覆盖。

4、确定遍历顺序

遍历i的时候一定要从下到上遍历，这样才能保证，下一行的数据是经过计算的

5、举例推导dp数组

public class Solution {public int longestPalindromeSubseq(String s) {int len = s.length();int[][] dp = new int[len + 1][len + 1];for (int i = len - 1; i >= 0; i--) { // 从后往前遍历 保证情况不漏dp[i][i] = 1; // 初始化for (int j = i + 1; j < len; j++) {if (s.charAt(i) == s.charAt(j)) {dp[i][j] = dp[i + 1][j - 1] + 2;} else {dp[i][j] = Math.max(dp[i + 1][j], Math.max(dp[i][j], dp[i][j - 1]));}}}return dp[0][len - 1];}
}

10 单调栈

10.1 每日温度

请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

单调栈用的时机：通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。

单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素的元素，优点是只需要遍历一次。

1、单调栈里存放的元素是什么？

单调栈里只需要存放元素的下标 i 就可以了，如果需要使用对应的元素，直接T[i]就可以获取。

2、单调栈里元素是递增呢？ 还是递减呢？

注意一下顺序为 从栈头到栈底的顺序，

这里我们要使用递增循序（再强调一下是指从栈头到栈底的顺序），因为只有递增的时候，加入一个元素i，才知道栈顶元素在数组中右面第一个比栈顶元素大的元素是i。

temperatures = [73, 74, 75, 71, 71, 72, 76, 73]为例来逐步分析，输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

 public static int[] dailyTemperatures(int[] temperatures) {Stack<Integer> stack = new Stack<>();int[] res = new int[temperatures.length];for (int i = 0; i < temperatures.length; i++) {/*** 取出下标进行元素值的比较*/while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {int preIndex = stack.pop();res[preIndex] = i - preIndex;}/*** 注意 放入的是元素位置*/stack.push(i);}return res;}

10.2 下一个更大元素 I

给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].        输出: [-1,3,-1]

class Solution {public int[] nextGreaterElement(int[] nums1, int[] nums2) {Stack<Integer> temp = new Stack<>();int[] res = new int[nums1.length];Arrays.fill(res,-1);HashMap<Integer, Integer> hashMap = new HashMap<>();for (int i = 0 ; i< nums1.length ; i++){hashMap.put(nums1[i],i);}temp.add(0);for (int i = 1; i < nums2.length; i++) {if (nums2[i] <= nums2[temp.peek()]) {temp.add(i);} else {while (!temp.isEmpty() && nums2[temp.peek()] < nums2[i]) {if (hashMap.containsKey(nums2[temp.peek()])){Integer index = hashMap.get(nums2[temp.peek()]);res[index] = nums2[i];}temp.pop();}temp.add(i);}}return res;}
}

10.3 下一个更大元素II

给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。

相信不少同学看到这道题，就想那我直接把两个数组拼接在一起，然后使用单调栈求下一个最大值不就行了！确实可以！将两个nums数组拼接在一起，使用单调栈计算出每一个元素的下一个最大值，最后再把结果集即result数组resize到原数组大小就可以了。这种写法确实比较直观，但做了很多无用操作，例如修改了nums数组，而且最后还要把result数组resize回去。

其实也可以不扩充nums，而是在遍历的过程中模拟走了两边nums。

class Solution {public int[] nextGreaterElements(int[] nums) {//边界判断if(nums == null || nums.length <= 1) {return new int[]{-1};}int size = nums.length;int[] result = new int[size];//存放结果Arrays.fill(result,-1);//默认全部初始化为-1Stack<Integer> st= new Stack<>();//栈中存放的是nums中的元素下标for(int i = 0; i < 2*size; i++) {while(!st.empty() && nums[i % size] > nums[st.peek()]) {result[st.peek()] = nums[i % size];//更新resultst.pop();//弹出栈顶}st.push(i % size);}return result;}
}

10.4  接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

• 输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
• 输出：6

本文深度讲解如下三种方法：

• 双指针法
• 动态规划
• 单调栈

 10.4.1 双指针法

双指针发要考虑是按照行来计算还是按照列来计算。

接下来看一下按照列如何计算：如果按照列来计算的话，宽度一定是1了，我们再把每一列的雨水的高度求出来就可以了。可以看出每一列雨水的高度，取决于，该列 左侧最高的柱子和右侧最高的柱子中最矮的那个柱子的高度。

那么列4的雨水高度为 列3和列7的高度最小值减列4高度，即： min(lHeight, rHeight) - height。

要注意第一个柱子和最后一个柱子不接雨水。

class Solution {public int trap(int[] height) {int sum = 0;for (int i = 0; i < height.length; i++) {// 第一个柱子和最后一个柱子不接雨水if (i==0 || i== height.length - 1) continue;int rHeight = height[i]; // 记录右边柱子的最高高度int lHeight = height[i]; // 记录左边柱子的最高高度for (int r = i+1; r < height.length; r++) {if (height[r] > rHeight) rHeight = height[r];}for (int l = i-1; l >= 0; l--) {if(height[l] > lHeight) lHeight = height[l];}int h = Math.min(lHeight, rHeight) - height[i];if (h > 0) sum += h;}return sum;}
}

10.4.2 动态规划解法

在上一节的双指针解法中，可以得到当前列雨水面积：min(左边柱子的最高高度，记录右边柱子的最高高度) - 当前柱子高度。

动态规划公式：

即从左向右遍历：maxLeft[i] = max(height[i], maxLeft[i - 1]);

从右向左遍历：maxRight[i] = max(height[i], maxRight[i + 1]);

class Solution {public int trap(int[] height) {int length = height.length;if (length <= 2) return 0;int[] maxLeft = new int[length];int[] maxRight = new int[length];// 记录每个柱子左边柱子最大高度maxLeft[0] = height[0];for (int i = 1; i< length; i++) maxLeft[i] = Math.max(height[i], maxLeft[i-1]);// 记录每个柱子右边柱子最大高度maxRight[length - 1] = height[length - 1];for(int i = length - 2; i >= 0; i--) maxRight[i] = Math.max(height[i], maxRight[i+1]);// 求和int sum = 0;for (int i = 0; i < length; i++) {int count = Math.min(maxLeft[i], maxRight[i]) - height[i];if (count > 0) sum += count;}return sum;}
}

10.4.3 单调栈解法

单调栈是按照行方向来计算雨水，如图：

从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。

因为一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。

遇到相同的元素，更新栈内下标，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。

是用单调栈，其实是通过 长 * 宽 来计算雨水面积的。

长就是通过柱子的高度来计算，宽是通过柱子之间的下标来计算，

class Solution {public int trap(int[] height){int size = height.length;if (size <= 2) return 0;// in the stack, we push the index of array// using height[] to access the real heightStack<Integer> stack = new Stack<Integer>();stack.push(0);int sum = 0;for (int index = 1; index < size; index++){int stackTop = stack.peek();if (height[index] < height[stackTop]){stack.push(index);}else if (height[index] == height[stackTop]){// 因为相等的相邻墙，左边一个是不可能存放雨水的，所以pop左边的index, push当前的indexstack.pop();stack.push(index);}else{//pop up all lower valueint heightAtIdx = height[index];while (!stack.isEmpty() && (heightAtIdx > height[stackTop])){int mid = stack.pop();if (!stack.isEmpty()){int left = stack.peek();int h = Math.min(height[left], height[index]) - height[mid];int w = index - left - 1;int hold = h * w;if (hold > 0) sum += hold;stackTop = stack.peek();}}stack.push(index);}}return sum;}
}

10.5 柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

双指针解法

class Solution {public int largestRectangleArea(int[] heights) {int largestRectangleArea(vector<int>& heights) {int sum = 0;for (int i = 0; i < heights.size(); i++) {int left = i;int right = i;for (; left >= 0; left--) {if (heights[left] < heights[i]) break;}for (; right < heights.size(); right++) {if (heights[right] < heights[i]) break;}int w = right - left - 1;int h = heights[i];sum = max(sum, w * h);}return sum;}
}

动态规划

class Solution {public int largestRectangleArea(int[] heights) {int length = heights.length;int[] minLeftIndex = new int [length];int[] maxRigthIndex = new int [length];// 记录左边第一个小于该柱子的下标minLeftIndex[0] = -1 ;for (int i = 1; i < length; i++) {int t = i - 1;// 这里不是用if，而是不断向右寻找的过程while (t >= 0 && heights[t] >= heights[i]) t = minLeftIndex[t];minLeftIndex[i] = t;}// 记录每个柱子 右边第一个小于该柱子的下标maxRigthIndex[length - 1] = length;for (int i = length - 2; i >= 0; i--) {int t = i + 1;while(t < length && heights[t] >= heights[i]) t = maxRigthIndex[t];maxRigthIndex[i] = t;}// 求和int result = 0;for (int i = 0; i < length; i++) {int sum = heights[i] * (maxRigthIndex[i] - minLeftIndex[i] - 1);result = Math.max(sum, result);}return result;}
}

单调栈

class Solution {int largestRectangleArea(int[] heights) {Stack<Integer> st = new Stack<Integer>();// 数组扩容，在头和尾各加入一个元素int [] newHeights = new int[heights.length + 2];newHeights[0] = 0;newHeights[newHeights.length - 1] = 0;for (int index = 0; index < heights.length; index++){newHeights[index + 1] = heights[index];}heights = newHeights;st.push(0);int result = 0;// 第一个元素已经入栈，从下标1开始for (int i = 1; i < heights.length; i++) {// 注意heights[i] 是和heights[st.top()] 比较 ，st.top()是下标if (heights[i] > heights[st.peek()]) {st.push(i);} else if (heights[i] == heights[st.peek()]) {st.pop(); // 这个可以加，可以不加，效果一样，思路不同st.push(i);} else {while (heights[i] < heights[st.peek()]) { // 注意是whileint mid = st.peek();st.pop();int left = st.peek();int right = i;int w = right - left - 1;int h = heights[mid];result = Math.max(result, w * h);}st.push(i);}}return result;}
}

本文完全借鉴于：代码随想录

Leetcode刷题笔记（代码随想录）相关推荐

1. LeetCode刷题笔记2——数组2

   LeetCode刷题笔记2--数组2 重塑数组 题目 在 MATLAB 中,有一个非常有用的函数 reshape ,它可以将一个 m x n 矩阵重塑为另一个大小不同(r x c)的新矩阵,但保留其原 ...

2. LeetCode刷题笔记-动态规划-day4

   文章目录 LeetCode刷题笔记-动态规划-day4 55. 跳跃游戏 1.题目 2.解题思路 3.代码 45. 跳跃游戏 II 1.题目 2.解题思路 3.代码 LeetCode刷题笔记-动态规划 ...

3. LeetCode刷题笔记- 15.三数之和

   LeetCode刷题笔记- 15.三数之和 C语言 题目 注意点 C语言 /*** Return an array of arrays of size *returnSize.* The sizes ...

4. LeetCode刷题笔记第6题：Z字形变换

   LeetCode刷题笔记第6题:Z字形变换 想法: 要完成字符串根据给定的行数从上往下,从左到右完成Z字形排列.当只有一行时直接返回原字符串,当行数大于1时,先以行数构建一个行数数值个空字符串的列表, ...

5. leetcode刷题笔记——二分查找

   leetcode刷题笔记--二分查找 目前完成的贪心相关的leetcode算法题序号: 中等:80,81 困难:4 来源:力扣(LeetCode) 链接:https://leetcode-cn.com ...

6. LeetCode刷题笔记（算法思想 四）

   LeetCode刷题笔记(算法思想 四) 七.动态规划 斐波那契数列 70. 爬楼梯 198. 打家劫舍 213. 打家劫舍 II 信件错排 母牛生产 矩阵路径 64. 最小路径和 62. 不同路径 ...

7. 卷进大厂系列之LeetCode刷题笔记：二分查找（简单）

   LeetCode刷题笔记:二分查找(简单) 学算法,刷力扣,加油卷,进大厂! 题目描述 涉及算法 题目解答 学算法,刷力扣,加油卷,进大厂! 题目描述 力扣题目链接 给定一个 n 个元素有序的(升序) ...

8. 小何同学的leetcode刷题笔记 基础篇（01）整数反转

   小何同学的leetcode刷题笔记 基础篇(01)整数反转[07] *** [01]数学取余法*** 对数字进行数位操作时,常见的方法便是用取余的方法提取出各位数字,再进行操作 操作(1):对10取余 ...

9. LeetCode刷题笔记汇总

   LeetCode刷题笔记汇总 第一次刷LeetCode写的一些笔记. 1.两数之和 3.无重复字符的最长子串 15.三数之和 18.四数之和 19.删除链表的倒数第 N 个结点 20.有效的括号 21 ...

10. 【leetcode刷题笔记】动态规划

    #[leetcode刷题笔记]动态规划 石子游戏 public boolean stoneGame(int[] piles) {int N = piles.length;// dp[i][j] is ...

最新文章

1. power计算机英语,十万火急求解计算机英语!AC power lineAND gateAND-OR circuitXOR gateunrel...
2. boost::fibers::algo::shared_work ＞用法的测试程序
3. configure 查找依赖库_Rust在编译Android的库时，如何设定依赖的第三方库引用的C/C++的动态库的搜索路径？...
4. [渝粤教育] 西南科技大学 基础工业工程 在线考试复习资料
5. C#经典系列-键值对
6. linux获取文件名最后一位,获取出文件最后一位是1 或者0 若果都是1 代表是正确的 如果有0代表错误...
7. LongAdder，AtomicIntegerFieldUpdater深入研究
8. WARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None))
9. frame越过另一个frame_Python3.6实现一个简单的文本编辑器
10. 如何在 Linux 终端中知道你的公有 IP
11. 大一c语言常见编程题,自己整理的C语言常见编程题
12. linux系统分区磁盘,Linux 操作系统手动磁盘分区详细说明
13. 常数1的傅里叶变换详解过程
14. 携程商旅酒店直连平台的实践（一）
15. 在电脑上下载 Youtube 的视频
16. [代码审计]Weiphp5.0 前台文件任意读取分析
17. Spring3 MVC详解二
18. 关于编译型语言函数的调用(一)
19. 图像处理入门100题（三）
20. 讲台计算机的英语怎么读,讲台英语怎么读

热门文章

1. 8.jQuery例子——增删改查
2. oracle中负数的四舍五入,oracle中round()四舍五入
3. python-列表_字典_集合的相关函数_深拷贝和浅拷贝
4. win10系统 软件图标 移动到开始磁贴上方法
5. USACO vans
6. web网页设计期末课程大作业：美食餐饮文化主题网站设计——HTML+CSS+JavaScript美食餐厅网站设计与实现 11页面
7. 15.transformer全解
8. Android海外应用和安卓源码的多国语言翻译
9. 一个很不错的四格小漫画 - 世界人民的愿望
10. Redis笔记（狂神说）