[cont, posC, posF] compactar(a, izq, der, mitad, m, c)
    int cont = 0;
    int i = mitad;
    int posC = mitad;
    while (i > izq && a[i] == c)
        cont++;
        i--;
    posC = i;
    i = mitad + 1;
    while (i < der && a[i] == c)
        cont++;
        i++;
    if (posC + (m-cont) < der) // Hay espacio por la derecha
        return [cont, posC, posC];
    else if (posC - (m-cont) > izq) // Hay espacio por la izquierda
        nuevaPosF = posC - (m-cont);
        return [cont, posC, nuevaPosF];
    else return [cont, posC, -1] // No hay espacio

[cont, posC, posF] DyV(a, izq, der, m, c)
    if (der == izq) // Caso base --> (n == 1)
        if (a[izq] == c)
            if (m == 1)
                return [1, 1, 1];
            else return [1, 1, -1];
        else return [0, -1, -1];
    else
        mitad = (izq+der)/2;
        solI = DyV(a, izq, mitad, m, c);
        solD = DyV(a, mitad + 1, der, m, c);
        if (a[mitad] == a[mitad + 1] == c) // Hay compartición
            solMitad = compactar(a, izq, der, mitad, m, c);
            return max(solI, solD, solMitad);
        else
            return max(solI, solD);

fin

[cont, posC, posF] max(int solI, int solD, int solMitad)
    if (solI[cont] == solD[cont] == solMitad[cont] == 0)
        return [0, -1, -1];
    if (solI[cont] > solD[cont] && solI[cont] > solMitad[cont]) // La mayor es la de la izquierda
        if (solI[posF] != -1) // Ya se había encontrado la subcadena de la solución
            return [solI[cont], solI[posC], solI[posF]];
        else // No se había encontrado la subcadena de la solución por falta de espacio. Vemos si ahora hay
            if (solI[posC] + (m-posI[cont]) < der) // Hay espacio por la derecha
                return [solI[cont], solI[posC], solI[posC]];
            else if (solI[posC] - (m-solI[cont]) > izq) // Hay espacio por la izquierda
                nuevaPosF = solI[posC] - (m-solI[cont]);
                return [solI[cont], solI[posC], nuevaPosF];
            else return [solI[cont], solI[posC], -1] // No hay espacio
    else if (solD[cont] > solI[cont] && solD[cont] > solMitad[cont]) // La mayor es la de la derecha
        nuevaPosC = solD[posC] + mitad;
        if (solD[posF] != -1)
            nuevaPosF = solD[posF] + mitad;
            return [solD[cont], nuevaPosC, nuevaPosF];
        else
            if (nuevaPosC + (m-posD[cont]) < der)
                return [solD[cont], nuevaPosC, nuevaPosC];
            else if (nuevaPosC - (m-solD[cont]) > izq)
                nuevaPosF = nuevaPosC - (m-solD[cont]);
                return [solD[cont], nuevaPosC, nuevaPosF];
            else return [solD[cont], nuevaPosC, -1];
    else // La mayor es la del medio, pero ya tiene todo calculado
        return [solMitad[cont], solMitad[posC], solMitad[posF]];

[cont, posC, posF] max(int solI, int solD)
    if (solI[cont] == solD[cont] == 0)
        return [0, -1, -1];
    if (solI[cont] > solD[cont] && solI[cont] > solMitad[cont]) // La mayor es la de la izquierda
        if (solI[posF] != -1) // Ya se había encontrado la subcadena de la solución
            return [solI[cont], solI[posC], solI[posF]];
        else // No se había encontrado la subcadena de la solución por falta de espacio. Vemos si ahora hay
            if (solI[posC] + (m-posI[cont]) < der) // Hay espacio por la derecha
                return [solI[cont], solI[posC], solI[posC]];
            else if (solI[posC] - (m-solI[cont]) > izq) // Hay espacio por la izquierda
                nuevaPosF = solI[posC] - (m-solI[cont]);
                return [solI[cont], solI[posC], nuevaPosF];
            else return [solI[cont], solI[posC], -1] // No hay espacio
    else // La mayor es la de la derecha
        nuevaPosC = solD[posC] + mitad;
        if (solD[posF] != -1)
            nuevaPosF = solD[posF] + mitad;
            return [solD[cont], nuevaPosC, nuevaPosF];
        else
            if (nuevaPosC + (m-posD[cont]) < der)
                return [solD[cont], nuevaPosC, nuevaPosC];
            else if (nuevaPosC - (m-solD[cont]) > izq)
                nuevaPosF = nuevaPosC - (m-solD[cont]);
                return [solD[cont], nuevaPosC, nuevaPosF];
            else return [solD[cont], nuevaPosC, -1];