- Nombre d'îles
Vous donne une grille bidimensionnelle composée de «1» (terre) et «0» (eau) Veuillez compter le nombre d'îles dans la grille.
Les îles sont toujours entourées d'eau et chaque île ne peut être formée qu'en reliant les terres adjacentes dans le sens horizontal ou vertical.
Ce problème peut être résolu avec BFS ou 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;
}
};
- Plage de nombres au niveau du bit ET
Plage donnée [m, n], où 0 <= m <= n <= 2147483647, renvoie le ET au niveau du bit de tous les nombres de cette plage (y compris m, n points d'extrémité).
L'essence de cette question est de savoir comment simplifier le nombre d'opérations sur les bits. Tout d'abord, nous devons faire attention au plus petit nombre.Si le nombre de chiffres est différent, commencez simplement par la décimale. Deuxièmement, lorsque les chiffres sont identiques, trouvez les différents chiffres et attribuez la valeur 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;
}
}
};
- Nombre heureux
Ecrivez un algorithme pour déterminer si un nombre n est un nombre heureux.
«Nombre heureux» est défini comme: Pour un entier positif, chaque fois que le nombre est remplacé par la somme des carrés des nombres dans chaque position, puis ce processus est répété jusqu'à ce que le nombre devienne 1, ou ce peut être une boucle infinie mais cela ne change jamais. À 1. S'il peut être changé en 1, alors ce nombre est un nombre heureux.
Cette question implique la possibilité de boucles, il est donc préférable d'utiliser des pointeurs rapides et lents pour détecter les boucles
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;
}
};
- Supprimer les éléments de liste liée
Supprimez tous les nœuds de la liste liée qui sont égaux à la valeur donnée 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;
}
};
- Comptage des nombres premiers Comptez le nombre de
tous les nombres premiers inférieur à un entier non négatif n.
Utilisation de la méthode du tamis Eradosé: définissez d'abord tous les nombres premiers, puis excluez leurs multiples à leur tour
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;
}
};
- Chaînes isomorphes
Étant donné deux chaînes s et t, juger si elles sont isomorphes.
Si les caractères de s peuvent être remplacés pour obtenir t, alors les deux chaînes sont isomorphes.
Toutes les occurrences de caractères doivent être remplacées par un autre caractère tout en préservant l'ordre des caractères. Deux caractères ne peuvent pas être mappés sur le même caractère, mais le personnage peut être mappé sur lui-même.
Il existe deux méthodes pour cette question: utiliser une carte pour mapper les caractères existants, puis vérifier à chaque fois si le mappage est le même. La deuxième méthode consiste à convertir les caractères en nombres, puis à comparer les deux chaînes de nombres
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;
}
};
- Inverser la liste liée
Inverser une liste liée individuellement.
/**
* 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;
}
};