5472. 重新排列字符串
知识点：模拟
先创建一个等长的字符串，然后按顺序对其更新即可。
class Solution {
public:
string restoreString(string s, vector<int>& indices) {
string str = s;
for(int i = 0; i < s.size(); i++) {
str[indices[i]] = s[i];
}
return str;
}
};
5473. 灯泡开关 IV
知识点：思维题
首先找到第一个和目标状态不一样的灯泡，然后改变其和其后所有灯泡的状态。然后重复前述步骤，直到所有灯泡都到达目标状态。
接下来用我拙劣的语言来说明一下该算法是收敛的：
虽然每次操作可能会让后面的灯泡不符合目标状态，但是可以保证当前被选中的灯泡变成目标状态的且不会反复。所以可以保证最终所有灯泡都会变成合法的。
再用我拙劣的的语言来说明下这样做是最优的：
设第一个不合法的灯泡的下标为 i，那么必须对 i 进行操作。原因如下：
- 原因一：对 j (j>i)进行操作，不会影响 i。
- 原因二：对 j (j < i) 进行操作，会使得 j 变为不合法，那就意味着要对 j 操作两次。但对 j 操作两次意味着 i 的状态不会改变。
综上，必须要操作 i。当对 i 操作之后，要么全都达到了目标状态，要么产生了一个新的 i。也就是说对于每一种初始状态，其中要被操作的那些灯泡(姑且称之为关键灯泡)就已经被确定了。无论你按什么样的次序操作，这些关键灯泡都是要操作的，而对其他灯泡的操作都是冗余的(如原因二所述)，所以这样操作是最优的。
class Solution {
public:
int minFlips(string target) {
int anw = 0;
bool status = false;
for(int i = 0; i < target.size(); i++) {
if(target[i] == '0') {
if(status == false) {
continue;
} else {
anw ++;
status = false;
}
} else {
if(status == true) {
continue;
} else {
anw ++;
status = true;
}
}
}
return anw;
}
};
5474. 好叶子节点对的数量
知识点：深度优先遍历
先来说个前提：二叉树中，两个节点的最近路径是唯一的，且必然会经过两个节点的最近公共祖先。
最近公共祖先(LCA)：设有节点F，A，B，如果F即是A的祖先，又是B的祖先，那么F是A，B的公共祖先。在所有符合上述要求的F中，深度最大的那个即为A，B的最近公共祖先。
设以节点 F 为LCA的好叶子节点对为 C(F)。那么最终的答案即为所有C(F)的累加和。那如何求解C(F)呢？
首先分别左右子树中到F的距离为 x(1 <= x <= distance) 的叶子节点的数量。
然后将枚举距离将左右子树的叶子节点配对，统计其中符合距离要求的点对即可。
拙劣的 证明：
因为每对叶子节点的LCA是唯一的，且LCA必定存在，所以通过LCA来区分点对既不会重复也不会漏掉。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
// cntDict::key 是节点的内存地址，用作一个节点的id。
// cntDict::value 也是一个 map, 其 value 为到 cntDict::key 距离为 key 的数量。
map<ptrdiff_t, map<int, int>> cntDict;
int dfs(TreeNode *root, int distance) {
if(root == nullptr) {
return 0;
}
int anw = 0;
anw += dfs(root->left, distance); // 累加右子树中点对的数量
anw += dfs(root->right, distance); // 累加左子树中点对的数量
//左右节点都存在，那么必有以 root 为LCA 的点对，统计其中符合要求的叶子点对数量。
if(root->left != nullptr && root->right != nullptr) {
const map<int, int> &left = cntDict[ptrdiff_t(root->left)];
const map<int, int> &right = cntDict[ptrdiff_t(root->right)];
for(int i = 0; i < distance; i++) {
auto lit = left.find(i);
if(lit == left.end()) { continue; }
for(int j = 0; j < distance; j++) {
if(i+j+2 > distance) {
continue;
}
auto rit = right.find(j);
if(rit == right.end()) {
continue;
}
anw += lit->second * rit->second;
}
}
}
map<int, int> cnt;
if(root->left != nullptr) {
const map<int, int> &left = cntDict[ptrdiff_t(root->left)];
for(auto it = left.begin(); it != left.end(); ++it) {
if(it->first + 1 >= distance) { continue; }
cnt[it->first+1] += it->second;
}
}
if(root->right != nullptr) {
const map<int, int> &left = cntDict[ptrdiff_t(root->right)];
for(auto it = left.begin(); it != left.end(); ++it) {
if(it->first + 1 >= distance) { continue; }
cnt[it->first+1] += it->second;
}
}
if(root->left == nullptr && root->right == nullptr) {
cnt[0] = 1;
}
cntDict.insert(make_pair(ptrdiff_t(root), cnt));
return anw;
}
int countPairs(TreeNode* root, int distance) {
return dfs(root, distance);
}
};
5462. 压缩字符串 II
知识点：动态规划
这个题写的相当挫。。
既然是动态规划，那么先来确定状态：
设 s 的长度为n，下标从 1 开始。
f(i,j,d) 为以 s[i] 结尾，且末尾有 j 个连续的 s[i]，且删了 d 个字符的最小长度。
当我们向 s 末尾追加一个 s 中不存在的字符(比如 #)，那么答案就是 f(n+1, 1, k) - 1。减一是为了移除追加的特殊字符。
状态确定了，再来看如何转移：
先把状态摆在这里：
- i: s[i]为最后一个字符
- j：末尾是 j 个连续的 s[i]。
- d: 总共删除了 d 个字符。
当 s[i] 为最后一个字符时，意味了其后的所有字符都被删除了，设其后字符数量为 deleted。
然后枚举s[i]之前删除字符的数量为 part，part 和 deleted 满足 0 <= part 且 part + deleted <= k。
这样就得到了可以转移到f(i,j,k)的状态 f(i-part-1, con, k - part-deleted)。con 需满足 0 <= con 且 con <= i-part-1。
然后通过讨论 s[i] 和 s[i-part-1] 是否相同，可得到从 f(i-part-1, con, k-part-deleted) 转移到 f(i,j,d)的计算公式。
class Solution {
public:
int dp[102][101][101];
int get(int con) {
// con == 1, 说明要从 x 变为 x2
// con == 9, 说明要从 x9 变为 x10
// con == 9, 说明要从 x99 变为 x100
return (con == 1 || con == 9 || con == 99) ? 1 : 0;
}
int getLengthOfOptimalCompression(string s, int k) {
if(k >= s.size()) {
return 0;
}
s += "#";
memset(dp, 0x7f, sizeof(dp));
dp[0][0][0] = 0;
// 枚举最后一个字符的下标。
for(int now = 1; now <= s.size(); now++) {
// 枚举 now 之前保留的最后一个字符 pre。
for(int pre = now-1; pre >= 0; pre--) {
if(now-pre-1 > k) {
break;
}
// 枚举 pre 之前删除了 deleted 个字符。
for(int deleted = 0; deleted <= k; deleted++) {
int allDeleted = deleted + now-pre-1;
if(allDeleted > k) {
break;
}
// 枚举连续的 s[pre] 的个数
for(int con = 0; con <= pre; con++) {
if(dp[pre][con][deleted] > 100) {
// 大于 100 说明该状态不可达。
continue;
}
// 转移
if(pre != 0 && s[pre-1] == s[now-1]) {
dp[now][con+1][allDeleted] = min(dp[now][con+1][allDeleted], dp[pre][con][deleted] + get(con));
} else {
dp[now][1][allDeleted] = min(dp[now][1][allDeleted], dp[pre][con][deleted] + 1);
}
}
}
}
}
return dp[s.size()][1][k] - 1;
}
};
