Dirección del asunto
Cuente el número de elementos que coinciden con las reglas de búsqueda
Para problemas de agua, simplemente simule.
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;
}
};
Costo del postre más cercano al precio objetivo
En pocas palabras, debes elegir una base de helado, puede haber varios ingredientes y la cantidad de cada ingrediente puede ser 0, 1 o 2. El rango de datos es 10, lo que nos pide que usemos la recursividad.
Al actualizar los datos, si la diferencia es igual al objetivo, seleccione el más pequeño. De lo contrario, elija el número con la menor diferencia.
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;
}
};
Haga que la suma de la matriz sea igual al menor número de operaciones
Dos matrices ordenadas, a, b, se ordenan de pequeñas a grandes. Suponga que la suma de a es pequeña.
Los punteros dobles comienzan a moverse respectivamente desde el lado izquierdo (lado más pequeño) de la matriz a y el lado derecho (lado más grande) de la matriz b;
Para igualar la suma de las dos matrices, cada operación puede hacer que el número más grande sea más pequeño (el más pequeño se convierte en 1), o el número más pequeño se vuelve más grande (el más grande se convierte en 6), elija con avidez el lado con la mayor diferencia para modificar . Si hay una matriz que no se puede modificar, solo puede modificar otra matriz en este momento.
Modifique las condiciones de terminación, suma> = sumb.
Cuando aparece suma> = sumb, se debe modificar hasta que la suma de los dos sea exactamente igual.
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;
}
};
Flota II
La respuesta para el automóvil del extremo derecho debe ser -1. Cada automóvil debe perseguir al automóvil más a la derecha y configurar i automóvil como Ci, posición Pi y velocidad Si.
Para el coche de la derecha, si
Si <= Si + 1, no se perseguirá. Por el contrario, el tiempo registrado es (Pi + 1-P) / (Si-Si + 1).
Pero la situación real es un poco más complicada. Si Ci + 1 alcanza Ci + 2 cuando el automóvil actual Ci alcanza Ci + 1, entonces se usa el tiempo de Ci + 2 para calcular.
Entonces tenemos que usar la idea de la pila para hacer:
Si el coche actual Ci alcanza a Ci + 1, y Ci + 1 alcanza a Ci + 2, entonces Ci + 1 se puede eliminar, continuar juzgando y aún ejecutar la sentencia anterior; si aún se puede eliminar, elimínelo .
Si la pila está vacía después de la extracción (0 o más veces), significa que el automóvil actual no alcanzará a ningún automóvil, y la respuesta es -1.
Si la pila no está vacía después de la eliminación, significa que el automóvil actual alcanzará el Ctop del automóvil en la parte superior de la pila actual.
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;
}
};