#include <list>

using namespace std;

#define MAX_DEPTH 1000
#define MAX_NUMBER 10000000 // repartido para 8 estados

const static short map[][8] = {
    { 0, 0, 0, 1, 1, 0, 1, 0 },
    { 0, 0, 1, 0, 0, 0, 0, 0 },
    { 0, 1, 0, 0, 1, 0, 1, 0 },
    { 1, 0, 0, 0, 0, 0, 0, 0 },
    { 0, 0, 0, 0, 0, 0, 0, 1 },
    { 0, 1, 0, 1, 0, 0, 1, 0 },
    { 0, 0, 0, 0, 0, 1, 0, 0 },
    { 0, 1, 0, 1, 1, 0, 0, 0 }
};

class T {
public:
    short t; // { Ai = 0, Ad, Bi, Bd, Ci, Cd, Di, Dd = 7 }
    int n;
    T *p; // previo
    T(char _t, int _n, T *_p) { t = _t; n = _n; p = _p; }
};

typedef T *pT;

#define lT list<pT>
#define ilT list<pT>::const_iterator

void main( void ) {

    int maxL = MAX_DEPTH;
    lT *a = new lT[ MAX_DEPTH ];
    bool *c = new bool[ MAX_NUMBER ];
    for(int i = 0; i < MAX_NUMBER; i++)
        c[i] = false;

    a[0].push_back(new T(0, 2011, NULL));

    while(1) {
        int l = -1;
        while(++l < MAX_DEPTH)
            if(a[l].size() > 0)
                break;
        if(l >= MAX_DEPTH)
            break;
        T *t = a[l].back();
        if(t->n == 2012) {
            printf("Solución encontrada:\n");
            while(t) {
                char *f;
                switch(t->t >> 1) {
                case 0: f = "\t%i + 7 = %i\n"; break;
                case 1: f = "\t%i / 2 = %i\n"; break;
                case 2: f = "\t%i * 3 = %i\n"; break;
                case 3: f = "\t%i - 5 = %i\n"; break;
                }
                printf(f, t->p == NULL ? 2011 : t->p->n, t->n);
                t = t->p;
            }
            //break;
            maxL = l;
        }
        a[l++].pop_back();
        if(l <= maxL) {
            for(int i = 0; i < 8; i++ )
                if(map[t->t][i]) {
                    int n;
                    switch(i >> 1) {
                    case 0: n = t->n + 7; break;
                    case 1: n = t->n / 2; break;
                    case 2: n = t->n * 3; break;
                    case 3: n = t->n - 5; break;
                    }
                    int w = n * 8 + i;
                    if(w >= 0 && w < MAX_NUMBER && !c[w]) {
                        a[l].push_back(new T(i, n, t));
                        c[w] = true;
                    }
                }
        }
    }
}