Subset Sum OIA

#include <iostream>
#include <vector>

#define INF (1 << 29)

using namespace std;

int SubsetSum(vector <int> valoresSet, int maxValor)
{
    vector <vector <bool> > T(valoresSet.size()+1, vector <bool> (maxValor+1, false));

    T[0][0] = true; ///Porque el valor 0 lo podemos usar sin usar elementos

    for(int i=1; i<=valoresSet.size(); i++)
    {
        for(int j=0; j<=maxValor; j++)
        {
            if(j < valoresSet[i-1]) ///A las celdas menores que el valor
                T[i][j] = T[i-1][j]; ///Tomo la respuesta de arriba
            else
                T[i][j] = T[i-1][j-valoresSet[i-1]] or T[i-1][j];
            /**
            En la línea que está arriba de este comentario,
            lo que pregunto es: Puedo formar el valor j
            usando la moneda, o sin usarla? Si es posible
            de alguna de las dos formas, entonces la respuesta
            es true, porque al menos hay una forma de componer ese valor
            **/
        }
    }

    /**
    Una vez que calculamos todo, tenemos que verificar si hay respuesta.
    Es posible que algunos valores no se puedan formar.
    Por ejemplo, en este caso no puedo armar el valor 1000.
    En caso de no poder armarse, devuelvo false y listo
    **/

    if(T[valoresSet.size()][maxValor] == false)
        return false;

    /**
    Si llegué hasta acá es porque hay un set cuya suma es maxValor.
    Ahora hago el backtracking para saber qué valores utilicé
    La idea es empezar de la celda que está mas abajo a la derecha, esa
    es nuestra celda actual.
    Si la celda de arriba también, entonces subo una posición
    Si la celda de arriba es false, entonces
    tengo que subir una posición y además moverme valoresSet[i-1]
    posiciones para la izquierda. En este caso, valoresSet[i-1] es
    parte de la respuesta. Repetir hasta llegar a i = 0
    **/

    int i = valoresSet.size();
    int j = maxValor;

    cout << "Los elementos que suman " << maxValor << " son: ";
    while(i)///O sea, mientras i > 0
    {
        if(T[i-1][j] == false)
        {
            j -= valoresSet[i-1];
            cout << valoresSet[i-1] << " + ";
        }
        i--; ///Al fin y al cabo, siempre me termino moviendo para arriba
    }
    cout << endl;

    return T[valoresSet.size()][maxValor]; ///La última celda tiene la respuesta
}

int main()
{
    cout << SubsetSum({7, 2, 3, 6}, 13) << endl;
    return 0;
}