截至2020/08/20
文章的主题还是分为学习算法和学习Java两个部分。由于一些题目都是老题,因此主要学习思路和Java写法。
336.回文对 H
这道题目是比较难的,官方题解也给的比较清楚,这里我们辅助注释理解就可以。
Java方法:
map.getOrDefault(a, -1);
,在字典中查找a,如果找到返回值,否则返回-1;String s = new StringBuffer(words[i]).reverse().toString();
得到一个字符串,这里采用了SrtingBuffer类的toString方法
class Solution {
Map<String, Integer> indices = new HashMap<String, Integer>();
public List palindromePairs(String[] words) {
int n = words.length;
for (int i = 0; i < n; ++i) {
String s = new StringBuffer(words[i]).reverse().toString();
indices.put(s, i);
}
List<int[]> ret = new ArrayList<>();
//List<List<Integer>> ret = new ArrayList<List<Integer>>();
for (int i = 0; i < n; i++) {
String word = words[i];
int m = words[i].length();
for (int j = 0; j <= m; j++) {
// 回文对的拼接,右半段自身是,左半对的反转在字典中存在
这里需要注意细节!!!考虑空字符串,j = m的情况
if (isPalindrome(word, j, m - 1)) {
int leftId = findWord(word, 0, j);
// 返回-1表示不存在,并且不能相同
if (leftId != -1 && leftId != i) {
ret.add(new int[]{i, leftId});
}
}
// 左边段自身是,右半段的反转存在
if (j != 0 && isPalindrome(word, 0, j - 1)) {
int rightId = findWord(word, j, m);
if (rightId != -1 && rightId != i) {
ret.add(new int[]{rightId, i});
}
}
}
}
return ret;
}
public boolean isPalindrome(String s, int left, int right) {
int len = right - left + 1;
for (int i = 0; i < len / 2; i++) {
if (s.charAt(left + i) != s.charAt(right - i)) {
return false;
}
}
return true;
}
public int findWord(String s, int left, int right) {
return indices.getOrDefault(s.substring(left, right), -1);
}
}
99.恢复二叉搜索树 H
关键在于找到核心的思路,我们首先对树进行遍历,中序遍历,如果是二叉搜索树,可以保证数组最后是单调递增的。但是由于存在交换,因此我们可以想到,存在两个特殊的点。第一个A点应该是大于后一个点,第二个点自然是大于A的前一个数字。特别考虑清楚边界的情况,如B点位于结尾。
然后我们得到两个点的位置之后,只需要再遍历树进行替换。注意这里的替换还是很有意思的。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int count = 0;
public void recoverTree(TreeNode root) {
List<Integer> nums = new ArrayList<Integer>();
inorder(root, nums);
int[] err = finderr(nums);
recover(err[0],err[1],root);
}
public void inorder(TreeNode root,List<Integer> nums){
if (root != null){
inorder(root.left, nums);
nums.add(root.val);
inorder(root.right, nums);
}
return;
}
public int[] finderr(List<Integer> nums){
int n = nums.size();
int x = 0, y = nums.get(n-1);
int flag = 0;
for(int i = 1; i < n; i++){
if (flag == 0 && nums.get(i-1)>nums.get(i)){
flag ++;
x = nums.get(i-1);
}
else if(flag == 1 && nums.get(i)>x){
flag ++;
y = nums.get(i-1);
}
}
return new int[]{x,y};
}
public void recover(int err1, int err2, TreeNode root){
if (root == null) return;
if (count<2 && (root.val == err1 || root.val == err2)){
root.val = root.val == err1?err2:err1;
count++;
}
if (count == 2) return;
recover(err1, err2, root.left);
recover(err1, err2, root.right);
}
}
133.克隆图
题目其实很简单,但是这里重点考察了深拷贝的问题。
/*
// Definition for a Node.
class Node {
public int val;
public List<Node> neighbors;
public Node() {
val = 0;
neighbors = new ArrayList<Node>();
}
public Node(int _val) {
val = _val;
neighbors = new ArrayList<Node>();
}
public Node(int _val, ArrayList<Node> _neighbors) {
val = _val;
neighbors = _neighbors;
}
}
*/
class Solution {
public Node cloneGraph(Node node) {
if (node == null) return node;
Queue<Node> queue = new LinkedList<>();
HashMap<Node, Node> dic = new HashMap();
queue.offer(node);
// 这里考虑清楚,我们是要克隆一个新的,因此首先克隆第一个
dic.put(node, new Node(node.val, new ArrayList<Node>()));
while(!queue.isEmpty()){
Node n = queue.poll();
for (Node neighbor:n.neighbors){
if (!dic.containsKey(neighbor)){
dic.put(neighbor, new Node(neighbor.val, new ArrayList<Node>()));
queue.offer(neighbor);
}
// 更新所有的克隆节点的邻居
dic.get(n).neighbors.add(dic.get(neighbor));
}
}
return dic.get(node);
}
}
546.移出盒子 H
这道题第一眼感觉就是类似扎气球,但是仔细分析还不太一样。虽然基本思想还是区间dp但是这次的dp设置真是不太一样。这里我们采用了记忆化的搜索方法。
我们考虑某个区间[6,2,6,3,6,7,8,6,6],考虑区间[6,2,6,3,6]和后面的区间,这个区间的坐标是[l, r]
但是还可以和后面的两个6组合成为更大的消除方法。因此定义dp[i][j][k]
,表示区间左端点i,右端点j,连同区间外的k个点,其中这k个点的数值等于nums[j]。这样可以变为dp[l][r][k] = dp[i][j-1][0]+(k+1)*(k+1)
。
由于区间中还存在其他等于6的点,因此还可以dp[l][i][k+1]+dp[i+1][r][0]
其中k+1是因为,把最后一个也就是num[r]
这个位置的数字也考虑了,之后的空间就无法考虑了只能是dp[i+1][r][0]
。
核心在于记忆化搜索其实更直观,只要考虑清楚最后一个状态可能如何转换得到就可以。
class Solution {
public int removeBoxes(int[] boxes) {
int[][][] dp = new int[100][100][100];
return calculatePoints(boxes, dp, 0, boxes.length - 1, 0);
}
public int calculatePoints(int[] boxes, int[][][] dp, int l, int r, int k) {
if (l > r) return 0;
if (dp[l][r][k] != 0) return dp[l][r][k];
while (r > l && boxes[r] == boxes[r - 1]) {
r--;
k++;
}
dp[l][r][k] = calculatePoints(boxes, dp, l, r - 1, 0) + (k + 1) * (k + 1);
for (int i = l; i < r; i++) {
if (boxes[i] == boxes[r]) {
dp[l][r][k] = Math.max(dp[l][r][k], calculatePoints(boxes, dp, l, i, k + 1) + calculatePoints(boxes, dp, i + 1, r - 1, 0));
}
}
return dp[l][r][k];
}
}