El camino tiene obstáculos y es largo, y la línea se acerca. Mantén la cabeza baja y trabaja duro, si no hablas, ¡serás un éxito de taquilla! ¡Vamos, Sao Nian!
1 introducción al tema
Enlace del título original: 1480. Suma dinámica de una matriz unidimensional
Consulte el enlace anterior para el tema, y una breve descripción es la siguiente:
Te da una variedad de números. La fórmula de cálculo de la "suma dinámica" de la matriz es: runningSum [i] = sum (nums [0]… nums [i]).
Devuelve la suma dinámica de nums.
El ejemplo de pregunta 1 es el siguiente:
输入：nums = [1,2,3,4]
输出：[1,3,6,10]
解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。
La pregunta de muestra 2 es la siguiente:
输入：nums = [1,1,1,1,1]
输出：[1,2,3,4,5]
解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
El tema de muestra 3 es el siguiente:
输入：nums = [3,1,2,10,1]
输出：[3,4,6,16,17]
Está implementado en C ++, y el marco básico que da el título es el siguiente:
class Solution {
public:
vector<int> runningSum(vector<int>& nums) {
}
};
2 análisis de temas
Primero, leí el título varias veces con cuidado, luego miré los ejemplos que se dan a continuación y descubrí que los datos n-ésimo son iguales a los datos (n-1) + n-ésimo. Haré una tabla para que sea más fácil de entender
| subíndice nums | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| datos brutos | 1 | 2 | 3 | 4 |
| proceso de cálculo | 1 | 1 + 2 | 1 + 2 + 3 | 1 + 2 + 3 + 4 |
| Resultados del cálculo | 1 | 3 | 6 | 10 |
Puede verse en la tabla anterior que el resultado del cálculo de n es igual a (n-1) más el valor de n, como 3 = 1 + 2; 6 = 3 + 3; 10 = 6 + 4;
3 Empiece a solucionar el problema
3.1 Primer intento
Codifique primero, luego analice
class Solution {
public:
vector<int> runningSum(vector<int>& nums) {
int temp;
vector<int> vArray;
vArray.push_back(nums.at(0));
temp = nums.at(0);
for(size_t i = 1; i < nums.size(); i++){
temp += nums.at(i);
vArray.push_back(temp);
}
return vArray;
}
};
Primero, definí una variable temp de tipo int, que se usa como tránsito, luego definí un contenedor vArray de tipo int, que se usa como valor de retorno;
El siguiente paso es insertar primero el primer elemento de la matriz en vArray, y luego usar un bucle for para encontrar la suma de n-1 yn bits, luego ponerlo en temp y luego presionar temp en vArray;
Una vez finalizado el ciclo for, vuelva al contenedor vArray directamente;
Después de probar, este método es muy torpe, pero también se da cuenta de la función. El tiempo y el
consumo de memoria son los siguientes: la memoria es un poco grande, pero la eficiencia no es mala ...
3.2 Segundo intento
Este intento es comprender sus ideas después de leer las soluciones a los problemas de todos y luego ejecutar la práctica nuevamente, esta vez el código es el siguiente
class Solution {
public:
vector<int> runningSum(vector<int>& nums) {
for(size_t i = 1; i < nums.size(); i++){
nums[i] += nums[i - 1];
}
return nums;
}
};
En esta modificación, se utilizan todas las variables existentes en lugar de las nuevas variables locales, lo que puede ahorrar espacio Entonces, para el tipo de variables en el ciclo for, sigo usando size_t;
Esta vez, el código parece conciso y fácil de entender. Por ejemplo, en este código central, las siguientes dos líneas son equivalentes, pero explican nuestras ideas de análisis anteriores. La enésima es igual a la enésima más la enésima -1 persona;
nums[i] += nums[i - 1];
nums[i] = nums[i] + nums[i - 1];
El resultado es obvio, el espacio de memoria ocupado este tiempo es pequeño, pero hay otro problema, el tiempo es largo, como se muestra en la figura siguiente, es directamente de 8ms
Después de pensar y pensar, solo hay una diferencia con la solución de referencia, es decir, el tipo de variable es diferente. Definí el tipo size_t y el código original usa el tipo int, así que tengo un tercer intento. Esta vez es completamente igual que el código de referencia. Consistente.
3.3 Tercer intento
El código para este intento es diferente al de la segunda vez, solo el tipo de variable, el código específico es el siguiente:
class Solution {
public:
vector<int> runningSum(vector<int>& nums) {
for(int i = 1; i < nums.size(); i++){
nums[i] += nums[i - 1];
}
return nums;
}
};
No explicaré demasiado, simplemente ejecute los resultados directamente, como se muestra a continuación
, el resultado de este tiempo es un valor medio, la memoria no es tan grande y el tiempo de ejecución también es rápido.
La suposición es que la razón debería ser la matriz. Los tipos de valor de retorno son todos tipos int. Yo uso un tipo size_t para recuperar los datos, y habrá operaciones que llevarán mucho tiempo.
3.4 Análisis
¿Por qué hay una diferencia tan grande en una variable? Revisé y encontré algunos resultados, pero no tan detallados, como sigue:
El segundo es un poco más claro, es decir, int se fija en 4 bytes, pero size_t se determina de acuerdo con el sistema operativo de la máquina, etc. Esta es la razón de la sensación de que consume mucho tiempo, y las razones más profundas deben estudiarse más a fondo.
4 resumen
- Hace mucho tiempo que un senior me recomendó LeetCode (LeetCode), pero lo intenté en ese momento y descubrí que no podía hacer nada. Era demasiado vergonzoso, estaba demasiado despeinado;
- Está aquí de nuevo, tengo unos conocimientos básicos para superarme, si no lo conozco comprobaré la información.
- Siento que esto es muy divertido, también compré Sudoku yo mismo, no tengo nada que hacer, ejercito mi cerebro y mi propio pensamiento para mantenerme vivo;
- Bueno, se acabó, nos vemos la próxima ~, que tengas un buen fin de semana, ¡te deseo todo lo mejor!
Si el contenido del artículo es incorrecto, comente / envíe un mensaje privado con muchos consejos, ¡gracias! Si crees que el contenido del artículo no es malo, recuerda hacer clic en tres enlaces (como, marcar como favorito, dejar un mensaje), tu apoyo es mi mayor aliento, ¡gracias!