Me desperté a las 6:40, md, roto.
392. Determinación de subsecuencias
Descripción del Título:
Dadas las cadenas s y t, determine si s es una subsecuencia de t.
Una subsecuencia de una cadena es una nueva cadena formada al eliminar algunos (o no) caracteres de la cadena original sin cambiar las posiciones relativas de los caracteres restantes. (Por ejemplo, "ace" es una subsecuencia de "abcde", pero "aec" no lo es).
Avanzado:
Si hay una gran cantidad de entradas S, llamadas S1, S2, ..., Sk donde k >= 1 billón, debe verificar si son subsecuencias de T a su vez. En este caso, ¿cómo cambiarías el código?
Ideas:
Use dos punteros i y j para apuntar a las cadenas s y t respectivamente;
Como quieres encontrar el carácter de s en t, si s[i] y t[j] no son iguales, j retrocederá, y si son iguales, volverán a estar juntos;
Finalmente, juzgue si i ha llegado al final de la cadena s, si es así, devuelva verdadero, de lo contrario devuelva falso;
class Solution {
public:
bool isSubsequence(string s, string t) {
int i = 0, j = 0;
while (s[i] && t[j]) {
if (s[i] == t[j]) {
i++;
}
j++;
}
return s[i] == '\0';
// int i = 0, j = 0;
// while (i < s.size() && j < t.size()) {
// if (s[i] == t[j]) {
// ++i;
// }
// ++j;
// }
// if (i == s.size()) {
// return true;
// }
// return false;
}
};Descripción del Título:
Dada una cadena s y un entero k, cada vez que se cuentan 2k caracteres desde el principio de la cadena, invierta los primeros k caracteres de los 2k caracteres.
Si los caracteres restantes son menores que k, invierta todos los caracteres restantes.
Si los caracteres restantes son menores a 2k pero mayores o iguales a k, invierta los primeros k caracteres y deje el resto como están.
Ideas:
De acuerdo con el significado del título, en primer lugar, no importa si se pueden contar 2k números o no, el primer número menor o igual que k debe ser volteado, por lo que lo importante es juzgar cuántos números se deben voltear. ;
La función inversa puede escribirla usted mismo, o puede usar la función de biblioteca función inversa yyds;
class Solution {
void swap(char &a, char &b) {
char tmp = a;
a = b;
b = tmp;
}
public:
string reverseStr(string s, int k) {
int i;
int n = s.length();
int start, end;
for (i = 0; i < n; i += 2*k) {
start = i;
end = min(i + k - 1, n-1);
while (start < end) {
swap(s[start++], s[end--]);
}
}
return s;
// int n = s.length();
// for (int i = 0; i < n; i += 2*k) {
// reverse(s.begin() + i, s.begin() + min(i + k, n));
// }
// return s;
}
};
Pregunta de entrevista 16.24 Suma de pares
Descripción del Título:
Diseñe un algoritmo para encontrar todos los pares de enteros en una matriz cuya suma sea un valor específico. Un número solo puede pertenecer a un par de números.
Ideas:
Problema típico de doble puntero; recuerde ordenar primero
class Solution {
public:
vector<vector<int>> pairSums(vector<int>& nums, int target) {
sort(nums.begin(), nums.end());
int i = 0, j = nums.size() - 1;
vector<vector<int>> ans;
while (i < j) {
int sum = nums[i] + nums[j];
if (sum > target) {
j--;
} else if (sum < target) {
i++;
} else {
ans.push_back({nums[i], nums[j]});
i++;
j--;
}
}
return ans;
}
};696. Contar subcadenas binarias
Descripción del Título:
Dada una cadena s, cuente y devuelva la cantidad de subcadenas no vacías (contiguas) que tienen la misma cantidad de 0 y 1, donde todos los 0 y todos los 1 se agrupan de forma consecutiva.
Las subcadenas que aparecen repetidamente (en diferentes posiciones) también cuentan la cantidad de veces que aparecen.
Ideas:
Puede usar punteros dobles o dp;
Puntero doble:
Primero encuentre el primer carácter s[j] que no es igual al carácter anterior s[i], y registre la posición k;
Luego encuentre el último carácter s[j] que no es igual al carácter anterior. En este momento, se puede contar el número de veces. Este número depende de la longitud de la cadena más corta de las dos cadenas desiguales antes y después, que es, min(ki, jk) ki significa la longitud anterior de esa cadena, jk representa la longitud de la última cadena;
pd:
Atraviese la cadena primero y use dp[i] para representar la longitud de la subcadena igual más larga que se puede obtener desde el frente hasta la i-ésima posición;
Entonces, sea l = dp[i], lo que significa que hay l subcadenas de igual longitud en la i-ésima posición, entonces el carácter en la posición il no debe ser igual al carácter en la posición i, es decir, s[ i] != s[il], ll = dp[il] significa que hay ll cadenas de igual longitud en la posición de il, y cuando ll>l, el contador se incrementa en uno;
class Solution {
// int dp[100010];
public:
int countBinarySubstrings(string s) {
int ans = 0;
int i = 0, j = 0;
while (j < s.length()) {
while (s[i] == s[j] && j < s.length()) {
++j;
}
int k = j;
while (s[i] != s[j] && j < s.length()) {
++j;
}
ans += min(j - k, k - i);
i = k;
}
return ans;
// int ans = 0;
// s = '#' + s;
// for (int i = 1; i < s.length(); ++i) {
// if (s[i] == s[i-1]) {
// dp[i] = dp[i-1] + 1;
// } else {
// dp[i] = 1;
// }
// }
// for (int i = 1; i < s.length(); ++i) {
// int l = dp[i]; // 前面有l个字符与s[i]字符相等
// int ll = dp[i - l]; // 字符s[i-l]与字符s[i]不相等
// if (ll >= l) {
// ans ++;
// }
// }
// return ans;
}
};