Directorio de artículos
Pregunta de entrevista 08.01 Pregunta de tres pasos
Haga clic para ver: pregunta de tres pasos
Pregunta de tres pasos. Un niño sube las escaleras. Las escaleras tienen n escalones. El niño puede subir 1 escalón, 2 escalones o 3 escalones a la vez. Implemente un método que cuente de cuántas maneras el niño puede subir las escaleras. El resultado puede ser muy grande, necesita módulo 1000000007 en el resultado.
Ejemplo 1:
Entrada: n = 3
Salida: 4
Explicación: Hay cuatro formas de moverse
Ejemplo 2:
Entrada: n = 5
Salida: 13
análisis de tema
Cuando n==1,
solo puede ir de 0 a 1, es decir, 0->1, por lo que solo hay un método
Cuando n==2
, puede ir de 0->2, hay una forma
de ir de 1->2, y solo hay una forma de 0 a 1, y solo se necesita un paso de 1 a 2, entonces hay dos formas de
finalmente 1+ 1, hay 2 métodos
Cuando n==3,
hay 1 método de 0->3
de 1->3, porque solo hay 1 método de 0->1, y solo se necesita un paso de 1 a 3, por lo que hay 1 método
de 2->3, porque 0->2 tiene 2 métodos, y 2 a 3 solo necesita agregar un paso, por lo que hay 2 métodos, y
finalmente 1+1+2, hay 4 métodos en total
Cuando n==4
, debido a que se toman como máximo 3 pasos a la vez, 0-> 4 no es válido.
De 1-> 4, porque hay 1 método para 0-> 1, y 1 a 4 solo necesita agregar un paso, por lo que hay 1 método
de 2->4, porque 0->2 tiene 2 métodos, y de 2 a 4 solo necesita agregar un paso, por lo que hay 2 métodos
de 3->4, porque 0->3 tiene 3 métodos, y solo de 3 a 4 Necesita agregar un paso, por lo que hay 3 métodos,
finalmente 1+2+3, un total de 7 métodos
ecuación de transición de estado
Terminar en la posición i
dp[i] representa cuántas formas hay para llegar a la posición i
Ecuación de transición de estado
Divide el problema con el estado de la posición i, el último paso
dp[i] se considera en tres casos,
desde la posición i-1 hasta la posición i es dp[i-1]
desde la posición i-2 hasta la posición i es dp[i-2]
desde la posición i-3 hasta la posición i es dp [i-3]
dp[i]= dp[i-1]+dp[i-2]+dp[i-3]
código completo
class Solution {
public:
int waysToStep(int n) {
if(n==1||n==2)
{
return n;
}
if(n==3)
{
return 4;
}
vector<int>dp(n+1);
dp[1]=1;
dp[2]=2;
dp[3]=4;
int i=0;
for(i=4;i<=n;i++)
{
dp[i]=( (dp[i-1]+dp[i-2])%1000000007+dp[i-3])%1000000007;
}
return dp[n];
}
};
Al calcular la ecuación de transición de estado, no puede sumar los tres y luego tomar el módulo, de lo contrario se informará un error.Al
sumar dp[i-1] y dp[i-2], debe tomar el módulo y luego use dp[i-3] y tome el módulo al agregar
746. Sube escaleras con un costo mínimo
Click para ver: Subir escaleras con coste mínimo
Se le da un costo de matriz entera, donde costo[i] es el costo de subir el i-ésimo escalón de las escaleras. Una vez que pague esta tarifa, puede optar por subir un tramo de escaleras o dos.
Puede elegir comenzar a subir las escaleras desde el escalón con el subíndice 0 o el subíndice 1.
Calcule y devuelva el costo mínimo para llegar a la parte superior de las escaleras.
Ejemplo 1:
Entrada: costo = [10,15,20]
Salida: 15
Explicación: Comenzará desde el paso con el subíndice 1.
Paga 15 y sube dos escalones hasta la parte superior de las escaleras.
El costo total es de 15.
análisis de tema
A partir del subíndice 0, puede gastar 10 yuanes en el subíndice 1, o puede ir al subíndice 2,
pero el subíndice 2 no es el techo, porque si es el techo, el costo mínimo debería ser 10, no 15,
por lo que el techo es el penúltimo elemento de la matriz de costos
Comenzando desde la posición con el subíndice 1, puede ir a la posición con el subíndice 2, o puede ir a la parte superior del edificio.
ecuación de transición de estado
dp[i] representa el costo mínimo al alcanzar la posición i
, y el costo mínimo de la posición i se obtiene al combinar el costo mínimo de la posición i-1 y el costo mínimo de la posición i-2
dp[i] se puede dividir en
1. Primero alcance la posición i-1, pague el costo[i-1], dé un paso
dp[i-1] representa el costo mínimo para alcanzar la posición i-1, y cost[i-1] representa el costo requerido para la posición i-1, es
decir dp[i-1]+coste[i-1]
2. Primero alcance la posición i-2, pague el costo[i-2], dé dos pasos
dp[i-2] representa el costo mínimo para alcanzar la posición i-2, cost[i-2] representa el costo requerido para la posición i -2
Es decir, dp[i-2]+coste[i-2]
Ecuación de transferencia dinámica
dp[i]= min(dp[i-1]+coste[i-1],dp[i-2]+coste[i-2]);
código completo
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
vector<int>dp(cost.size()+1,0);
dp[0]=0;
dp[1]=0;
int i=0;
for(i=2;i<cost.size()+1;i++)
{
dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
}
return dp[cost.size()];
}
};
Para la ecuación de transición de estado, no se pueden usar las posiciones con subíndice 0 y subíndice 1, lo que provocará cruce de fronteras.En
la pregunta, puede optar por comenzar a subir escaleras desde la posición 0 o 1, lo que significa que las dos posiciones están libres ,
es decir, dp[0] =0, dp[1]=0
91. Método de decodificación
Haga clic para ver: método de decodificación
Un mensaje que contiene las letras AZ se codifica mediante la siguiente asignación:
'A' -> "1"
'B' -> "2"
'Z' -> "26"
Para decodificar un mensaje codificado, todos los números deben basarse en el método de mapeo anterior, mapeo inverso de vuelta a las letras (puede haber más de un método). Por ejemplo, "11106" se puede asignar como:
"AAJF", agrupando mensajes como (1 1 10 6)
"KJF", agrupando mensajes como (11 10 6)
Tenga en cuenta que los mensajes no se pueden agrupar como (1 11 06) porque " 06" no se puede asignar a "F" porque "6" y "06" no son equivalentes en la asignación.
Dada una cadena no vacía que contiene solo números, cuente y devuelva la cantidad total de métodos de decodificación.
Los datos de la pregunta garantizan que la respuesta debe ser un número entero de 32 bits.
Ejemplo 1:
Entrada: s = "12"
Salida: 2
Explicación: Se puede decodificar como "AB" (1 2) o "L" (12).
Ejemplo 3:
Entrada: s = "06"
Salida: 0
Explicación: "06" no se puede asignar a "F" debido a los ceros iniciales ("6" y "06" no son equivalentes).
análisis de tema
Si se divide en 1 y 2, corresponde respectivamente a A y B.
Si se considera en conjunto, corresponde a L
Si se divide en 0 y 6, entonces 0 no tiene letra correspondiente.
Si se considera como un todo, no se permite que 0 inicial indique
ecuación de transición de estado
dp[i] indica el número total de métodos de decodificación cuando la posición i es el final
Caso 1: Deje que el número en la posición i se decodifique por separado
El número decodificado por separado debe ser del 1 al 9, por lo que habrá éxito/fracaso
Si la decodificación tiene éxito, el número correspondiente a la posición i está entre 1 y 9, lo que equivale a agregar un carácter después de todos los esquemas de decodificación en las posiciones 0 a i-1, y el número total decodificado es el número que termina en la posición i
. -1 Es decir, dp[i-1]
Si la decodificación falla, todos fallan y el número de decodificación es 0,
como: 60 se calcula por separado, 6 es F y 0 no tiene un número correspondiente, por lo que no hay éxito en la decodificación
Caso 2: Deje que el número en la posición i y el número en la posición i-1 se combinen para decodificar
Si la decodificación tiene éxito, el número combinado está entre 10 y 26, lo que equivale a agregar un carácter después de todos los esquemas de decodificación en las posiciones 0 a i-2, y el número de decodificación
general es el número que termina en i-2, que es, dp [i-2]
Si la decodificación falla, todos fallan y el número de decodificación es 0
dp[i]=dp[i-1]+dp[i-2]
dp[i-1] y dp[i-2] solo se agregarán cuando la decodificación sea exitosa, de lo contrario será 0
código completo
class Solution {
public:
int numDecodings(string s) {
vector<int>dp(s.size());
int i=0;
//初始化
if(s[0]!='0')
{
dp[0]=1;
}
else
{
dp[0]=0;
}
//有可能s字符串只有一个数字
if(s.size()==1)
{
return dp[0];
}
if(s[0]!='0'&&s[1]!='0')
{
dp[1]++;
}
//因为s[0]存的是字符，所以选哟减去'0'，从而获取数字
int sum=(s[0]-'0')*10+(s[1]-'0');
if(sum>=10&&sum<=26)
{
dp[1]++;
}
for(i=2;i<s.size();i++)
{
//说明可以单独编码成功
if(s[i]!='0')
{
dp[i]+=dp[i-1];
}
//说明可以结合编码成功
int sum=(s[i-1]-'0')*10+(s[i]-'0');
if(sum>=10&&sum<=26)
{
dp[i]+=dp[i-2];
}
}
return dp[s.size()-1];
}
};
Inicializar
dp[0] significa que solo hay un número.
Si el número está entre 1 y 9, la decodificación es exitosa y se devuelve 1.
Si el número es 0, la decodificación falla y se devuelve 0.
dp[1] significa que dos números
se pueden dividir en dos números que se pueden decodificar por separado y combinar para decodificar
Si la decodificación es exitosa solo, el número de decodificación + 1, de lo contrario es 0,
si la combinación es exitosa, el número de decodificación + 1, de lo contrario es 0,
entonces hay 0 1 2 tres casos