- Número de islas
Proporcione una cuadrícula bidimensional compuesta por "1" (tierra) y "0" (agua). Cuente el número de islas en la cuadrícula.
Las islas siempre están rodeadas de agua, y cada isla solo se puede formar conectando tierras adyacentes en dirección horizontal o vertical.
Este problema se puede resolver con BFS o DFS
class Solution {
private:
void dfs(vector<vector<char>>& grid, int r, int c) {
int nr = grid.size();
int nc = grid[0].size();
grid[r][c] = '0';
if (r - 1 >= 0 && grid[r-1][c] == '1') dfs(grid, r - 1, c);
if (r + 1 < nr && grid[r+1][c] == '1') dfs(grid, r + 1, c);
if (c - 1 >= 0 && grid[r][c-1] == '1') dfs(grid, r, c - 1);
if (c + 1 < nc && grid[r][c+1] == '1') dfs(grid, r, c + 1);
}
public:
int numIslands(vector<vector<char>>& grid) {
int nr = grid.size();
if (!nr) return 0;
int nc = grid[0].size();
int num_islands = 0;
for (int r = 0; r < nr; ++r) {
for (int c = 0; c < nc; ++c) {
if (grid[r][c] == '1') {
++num_islands;
dfs(grid, r, c);
}
}
}
return num_islands;
}
};
class Solution {
public:
int numIslands(vector<vector<char>>& grid) {
int nr = grid.size();
if (!nr) return 0;
int nc = grid[0].size();
int num_islands = 0;
for (int r = 0; r < nr; ++r) {
for (int c = 0; c < nc; ++c) {
if (grid[r][c] == '1') {
++num_islands;
grid[r][c] = '0';
queue<pair<int, int>> neighbors;
neighbors.push({
r, c});
while (!neighbors.empty()) {
auto rc = neighbors.front();
neighbors.pop();
int row = rc.first, col = rc.second;
if (row - 1 >= 0 && grid[row-1][col] == '1') {
neighbors.push({
row-1, col});
grid[row-1][col] = '0';
}
if (row + 1 < nr && grid[row+1][col] == '1') {
neighbors.push({
row+1, col});
grid[row+1][col] = '0';
}
if (col - 1 >= 0 && grid[row][col-1] == '1') {
neighbors.push({
row, col-1});
grid[row][col-1] = '0';
}
if (col + 1 < nc && grid[row][col+1] == '1') {
neighbors.push({
row, col+1});
grid[row][col+1] = '0';
}
}
}
}
}
return num_islands;
}
};
- Rango de números AND bit a bit
Dado el rango [m, n], donde 0 <= m <= n <= 2147483647, devuelve el AND bit a bit de todos los números en este rango (incluidos m, n puntos finales).
La esencia de esta pregunta es cómo simplificar el número de operaciones de bits. En primer lugar, debemos prestar atención al número más pequeño, si el número de dígitos es diferente, simplemente comience desde el decimal. En segundo lugar, cuando los dígitos sean iguales, busque los diferentes dígitos y asigne el valor 0
class Solution {
public:
int rangeBitwiseAnd(int m, int n) {
if (m == n || m == 0) {
return m;
} else if (floor(log(n)/log(2)) - floor(log(m)/log(2)) >= 1) {
return 0;
} else {
int xorResult = n ^ m;
int bits = floor(log(xorResult)/log(2)) + 1;
return (m >> bits) << bits;
}
}
};
- Número feliz
Escribe un algoritmo para determinar si un número n es un número feliz.
"Número feliz" se define como: Para un entero positivo, cada vez que el número se reemplaza por la suma de los cuadrados de los números en cada posición, y luego este proceso se repite hasta que el número se convierte en 1, o puede ser un bucle infinito pero nunca cambia. A 1. Si se puede cambiar a 1, entonces este número es un número feliz.
Esta pregunta implica la posibilidad de bucles, por lo que es mejor usar punteros rápidos y lentos para detectar bucles
class Solution {
public:
int bitSquareSum(int n) {
int sum = 0;
while(n > 0)
{
int bit = n % 10;
sum += bit * bit;
n = n / 10;
}
return sum;
}
bool isHappy(int n) {
int slow = n, fast = n;
do{
slow = bitSquareSum(slow);
fast = bitSquareSum(fast);
fast = bitSquareSum(fast);
}while(slow != fast);
return slow == 1;
}
};
- Eliminar elementos de la lista vinculada
Elimina todos los nodos de la lista vinculada que sean iguales al valor dado val.
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
ListNode* sentinel = new ListNode(0);
sentinel->next = head;
ListNode *prev = sentinel, *curr = head, *toDelete = nullptr;
while (curr != nullptr) {
if (curr->val == val) {
prev->next = curr->next;
toDelete = curr;
} else prev = curr;
curr = curr->next;
if (toDelete != nullptr) {
delete toDelete;
toDelete = nullptr;
}
}
ListNode *ret = sentinel->next;
delete sentinel;
return ret;
}
};
- Contar números primos Cuente el número de
todos los números primos menores que un entero no negativo n.
Usando el método de tamiz Eradosé: primero establezca todo en números primos y luego excluya sus múltiplos a su vez
class Solution {
public:
int countPrimes(int n) {
int count = 0;
//初始默认所有数为质数
vector<bool> signs(n, true);
for (int i = 2; i < n; i++) {
if (signs[i]) {
count++;
for (int j = i + i; j < n; j += i) {
//排除不是质数的数
signs[j] = false;
}
}
}
return count;
}
};
- Cadenas
isomorfas Dadas dos cadenas s y t, juzgue si son isomorfas.
Si los caracteres en s se pueden reemplazar para obtener t, entonces las dos cadenas son isomorfas.
Todas las apariciones de caracteres deben ser reemplazadas por otro carácter preservando el orden de los caracteres. No se pueden asignar dos personajes al mismo personaje, pero el personaje se puede asignar a sí mismo.
Hay dos métodos para esta pregunta: use un mapa para mapear los caracteres existentes y luego verifique cada vez si el mapeo es el mismo. El segundo método es convertir los caracteres en números y luego comparar las dos cadenas de números
class Solution {
public:
bool isIsomorphic(string s, string t)
{
if (s.empty() && t.empty())
return true;
for(int i = 0; i < s.size(); i++)
{
if( s.find(s[i]) != t.find(t[i]))
return false;
}
return true;
}
};
- Lista enlazada
inversa Revierte una lista enlazada individualmente.
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode *next, *ptr, *prev;
ptr = next = head;
prev = NULL;
while (ptr)
{
next = ptr->next;
ptr->next = prev;
prev = ptr;
ptr = next;
}
return prev;
}
};
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if (head == NULL || head->next == NULL) {
return head;
}
ListNode* ret = reverseList(head->next);
head->next->next = head;
head->next = NULL;
return ret;
}
};