Cómo encontrar la suma mínima entre un conjunto de n elementos mayor que una clave dada

Aquí hay una solución que se ejecuta en O (2 ^ N)

función minimalSum (arr, k) {

let minSoFar = Number.MAX_SAFE_INTEGER,
hasSolution = false

const f = (índice, suma) => {
if (index> = arr.length) {
regreso
}

const currentVal = sum + arr [índice]

const withVal = currentVal,
sin valor = suma

if (withVal k) {
minSoFar = withVal
hasSolution = true
}

if (sin Val k) {
minSoFar = sin valor
hasSolution = true
}

f (índice + 1, conVal)
f (índice + 1, sin Val)
}

f (0, 0)

volver hasSolution? minSoFar: -1
}

console.log (minimalSum ([1, 2, 5, 3, 4, 1], 7))

La idea es cada paso en el camino, puede elegir incluir arr [i] o no incluirlo.

También es posible resolver esto con programación dinámica, aunque todavía no he podido reconocer una relación de recurrencia.

Este problema es una variante del problema de la mochila.

Para resolver el problema de la mochila, solía aplicar un enfoque de arriba hacia abajo, porque solo prueba los estados requeridos.

int dp (int id, int value)
{
if (valor> clave)
valor de retorno;
si (id == n)
volver (1 << 30);
if (memo [id] [value]! = -1)
volver memo [id] [valor];
retorno memo [id] [valor] = min (dp (id + 1, valor), dp (id + 1, elemento [id] + valor));
}

Para iniciar dp, dp (0, 0);

Hay muchos otros enfoques, pero creo que es el más fácil de entender.