动态规划解决，比较当前位置目标和实际字符串的字母，再根据不同情况计算接下来的情形。

class Solution {public int longestCommonSubsequence(String text1, String text2) {char[] t1 = text1.toCharArray();char[] t2 = text2.toCharArray();int m = t1.length;int n = t2.length;int[][] dp = new int[m + 1][n + 1];for (int i = 0; i < m; i++) {for (int j = 0; j < n; j++) {dp[i + 1][j + 1] = t1[i] == t2[j] ? dp[i][j] + 1 : Math.max(dp[i][j + 1], dp[i + 1][j]);}}return dp[m][n];}
}

有可能删除头节点，所以要用到虚拟头节点。
循环的过程中，将当前所指节点的下个节点的值取出作为标准，做到删除过程不重不漏。

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode() {}*     ListNode(int val) { this.val = val; }*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }* }*/
class Solution {public ListNode deleteDuplicates(ListNode head) {ListNode dummy = new ListNode(0, head);ListNode cur = dummy;while (cur.next != null && cur.next.next != null) {int val = cur.next.val;if (cur.next.next.val == val) {while (cur.next != null && cur.next.val == val) {cur.next = cur.next.next;}} else {cur = cur.next;}}return dummy.next;}
}

这题困难的地方在于，需要将时间复杂度优化到 $O(log(m+n))$，必须用二分来解决。
目前先实现时间复杂度为 $O(m+n)$ 的方法，后续再完善。

class Solution {public double findMedianSortedArrays(int[] nums1, int[] nums2) {if (nums1.length > nums2.length) {int[] temp = nums1;nums1 = nums2;nums2 = temp;}int m = nums1.length;int n = nums2.length;int[] group1 = new int[m + 2];int[] group2 = new int[n + 2];group1[0] = group2[0] = Integer.MIN_VALUE;group1[m + 1] = group2[n + 1] = Integer.MAX_VALUE;System.arraycopy(nums1, 0, group1, 1, m);System.arraycopy(nums2, 0, group2, 1, n);int i = 0;int j = (m + n + 1) / 2;while (true) {if (group1[i] <= group2[j + 1] && group1[i + 1] > group2[j]) {int max = Math.max(group1[i], group2[j]);int min = Math.min(group1[i + 1], group2[j + 1]);return (m + n) % 2 == 1 ? max : (max + min) / 2.0;}i++;j--;}}
}

先序遍历的变种，优先遍历右子树并维护深度，在结果中元素数量小于深度时，向其中添加新元素。

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public List<Integer> rightSideView(TreeNode root) {List<Integer> res = new ArrayList<>();dfs(root, res, 0);return res;}private void dfs(TreeNode node, List<Integer> res, int depth) {if (node == null) {return;}if (res.size() == depth) {res.add(node.val);}dfs(node.right, res, depth + 1);dfs(node.left, res, depth + 1);}
}

模板题，理解的基础上直接记。

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public List<Integer> inorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();dfs(root, res);return res;}private void dfs(TreeNode node, List<Integer> res) {if (node == null) {return;}dfs(node.left, res);res.add(node.val);dfs(node.right, res);}
}