力扣OJ（0601-800）
目录
605. 种花问题
611. 有效三角形的个数
617. 合并二叉树
621. 任务调度器
624. 数组列表中的最大距离
625. 最小因式分解
628. 三个数的最大乘积
629. K 个逆序对数组
630. 课程表 III
634. 寻找数组的错位排列
643. 子数组最大平均数 I
644. 子数组最大平均数 II
646. 最长数对链
647. 回文子串
660. 移除 9
664. 奇怪的打印机
672. 灯泡开关 Ⅱ
673. 最长递增子序列的个数
679. 24 点游戏
680. 验证回文字符串 Ⅱ
683. K 个关闭的灯泡
684. 冗余连接
685. 冗余连接 II
686. 重复叠加字符串匹配
690. 员工的重要性
693. 交替位二进制数
695. 岛屿的最大面积
697. 数组的度
698. 划分为k个相等的子集
704. 二分查找
708. 循环有序列表的插入
713. 乘积小于K的子数组
714. 买卖股票的最佳时机含手续费
716. 最大栈
720. 词典中最长的单词
724. 寻找数组的中心下标
733. 图像渲染
738. 单调递增的数字
740. 删除与获得点数
742. 二叉树最近的叶节点
743. 网络延迟时间
746. 使用最小花费爬楼梯
752. 打开转盘锁
753. 破解保险箱
754. 到达终点数字
756. 金字塔转换矩阵
762. 二进制表示中质数个计算置位
764. 最大加号标志
767. 重构字符串
769. 最多能完成排序的块
771. 宝石与石头
774. 最小化去加油站的最大距离
776. 拆分二叉搜索树
778. 水位上升的泳池中游泳
785. 判断二分图
787. K 站中转内最便宜的航班
790. 多米诺和托米诺平铺
791. 自定义字符串排序
793. 阶乘函数后 K 个零
795. 区间子数组个数
797. 所有可能的路径
800. 相似 RGB 颜色
605. 种花问题
假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false 。
示例 1：
输入：flowerbed = [1,0,0,0,1], n = 1 输出：true
示例 2：
输入：flowerbed = [1,0,0,0,1], n = 2 输出：false
提示：
1 <= flowerbed.length <= 2 * 104flowerbed[i]为0或1flowerbed中不存在相邻的两朵花0 <= n <= flowerbed.length
class Solution {
public:
bool canPlaceFlowers(vector& v, int n) {
int a=-2,ans=0;
for(int i=0;i3)ans+=(i-a)/2-1;
a=i;
}
}
ans+=(v.size()-1-a)/2;
return ans>=n;
}
}; 611. 有效三角形的个数
给定一个包含非负整数的数组 nums ，返回其中可以组成三角形三条边的三元组个数。
示例 1:
输入: nums = [2,2,3,4] 输出: 3 解释:有效的组合是: 2,3,4 (使用第一个 2) 2,3,4 (使用第二个 2) 2,2,3
示例 2:
输入: nums = [4,2,3,4] 输出: 4
提示:
1 <= nums.length <= 10000 <= nums[i] <= 1000
template
class Bsearch //寻找[low,high]中最小的满足isOk条件的数，low<=high,返回值范围是[low,high+getGap()]
{
public:
T find(T low, T high)
{
if (!isOk(high))return high + getGap(high);
if (isOk(low))return low;
T mid;
while (high - low > getGap(low)) {
mid = (high + low) / 2;
if (isOk(mid))high = mid;
else low = mid;
}
return high;
}
private:
virtual bool isOk(T x) const //若isOk(x)且!isOk(y)则必有y 0;
}
int getGap(int) {
return 1;
}
int getGap(long long) {
return 1;
}
double getGap(double) {
return 0.00000001;
}
};
class Solution:public Bsearch {
public:
int triangleNumber(vector& nums) {
sort(nums.begin(), nums.end());
this->nums = nums;
int ans = 0;
for (int i = 0; i < nums.size(); i++)for (int j = i + 1; j < nums.size(); j++) {
if (nums[i] <= 0 || nums[j] <= 0)continue;
s = nums[i] + nums[j];
int id = find(j, nums.size() - 1);
ans += id - j - 1;
}
return ans;
}
bool isOk(int x) const
{
return nums[x] >= s;
}
vector nums;
int s;
}; 617. 合并二叉树
rust
621. 任务调度器
贪心 贪心（2）活动安排问题_nameofcsdn的博客-CSDN博客
624. 数组列表中的最大距离
给定 m 个数组，每个数组都已经按照升序排好序了。现在你需要从两个不同的数组中选择两个整数（每个数组选一个）并且计算它们的距离。两个整数 a 和 b 之间的距离定义为它们差的绝对值 |a-b| 。你的任务就是去找到最大距离
示例 1：
输入：
[[1,2,3],
[4,5],
[1,2,3]]
输出： 4
解释：
一种得到答案 4 的方法是从第一个数组或者第三个数组中选择 1，同时从第二个数组中选择 5 。
注意：
每个给定数组至少会有 1 个数字。列表中至少有两个非空数组。
所有 m 个数组中的数字总数目在范围 [2, 10000] 内。
m 个数组中所有整数的范围在 [-10000, 10000] 内。
class Solution {
public:
void minmax(vector>& v, int& minid, int& maxid)
{
minid = 0, maxid = 0;
for (int i = 1; i < v.size(); i++) {
if (v[minid][0] > v[i][0])minid = i;
if (v[maxid].back() < v[i].back())maxid = i;
}
}
int maxDistance(vector>& v) {
int minid = 0, maxid = 0;
minmax(v, minid, maxid);
int a = v[minid][0], b = v[maxid].back();
if (minid != maxid)return b - a;
v.erase(v.begin() + minid);
minmax(v, minid, maxid);
int c = v[minid][0], d = v[maxid].back();
return max(b - c, d - a);
}
}; 625. 最小因式分解
给定一个正整数 a，找出最小的正整数 b 使得 b 的所有数位相乘恰好等于 a。
如果不存在这样的结果或者结果不是 32 位有符号整数，返回 0。
样例 1
输入：
48
输出：
68
样例 2
输入：
15
输出：
35
思路一，因式分解成2，3，5，7，再根据调整法得到贪心策略（关于2和3怎么组合）
class Solution {
public:
int smallestFactorization(int num) {
if(num==1)return 1;
int a2 = 0, a3 = 0, a5 = 0, a7 = 0;
while (num % 2 == 0)a2++, num /= 2;
while (num % 3 == 0)a3++, num /= 3;
while (num % 5 == 0)a5++, num /= 5;
while (num % 7 == 0)a7++, num /= 7;
if (num > 1)return 0;
vectorvf;
while (a7--)vf.push_back(7);
while (a5--)vf.push_back(5);
while (a2 >= 3)a2 -= 3, vf.push_back(8);
while (a3 >= 2)a3 -= 2, vf.push_back(9);
int k = 1;
while (a2--)k *= 2;
while (a3--)k *= 3;
if (k == 12)vf.push_back(2), vf.push_back(6);
else if (k > 1)vf.push_back(k);
if (vf.size() > 10)return 0;
sort(vf.begin(), vf.end());
long long n = 0;
for (auto& vi : vf)n *= 10, n += vi;
if (n > INT_MAX)return 0;
return n;
}
};
思路二，直接分成成2-9，大的优先。
class Solution {
public:
int smallestFactorization(int num) {
if (num == 1)return 1;
vectorvf;
for (int i = 9; i > 1; i--)while (num % i == 0)num/=i, vf.insert(vf.begin(),i);
if (num>1 || vf.size() > 10)return 0;
long long n = 0;
for (auto& vi : vf)n *= 10, n += vi;
if (n > INT_MAX)return 0;
return n;
}
};
628. 三个数的最大乘积
rust
629. K 个逆序对数组
排列组合
630. 课程表 III
贪心 贪心（2）活动安排问题_nameofcsdn的博客-CSDN博客
634. 寻找数组的错位排列
其他排列组合问题
643. 子数组最大平均数 I
给你一个由 n 个元素组成的整数数组 nums 和一个整数 k 。
请你找出平均数最大且 长度为 k 的连续子数组，并输出该最大平均数。
任何误差小于 10-5 的答案都将被视为正确答案。
示例 1：
输入：nums = [1,12,-5,-6,50,3], k = 4
输出：12.75
解释：最大平均数 (12-5-6+50)/4 = 51/4 = 12.75
示例 2：
输入：nums = [5], k = 1
输出：5.00000
提示：
n == nums.length
1 <= k <= n <= 105
-104 <= nums[i] <= 104
class Solution {
public:
double findMaxAverage(vector& nums, int k) {
int s = 0;
for (int i = 0; i < k; i++)s += nums[i];
double ans = s;
for (int i = k; i < nums.size(); i++) {
s += nums[i] - nums[i - k], ans = max(ans, s*1.0);
}
return ans / k;
}
}; 644. 子数组最大平均数 II
数列DP
646. 最长数对链
数列DP
647. 回文子串
区间DP
660. 移除 9
数位DP
664. 奇怪的打印机
区间DP
672. 灯泡开关 Ⅱ
找规律
673. 最长递增子序列的个数
数列DP
679. 24 点游戏
24点
680. 验证回文字符串 Ⅱ
剑指 Offer II 019. 最多删除一个字符得到回文
力扣OJ 剑指 Offer II_csuzhucong的博客-CSDN博客
683. K 个关闭的灯泡
线段树
684. 冗余连接
rust
685. 冗余连接 II
rust
686. 重复叠加字符串匹配
KMP
690. 员工的重要性
多叉树
693. 交替位二进制数
题目：
给定一个正整数，检查他是否为交替位二进制数：换句话说，就是他的二进制数相邻的两个位数永不相等。
示例 1:
输入: 5
输出: True
解释:
5的二进制数是: 101
示例 2:
输入: 7
输出: False
解释:
7的二进制数是: 111
示例 3:
输入: 11
输出: False
解释:
11的二进制数是: 1011
示例 4:
输入: 10
输出: True
解释:
10的二进制数是: 1010
代码：
class Solution {
public:
bool hasAlternatingBits2(int n) {
if (n == 0)return true;
if (n % 4 == 1)return hasAlternatingBits2(n / 4);
return false;
}
bool hasAlternatingBits(int n) {
if (n % 2 == 0)n /= 2;
return hasAlternatingBits2(n);
}
};695. 岛屿的最大面积
并查集
697. 数组的度
rust
698. 划分为k个相等的子集
题目：
给定一个整数数组 nums 和一个正整数 k，找出是否有可能把这个数组分成 k 个非空子集，其总和都相等。
示例 1：
输入： nums = [4, 3, 2, 3, 5, 2, 1], k = 4
输出： True
说明： 有可能将其分成 4 个子集（5），（1,4），（2,3），（2,3）等于总和。
注意:
1 <= k <= len(nums) <= 16
0 < nums[i] < 10000
思路：
DFS，注意剪枝，我这里采用的是简单的降序排序，排序可以让执行时间从2000ms降为4ms
代码：
int s[16];
class Solution {
public:
bool canPartitionKSubsets(vector &nums, int k, int deep)
{
if (deep >= nums.size())return true;
for (int j = 0; j <= deep && j < k; j++) {
if (s[j] < nums[deep])continue;
s[j] -= nums[deep];
if (canPartitionKSubsets(nums, k, deep + 1))return true;
s[j] += nums[deep];
}
return false;
}
bool canPartitionKSubsets(vector &nums, int k)
{
if (nums.size() < k || k <= 0 || k > 16)return false;
sort(nums.begin(),nums.end(),greater());
int anss = 0;
for (auto it = nums.begin(); it != nums.end(); it++) anss += *it;
if (anss % k) return false;
anss /= k;
for (int i = 0; i < k; i++) s[i] = anss;
return canPartitionKSubsets(nums, k, 0);
}
}; 704. 二分查找
rust
708. 循环有序列表的插入
剑指 Offer II 029. 排序的循环链表
713. 乘积小于K的子数组
剑指 Offer II 009. 乘积小于 K 的子数组
714. 买卖股票的最佳时机含手续费
状态转换DP
716. 最大栈
单调栈
720. 词典中最长的单词
给出一个字符串数组words组成的一本英语词典。从中找出最长的一个单词，该单词是由words词典中其他单词逐步添加一个字母组成。若其中有多个可行的答案，则返回答案中字典序最小的单词。
若无答案，则返回空字符串。
示例 1：
输入：
words = ["w","wo","wor","worl", "world"]
输出："world"
解释：
单词"world"可由"w", "wo", "wor", 和 "worl"添加一个字母组成。
示例 2：
输入：
words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
输出："apple"
解释：
"apply"和"apple"都能由词典中的单词组成。但是"apple"的字典序小于"apply"。
提示：
所有输入的字符串都只包含小写字母。
words数组长度范围为[1,1000]。
words[i]的长度范围为[1,30]。
我的代码：（动态规划的备忘录写法）
mapexitt;
mapm;
void init(vector& words)
{
exitt.clear();
m.clear();
for(int i=0;i0)return m[s]=dp(preString(s))+1;
return m[s]=-1;
}
class Solution {
public:
string longestWord(vector& words) {
init(words);
string ans="";
for(int i=0;iwords[i])
ans=words[i];
}
cout< 也可以用字典树做。
724. 寻找数组的中心下标
剑指 Offer II 012. 左右两边子数组的和相等
733. 图像渲染
并查集
738. 单调递增的数字
题目：
给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。
（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）
示例 1:
输入: N = 10
输出: 9
示例 2:
输入: N = 1234
输出: 1234
示例 3:
输入: N = 332
输出: 299
说明: N 是在 [0, 10^9] 范围内的一个整数。
代码：
class Solution {
public:
int monotoneIncreasingDigits(int N) {
int key = 1111111111, ans = 0, num = 9;
while (key)
{
while (N >= key && num > 0)
{
N -= key, ans += key, num--;
}
key /= 10;
}
return ans;
}
};740. 删除与获得点数
给定一个整数数组 nums ，你可以对它进行一些操作。
每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除每个等于 nums[i] - 1 或 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。
示例 1:
输入: nums = [3, 4, 2]
输出: 6
解释:
删除 4 来获得 4 个点数，因此 3 也被删除。
之后，删除 2 来获得 2 个点数。总共获得 6 个点数。
示例 2:
输入: nums = [2, 2, 3, 3, 3, 4]
输出: 9
解释:
删除 3 来获得 3 个点数，接着要删除两个 2 和 4 。
之后，再次删除 3 获得 3 个点数，再次删除 3 获得 3 个点数。
总共获得 9 个点数。
注意:
nums的长度最大为20000。
每个整数nums[i]的大小都在[1, 10000]范围内。
class Solution {
public:
int s[10001];
int ans[10001];
int dp(int k)
{
if(k<0)return 0;
if(ans[k])return ans[k];
return ans[k]=max(s[k]+dp(k-2),dp(k-1));
}
int deleteAndEarn(vector& nums) {
if(nums.size()==0)return 0;
memset(ans,0,sizeof(int)*10001);
memset(s,0,sizeof(int)*10001);
for(int i=0;i 742. 二叉树最近的叶节点
给定一个 每个结点的值互不相同 的二叉树，和一个目标整数值 k，返回 树中与目标值 k 最近的叶结点 。
与叶结点最近 表示在二叉树中到达该叶节点需要行进的边数与到达其它叶结点相比最少。而且，当一个结点没有孩子结点时称其为叶结点。
示例 1：
输入：root = [1, 3, 2], k = 1
输出： 2
解释： 2 和 3 都是距离目标 1 最近的叶节点。
示例 2：
输入：root = [1], k = 1
输出：1
解释：最近的叶节点是根结点自身。
示例 3：
输入：root = [1,2,3,4,null,null,null,5,null,6], k = 2
输出：3
解释：值为 3（而不是值为 6）的叶节点是距离结点 2 的最近结点。
提示：
二叉树节点数在 [1, 1000] 范围内
1 <= Node.val <= 1000
每个节点值都 不同
给定的二叉树中有某个结点使得 node.val == k
这个代码写的很烂很痛苦，最终还是AC了。
class Solution {
public:
map< TreeNode*, int>m;
map< TreeNode*, int>m2;
bool flag;
int dfs(TreeNode* root, int& num)
{
if (!root->left && !root->right) {
m[root] = 1, num = m2[root] = root->val;
return 1;
}
int deep = INT_MAX;
if (root->left)deep = dfs(root->left, num) + 1, m2[root] = num;
if (root->right) {
int ret = dfs(root->right, num);
if (deep > ret + 1) {
deep = min(deep, ret + 1), m2[root] = num;
}
else num = m2[root];
}
m[root] = deep;
return deep;
}
int dfs2(TreeNode* root, int k, int n, int& num) {
if (root->val == k) {
int ans = m[root];
num = m2[root];
return min(ans, n + 1);
}
if (root->left) {
int ans = dfs2(root->left, k, min(n + 1, m[root]), num);
if (flag && ans == min(n + 1, m[root]) + 1)num = m2[root];
else if (ans != -1) {
flag = false;
return ans + 1;
}
if (ans != -1)return ans - 1;
}
if (root->right) {
int ans = dfs2(root->right, k, min(n + 1, m[root]), num);
if (flag && ans == min(n + 1, m[root]) + 1)num = m2[root];
else if (ans != -1) {
flag = false;
return ans + 1;
}
if (ans != -1)return ans - 1;
}
return -1;
}
int findClosestLeaf(TreeNode* root, int k) {
int num;
flag = true;
dfs(root, num);
dfs2(root, k, m[root] - 1, num);
return num;
}
};743. 网络延迟时间
BFS
746. 使用最小花费爬楼梯
https://blog.csdn.net/nameofcsdn/article/details/119833252
752. 打开转盘锁
双向BFS
753. 破解保险箱
欧拉回路
754. 到达终点数字
在一根无限长的数轴上，你站在0的位置。终点在target的位置。
你可以做一些数量的移动 numMoves :
- 每次你可以选择向左或向右移动。
- 第
i次移动（从i == 1开始，到i == numMoves），在选择的方向上走i步。
给定整数 target ，返回 到达目标所需的 最小 移动次数(即最小 numMoves ) 。
示例 1:
输入: target = 2 输出: 3 解释: 第一次移动，从 0 到 1 。 第二次移动，从 1 到 -1 。 第三次移动，从 -1 到 2 。
示例 2:
输入: target = 3 输出: 2 解释: 第一次移动，从 0 到 1 。 第二次移动，从 1 到 3 。
提示:
-109 <= target <= 109target != 0
思路：第k次移动之后可能到达的位置是非常有规律的。
class Solution {
public:
int reachNumber(long long n) {
int x=ceil((sqrt(abs(n)*8+1)-1)/2);
return (n+1+(x-1)%4/2)%2?x+x%2+1:x;
}
};756. 金字塔转换矩阵
DFS
762. 二进制表示中质数个计算置位
题目：
给定两个整数 L 和 R ，找到闭区间 [L, R] 范围内，计算置位位数为质数的整数个数。
（注意，计算置位代表二进制表示中1的个数。例如 21 的二进制表示 10101 有 3 个计算置位。还有，1 不是质数。）
示例 1:
输入: L = 6, R = 10
输出: 4
解释:
6 -> 110 (2 个计算置位，2 是质数)
7 -> 111 (3 个计算置位，3 是质数)
9 -> 1001 (2 个计算置位，2 是质数)
10-> 1010 (2 个计算置位，2 是质数)
示例 2:
输入: L = 10, R = 15
输出: 5
解释:
10 -> 1010 (2 个计算置位, 2 是质数)
11 -> 1011 (3 个计算置位, 3 是质数)
12 -> 1100 (2 个计算置位, 2 是质数)
13 -> 1101 (3 个计算置位, 3 是质数)
14 -> 1110 (3 个计算置位, 3 是质数)
15 -> 1111 (4 个计算置位, 4 不是质数)
注意:
L, R 是 L <= R 且在 [1, 10^6] 中的整数。
R - L 的最大值为 10000。
代码：
class Solution {
public:
int hammingWeight(int n) {
int ans = 0;
while (n)
{
n ^= (n&(-n));
ans++;
}
return ans;
}
int countPrimeSetBits(int L, int R) {
setse = { 2, 3, 5, 7 ,11,13,17,19};
int ans = 0;
for (int i = L; i <= R; i++)
{
if (se.find(hammingWeight(i)) != se.end())ans++;
}
return ans;
}
}; 764. 最大加号标志
搜索else
767. 重构字符串
贪心（3）其他排序问题
769. 最多能完成排序的块
水题
771. 宝石与石头
给你一个字符串 jewels 代表石头中宝石的类型，另有一个字符串 stones 代表你拥有的石头。 stones 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
字母区分大小写，因此 "a" 和 "A" 是不同类型的石头。
示例 1：
输入：jewels = "aA", stones = "aAAbbbb" 输出：3
示例 2：
输入：jewels = "z", stones = "ZZ" 输出：0
提示：
1 <= jewels.length, stones.length <= 50jewels和stones仅由英文字母组成jewels中的所有字符都是 唯一的
class Solution {
public:
int numJewelsInStones(string jewels, string stones) {
mapm;
for(auto c:jewels)m[c]++;
int ans=0;
for(auto c:stones)if(m[c])ans++;
return ans;
}
}; 774. 最小化去加油站的最大距离
整数数组 stations 表示 水平数轴 上各个加油站的位置。给你一个整数 k 。
请你在数轴上增设 k 个加油站，新增加油站可以位于 水平数轴 上的任意位置，而不必放在整数位置上。
设 penalty() 是：增设 k 个新加油站后，相邻 两个加油站间的最大距离。
请你返回 penalty() 可能的最小值。与实际答案误差在 10-6 范围内的答案将被视作正确答案。
示例 1：
输入：stations = [1,2,3,4,5,6,7,8,9,10], k = 9
输出：0.50000
示例 2：
输入：stations = [23,24,36,39,46,56,57,65,84,98], k = 1
输出：14.00000
提示：
10 <= stations.length <= 2000
0 <= stations[i] <= 108
stations 按 严格递增 顺序排列
1 <= k <= 106
class Solution {
public:
bool ok(vector& stations, int k, double d)
{
int s = 0;
for (int i = 1; i < stations.size(); i++)s += (stations[i] - stations[i - 1]) / d;
return s <= k;
}
double minmaxGasDist(vector& stations, int k) {
double low = 1.0 / k, high = stations.back() - stations[0];
while (high - low > 0.00001) {
double mid = (low + high) / 2;
if (ok(stations, k, mid))high = mid;
else low = mid;
}
return high;
}
}; 776. 拆分二叉搜索树
二叉搜索树（BST）
778. 水位上升的泳池中游泳
BFS
785. 判断二分图
二分图
787. K 站中转内最便宜的航班
单源最短路径
790. 多米诺和托米诺平铺
有两种形状的瓷砖：一种是 2 x 1 的多米诺形，另一种是形如 "L" 的托米诺形。两种形状都可以旋转。
给定整数 n ，返回可以平铺 2 x n 的面板的方法的数量。返回对 109 + 7 取模 的值。
平铺指的是每个正方形都必须有瓷砖覆盖。两个平铺不同，当且仅当面板上有四个方向上的相邻单元中的两个，使得恰好有一个平铺有一个瓷砖占据两个正方形。
示例 1:
输入: n = 3 输出: 5 解释: 五种不同的方法如上所示。
示例 2:
输入: n = 1 输出: 1
提示：
1 <= n <= 1000
class Solution {
public:
int numTilings(int n) {
if(n<2)return 1;
n-=2;
int a=1,b=1,c=2,d=0;
while(n--)d=(c*2%1000000007+a)%1000000007,a=b,b=c,c=d;
return c;
}
};791. 自定义字符串排序
给定两个字符串 order 和 s 。order 的所有单词都是 唯一 的，并且以前按照一些自定义的顺序排序。
对 s 的字符进行置换，使其与排序的 order 相匹配。更具体地说，如果在 order 中的字符 x 出现字符 y 之前，那么在排列后的字符串中， x 也应该出现在 y 之前。
返回 满足这个性质的 s 的任意排列 。
示例 1:
输入: order = "cba", s = "abcd" 输出: "cbad" 解释: “a”、“b”、“c”是按顺序出现的，所以“a”、“b”、“c”的顺序应该是“c”、“b”、“a”。 因为“d”不是按顺序出现的，所以它可以在返回的字符串中的任何位置。“dcba”、“cdba”、“cbda”也是有效的输出。
示例 2:
输入: order = "cbafg", s = "abcd" 输出: "cbad"
提示:
1 <= order.length <= 261 <= s.length <= 200order和s由小写英文字母组成order中的所有字符都 不同
class Solution {
public:
string customSortString(string order, string s) {
mapm1,m2;
for(auto c:order)m1[c]=1;
string ans;
for(auto c:s){
if(m1[c])m2[c]++;
else ans+=c;
}
for(auto c:order)while(m2[c]--)ans+=c;
return ans;
}
}; 793. 阶乘函数后 K 个零
阶乘
795. 区间子数组个数
给你一个整数数组 nums 和两个整数：left 及 right 。找出 nums 中连续、非空且其中最大元素在范围 [left, right] 内的子数组，并返回满足条件的子数组的个数。
生成的测试用例保证结果符合 32-bit 整数范围。
示例 1：
输入：nums = [2,1,4,3], left = 2, right = 3 输出：3 解释：满足条件的三个子数组：[2], [2, 1], [3]
示例 2：
输入：nums = [2,9,2,5,6], left = 2, right = 8 输出：7
提示：
1 <= nums.length <= 1050 <= nums[i] <= 1090 <= left <= right <= 109
class Solution {
public:
long long numSubarrayBoundedMax(vector& nums, int key) {
int low=0;
long long ans=0;
for(int i=0;i<=nums.size();i++){
if(i& nums, int left, int right) {
return numSubarrayBoundedMax(nums,right)-numSubarrayBoundedMax(nums,left-1);
}
}; 797. 所有可能的路径
回溯算法
800. 相似 RGB 颜色
RGB 颜色 "#AABBCC" 可以简写成 "#ABC" 。
- 例如，
"#15c"其实是"#1155cc"的简写。
现在，假如我们分别定义两个颜色 "#ABCDEF" 和 "#UVWXYZ"，则他们的相似度可以通过这个表达式 -(AB - UV)^2 - (CD - WX)^2 - (EF - YZ)^2 来计算。
那么给你一个按 "#ABCDEF" 形式定义的字符串 color 表示 RGB 颜色，请你以字符串形式，返回一个与它相似度最大且可以简写的颜色。（比如，可以表示成类似 "#XYZ" 的形式）
任何 具有相同的（最大）相似度的答案都会被视为正确答案。
示例 1：
输入：color = "#09f166" 输出："#11ee66" 解释： 因为相似度计算得出 -(0x09 - 0x11)^2 -(0xf1 - 0xee)^2 - (0x66 - 0x66)^2 = -64 -9 -0 = -73 这已经是所有可以简写的颜色中最相似的了
示例 2：
输入：color = "#4e3fe1" 输出："#5544dd"
提示：
color.length == 7color[0] == '#'- 对于任何
i > 0，color[i]都是一个在范围['0', 'f']内的 16 进制数
class Solution {
public:
int toNum(char c)
{
if (c >= '0' && c <= '9')return c - '0';
return c - 'a' + 10;
}
char toChar(int n)
{
char ans = '0';
if (n < 10)return ans + n;
ans = 'a';
return ans + n - 10;
}
string similarRGB(string color) {
for (int i = 1; i < color.size(); i += 2) {
int x = toNum(color[i]);
int y = toNum(color[i+1]);
int s = x * 16 + y;
int k = 0, d = INT_MAX;
for (int i = 0; i < 16; i++) {
s -= i * 17;
if (s * s < d)d = s * s, k = i;
s+= i * 17;
}
color[i] = toChar(k);
color[i+1] = toChar(k);
}
return color;
}
};