思路:额外开一个字符数组存储以及完成题目要求的移动即可。
class Solution {
public String restoreString(String s, int[] indices) {
int n = s.length();
char[] c = s.toCharArray();
for (int i = 0; i < n; i++)
c[indices[i]] = s.charAt(i);
return new String(c);
}
}
思路:一定是从左到右翻转的,若当前灯是开着的,判断它之前翻转了几次,若是偶数次,则当前仍需要执行翻转操作,对于关着的灯也是一样的。
class Solution {
public int minFlips(String target) {
int num = 0;
int len = target.length();
for (int i = 0; i < len; i++) {
if (target.charAt(i) == '1' && num % 2 == 0)
num++;
if (target.charAt(i) == '0' && num % 2 != 0)
num++;
}
return num;
}
}
思路:最多只有1024个节点,对于每个节点,我们暴力其左右子树中能够凑出多少个好节点对即可。
class Solution {
private int ans;
private List<Integer> list1;
private List<Integer> list2;
public int countPairs(TreeNode root, int distance) {
list1=new ArrayList<>();
list2=new ArrayList<>();
dfs(root, distance);
return ans;
}
private void dfs(TreeNode root, int dis) {
if (root == null) return;
dfs(root.left,dis);
dfs(root.right,dis);
list1.clear();
list2.clear();
list1 = dfs_node(root.left, 1);
list2 = dfs_node(root.right, 1);
Collections.sort(list1);
Collections.sort(list2);
int size1 = list1.size();
int size2 = list2.size();
for (int i = 0; i < size1; i++) {
int l = 0, r = size2 - 1, p = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (list2.get(mid) + list1.get(i) <= dis) {
p = mid;
l = mid + 1;
} else
r = mid - 1;
}
ans += p + 1;
}
}
private List<Integer> dfs_node(TreeNode root, int depth) {
if (root == null)
return new ArrayList<>();
List<Integer> list = new ArrayList<>();
if (root.left == null && root.right == null)
list.add(depth);
else {
list.addAll(dfs_node(root.left, depth + 1));
list.addAll(dfs_node(root.right, depth + 1));
}
return list;
}
}
思路:动态规划,我们定义dp[i][j]表示前i个字符已经执行了j次删除操作的最小行程长度编码长度。
class Solution {
public int getLengthOfOptimalCompression(String s, int k) {
int n = s.length();
int[][] dp = new int[n + 1][k + 2];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++)
dp[i][j] = 1000000;
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= k; j++) {
dp[i][j + 1] = Math.min(dp[i][j + 1], dp[i - 1][j]);
int cnt = 0, del = 0;
for (int h = i; h <= n; h++) {
if (s.charAt(h - 1) == s.charAt(i - 1)) cnt++;
else del++;
if (j + del <= k)
dp[h][j + del] = Math.min(dp[h][j + del], dp[i - 1][j] + (cnt >= 100 ? 4 : cnt >= 10 ? 3 : cnt >= 2 ? 2 : 1));
}
}
return dp[n][k];
}
}