Tabla de contenido
Uno. 2496. El valor máximo de la cadena en la matriz
2. Pregunta de la entrevista 16.19 El tamaño del área de agua
1595. El costo mínimo de conectar dos conjuntos de puntos
Uno. 2496. El valor máximo de la cadena en la matriz
Ideas:
Recorra las cadenas en la matriz de entrada para determinar si cada carácter de la cadena es un número. Si la cadena contiene solo números, convierta la cadena al número representado en decimal; de lo contrario, el valor es la longitud de la cadena. Finalmente devuelve el valor máximo en la matriz de cadenas.
código:
class Solution {
public:
int maximumValue(vector<string>& strs) {
int cnt=0;
for(auto& str:strs){
bool flage=true;
for(char& s:str){
if(!isdigit(s)){
flage=false;
break;
}
}
cnt=max(cnt,flage?stoi(str):(int)str.size());
}
return cnt;
}
};Precauciones:
isdigit() es un carácter que detecta si un carácter es un dígito.
stoi() convierte una cadena de números en un número.
El valor de retorno de string.size() es de tipo sin firmar y debe convertirse.
2. Pregunta de la entrevista 16.19 El tamaño del área de agua
Ideas:
- A partir de 0 en el gráfico de cuadrícula, DFS visita 0 en ocho direcciones y marca estos 0 como "visitados". Cuando se implementa el código, 0 se puede cambiar directamente a 1.
- En el proceso DFS, se cuenta el número de cuadrículas visitadas en cada dirección y el número se acumula para obtener el cnt del tamaño del estanque.
- Cada vez que se comienza desde un nuevo 0 (punto de partida), significa que se ha encontrado un nuevo estanque y se agrega a la respuesta el tamaño del estanque obtenido por DFS.
- Utilice la función de clasificación para ordenar las respuestas y devolverlas.
código:
class Solution {
public:
int fang[8][2]={
{1,0},{0,1},{-1,0},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};
int dfs(vector<vector<int>> &land, int x, int y) {
if (x < 0 || x >= land.size() || y < 0 || y >= land[x].size() || land[x][y])
return 0;
land[x][y] = 1;
// 标记 (x,y) 被访问，避免重复访问
int cnt = 1;
// 访问八方向的
for(int i=0;i<8;i++)
cnt+= dfs(land,x+fang[i][0],y+fang[i][1]);
return cnt;
}
vector<int> pondSizes(vector<vector<int>>& land) {
int hang=land.size();
int lie=land[0].size();
vector<int> s;
for(int i=0;i<hang;i++){
for(int j=0;j<lie;j++){
if(land[i][j]==0){
int p=dfs(land,i,j);
s.push_back(p);
}
}
}
sort(s.begin(),s.end());
return s;
}
};
3. LCP 41. Ajedrez Inverso
Ideas:
Nos dimos cuenta de que el tamaño máximo del tablero de ajedrez en el título es de 8 × 8, por lo que podemos intentar enumerar todas las posiciones vacantes como la siguiente posición para colocar el ajedrez negro y luego usar el método de búsqueda en anchura para calcular la posición. que se puede voltear debajo de esta posición El número de piezas blancas, solo encuentre el valor máximo. Definimos una función bfs(i,j), que representa el número de piezas blancas que se pueden voltear después de colocar una pieza negra en la posición (i,j) del tablero. En la función, usamos la cola para la búsqueda en anchura, colocamos (i,j) en la cola al principio, y luego sacamos la posición del jefe del equipo continuamente y recorremos las ocho direcciones del tablero. Si hay un ajedrez blanco continuo en esta dirección, y hay una pieza negra al final, entonces todas las piezas blancas antes de la pieza negra se pueden voltear, colocar las posiciones de estas piezas blancas en la cola y continuar la amplitud. primera búsqueda. Finalmente, devolvemos el número de piezas blancas que se pueden voltear.
código:
class Solution {
public:
const int dirs[8][2] = {
{1, 0}, {-1, 0}, {0, 1}, {0, -1}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}
};
bool judge(const vector<string>& chessboard, int x, int y, int dx, int dy) {
x += dx;
y += dy;
while (0 <= x && x < chessboard.size() && 0 <= y && y < chessboard[0].size()) {
if (chessboard[x][y] == 'X') {
return true;
} else if (chessboard[x][y] == '.') {
return false;
}
x += dx;
y += dy;
}
return false;
}
int bfs(vector<string> chessboard, int px, int py) {
int cnt = 0;
queue<pair<int, int>> q;
q.emplace(px, py);
chessboard[px][py] = 'X';
while (!q.empty()) {
pair<int, int> t = q.front();
q.pop();
for (int i = 0; i < 8; ++i) {
if (judge(chessboard, t.first, t.second, dirs[i][0], dirs[i][1])) {
int x = t.first + dirs[i][0], y = t.second + dirs[i][1];
while (chessboard[x][y] != 'X') {
q.emplace(x, y);
chessboard[x][y] = 'X';
x += dirs[i][0];
y += dirs[i][1];
++cnt;
}
}
}
}
return cnt;
}
int flipChess(vector<string>& chessboard) {
int res = 0;
for (int i = 0; i < chessboard.size(); ++i) {
for (int j = 0; j < chessboard[0].size(); ++j) {
if (chessboard[i][j] == '.') {
res = max(res, bfs(chessboard, i, j));
}
}
}
return res;
}
};
1595. El costo mínimo de conectar dos conjuntos de puntos
Ideas:
Enumere el primer grupo de elementos. Para estos n elementos, cada elemento tiene 2^m estados de conexión (un elemento se puede conectar a varios elementos de otro grupo) y hay 2^m métodos de conexión. Enumere n elementos. Para cada conjunto de estados del elemento i-ésimo, calcule el costo mínimo del conjunto de estados total de él y los primeros elementos i-1. Aquí, si se trata de una enumeración directa violenta, la complejidad del tiempo es O( n2^ m2^m)
Debido a que hay un total de n elementos, el tamaño del primer conjunto de estados de elementos i-1 es 2^m, y el tamaño del conjunto de estados de elementos i-ésimo actual es 2^m. El conjunto del
elemento actual i es el conjunto de estado del elemento i anterior Hay dos casos cuando se crea un subconjunto:
1: cuando el conjunto de estado del elemento i no tiene intersección con el conjunto de estado de los elementos i-1 anteriores, la combinación de los dos conjuntos puede hacer que el costo de la unión sea más pequeño 2: El conjunto de estados del
elemento i y los elementos i-1 anteriores Cuando el conjunto de estados de 1 elemento tiene una intersección, el elemento i solo puede actualizar el estado cuando conecta una línea con el segundo grupo Para el estado binario del primer elemento i, definitivamente es un desperdicio conectar el elemento actual, pero solo se ha incluido una parte del caso 1 que no tiene intersección, por lo que para evitar que el elemento i-ésimo actual sea desconectado, enumerar de nuevo Conecte solo una línea a la vez para evitar que el elemento actual se caiga
código:
class Solution {
public:
int connectTwoGroups(vector<vector<int>> &cost) {
int m = cost[0].size(), f[1 << m];
f[0] = 0;
for (int j = 0; j < m; j++) {
int mn = INT_MAX;
for (auto &c: cost)
mn = min(mn, c[j]);
int bit = 1 << j;
for (int mask = 0; mask < bit; mask++)
f[bit | mask] = f[mask] + mn;
}
for (auto &row: cost) {
for (int j = (1 << m) - 1; j >= 0; j--) {
int res = INT_MAX;
for (int k = 0; k < m; k++)
res = min(res, f[j & ~(1 << k)] + row[k]);
f[j] = res;
}
}
return f[(1 << m) - 1];
}
};