Saltar al contenido

Potencias mínimas de P y Q sobre N. monitor

Mejorar artículo

Guardar artículo

me gusta el articulo

Mejorar artículo

Guardar artículo

entero dado norte y valores pags y q, La tarea es calcular el número mínimo de potencias de P y Q necesarias para generar N.

Observación: el 0mi También se considera la fuerza de los valores.

Ejemplos:

Aporte: N = 15, P = 2, Q = 3
Salida:: 3
Explicación: Podemos hacer 15 usando (8, 4, 3) o (9, 3, 3). Ambos toman 3 números.

Aporte: N = 19, P = 4, Q = 3
Salida:: 2
Explicación: En el segundo caso, podemos hacer 19 usando (16, 3), que son 2 números.

Enfoque: recursividad (memorización)

La idea básica es usar el enfoque de memorización para este problema, simplemente comprobaremos las formas de lograr o generar N considerando las fuerzas P y Q haciendo llamadas recursivas.

Pseudocódigo:

Para comprobar los permisos utilizados en la relación recursiva.

‘largo largo int a=1;
respuesta = 1st9; // para guardar la posible respuesta

si (potencia = 1){
volver n;
}
mientras (después de >= 0)
{
respuesta = min(respuesta, dp[n-a]);
a = a*potencia;
}

respuesta respuesta+1;

Siga los pasos a continuación para implementar la idea:

  • inicializar un doble penetración[] rango de tamaño N+1 e inicialícelo con 1e9.
  • Supongamos, los casos base, doble penetración[0] = 0 y doble penetración[1] = 1.
  • atravesar 2 Hasta que norte y encontrar los caminos con poderes.
    • Way1 considerando el poder de pags.
    • Way2 considerando el poder de q.
  • Considerar doble penetración[i] = min(camino1, camino2).
  • Después de pasar por el regreso doble penetración[N].

A continuación encontrará la implementación del enfoque anterior.

C++

 

#include <bits/stdc++.h>

using namespace std;

 

int check(int n, int power, vector<int>& dp)

{

    

    long long int a = 1;

    int ans = 1e9;

 

    

    if (power == 1)

        return n;

 

    

    while (n - a >= 0) {

        ans = min(ans, dp[n - a]);

        a = a * power;

    }

 

    return ans + 1;

}

 

int moves(int n, int p, int q)

{

    

    vector<int> dp(n + 1, 1e9);

 

    

    dp[0] = 0;

    dp[1] = 1;

 

    for (int i = 2; i <= n; ++i) {

        int way1 = check(i, p, dp);

        int way2 = check(i, q, dp);

        dp[i] = min(way1, way2);

    }

 

    

    return dp[n];

}

 

int main()

{

    int N = 15, P = 2, Q = 1;

 

    

    cout << moves(N, P, Q) << endl;

    return 0;

}

Complejidad del tiempo: O(N * registroN)
cuarto auxiliar: O(N * registroN)

Artículos relacionados: