题目地址
统计匹配检索规则的物品数量
水题，模拟即可。
class Solution {
private:
bool check(vector<string>& s, string ruleKey, string ruleValue)
{
if (ruleKey == "type")
{
return s[0] == ruleValue;
}
else if (ruleKey == "color")
{
return s[1] == ruleValue;
}
return s[2] == ruleValue;
}
public:
int countMatches(vector<vector<string>>& items, string ruleKey, string ruleValue) {
int res = 0;
for (int i = 0; i < items.size(); i++)
{
if (check(items[i], ruleKey, ruleValue))
res++;
}
return res;
}
};
最接近目标价格的甜点成本
简单来说，你必须选一个冰激凌基料，配料可以有多种，每种配料可以加的数量为0，1，2。数据范围均为10，这就提示我们用递归。
更新数据时，如果与目标差值相等，选小的。否则选差值小的那个数。
class Solution {
private:
int res = 0;
int update(int res, int k, int target)
{
if (res == 0) return k;
if (abs(target - res) == abs(target - k))
return res > k ? k : res;
return abs(target - res) > abs(target - k) ? k : res;
}
void dfs(int sum, int index, vector<int>& t,int target)
{
res = update(res, sum, target);
if (index == t.size())return;
for (int i = 0; i < 3; i++)
{
dfs(sum + i * t[index], index + 1, t, target);
}
}
public:
int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
for (int i = 0; i < baseCosts.size(); i++)
{
dfs(baseCosts[i], 0, toppingCosts, target);
}
return this->res;
}
};
通过最少操作次数使数组的和相等
两个有序数组，a，b，从小到大排序。假设a的和较小。
双指针分别从 数组 a 左侧（较小侧） 和 数组 b 右侧（较大侧）开始移动；
为了让两数组和相等，每次操作可以使较大数变小（最小变为 1），或较小数变大（最大变为 6），贪心的选择变化差值最大的一边修改。如果有一个数组已无法修改，此时只能修改另一个数组。
修改终止条件，suma>=sumb。
当出现suma>=sumb时，一定可以修改到正好两者之和相等。
class Solution {
public:
int minOperations(vector<int>& nums1, vector<int>& nums2) {
int suma = 0, sumb = 0;
sort(nums1.begin(), nums1.end());
sort(nums2.begin(), nums2.end());
for (auto& t : nums1)suma += t;
for (auto& t : nums2)sumb += t;
if (suma > sumb)
{
swap(suma, sumb);
swap(nums1, nums2);
}
//左边小，右边大
int res = 0;
int size1 = nums1.size(), size2 = nums2.size();
int i = 0, j = size2-1;
while (i < size1 && j >= 0 && suma < sumb)
{
if (6 - nums1[i] > nums2[j] - 1)//选择变化差值大的地方
suma += 6 - nums1[i++];
else
sumb -= nums2[j--] - 1;
res++;
}
//已经有一个地方变化完毕
while (i<size1 && suma>sumb)
{
suma += 6 - nums1[i++];
res++;
}
while (j >= 0 && suma < sumb)
{
sumb -= nums2[j--] - 1;
res++;
}
return suma >= sumb ? res : -1;
}
};
车队 II
最右侧的车的答案一定是 −1。每个车都需要追最右边的车，设i辆车为Ci位置为Pi，速度为Si。
对于右边的车来说，如果
扫描二维码关注公众号，回复：
12572969 查看本文章
Si<=Si+1，则不会追到。反之，则追到的时间为 (Pi+1-P)/(Si-Si+1)。
但是实际情况更复杂一点。如果在当前车Ci 追到Ci+1时，Ci+1追到了Ci+2，那么就要用Ci+2的时间来计算。
所以我们要用栈的思路来作：
如果当前车Ci 追到Ci+1时，Ci+1追到了Ci+2，那么Ci+1可以删除，继续判断仍然执行上一步判断；如果仍可去除，则去除。
如果经过（0次或多次）去除之后，栈为空，则表明当前车不会追上任何车，答案是 −1。
如果经过去除之后，栈不为空，则表明当前车会追上当前栈顶的车Ctop。
class Solution {
private:
double get_time(vector<int>& front, vector<int>& back)
//计算时间
{
return (double)(front[0] - back[0]) / (back[1] - front[1]);
}
public:
vector<double> getCollisionTimes(vector<vector<int>>& cars) {
int size = cars.size();
vector<double>res(size);
res[size - 1] = -1;
stack<int> s;
s.push(size - 1);
for (int i = size - 2; i >= 0; i--)
{
while (s.size())
{
//追不上的条件，要么速度没超过，要么再追到时他已经和前面的车合并
if (cars[i][1] <=cars[s.top()][1] ||
(res[s.top()] >= 1e-5 && get_time(cars[s.top()], cars[i])>res[s.top()]))
s.pop();
else//追得上，退出，此时栈顶为追到的车
break;
}
if (s.size())
res[i] = get_time(cars[s.top()], cars[i]);
else
res[i] = -1;
s.push(i);
}
return res;
}
};