La segunda observación permite reformular el problema de una manera más simple:

Problema partición Enunciado A: dados N enteros positivos, N>1, decir si estos pueden dividirse en dos grupos cuya suma sea la misma. Ejemplo: si el conjunto es {1,2,3,9,2,11,4}, una forma de partirlo en dos grupos con suma igual es {2,3,2} y {11,4,9,1}. Dos observaciones interesantes son: 1. Si la suma de todos los números es impar, el problema no tiene solución 2. Si la suma de todos los números es K, un número par, bastará con saber si hay UN subconjunto cuya suma sea K/2. La segunda observación permite reformular el problema de una manera más simple: Enunciado alternativo: dados N enteros positivos, establecer si de estos se puede sacar un subconjunto cuya suma sea K/2. Este enunciado es más simple porque se trata de encontrar un conjunto y no dos. Para lo que sigue en este documento M es K/2 y el conjunto de enteros positivos es A={k,k 1,k 2,...,k N-1 } Los algoritmos solución se pueden diseñar de varias formas. A continuación de presentan algunas: Solución exhaustiva o de fuerza bruta Básicamente consiste en generar todos los subconjuntos posibles y verificar si alguno de ellos cumple que sus elementos suman M. Se usará una cadena binaria b,b 1,b 2,...,b N-1 para representar cada uno de los subconjuntos de A. La convención de la representación es que si b j es 1, entonces k j está en el subconjunto representado. La siguiente tabla ilustra la biyección entre cadenas binarias de longitud 3 y subconjuntos de A={9,7,2}. Cadena binaria Subconjunto representado 1 {2} 1 {7} 11 {7,2} 1 {9} 11 {9,2} 11 {9,7} 111 {9,7,2} La generación exhaustiva de los subconjuntos de A se reduce a generar todas las cadenas binarias de longitud A. La verificación de uno cualquiera de estos subconjuntos consiste simplemente en establecer si la suma de sus elementos es M. Los algoritmos correspondientes son los siguientes: 1

PROCEDIMIENTO generar(ent_sal elegidos: arreglo [] de entero; ENT N: entero) (* OBJ: calcular el siguiente subconjunto para el problema PARTICIÓN, es decir, la siguiente cadena binaria PRE: elegidos[..n-1] es un vector de ceros y unos. Hay por lo menos un cero POS: elegidos CODIFICA el siguiente subconjunto *) k:entero k N-1; MQ (elegidos[k]=1) haga // recorre la cadena de derecha a izquierda... elegidos[k] // mientras haya unos k k-1 FinMQ elegidos[k] 1; //... una vez encuentra un,lo cambia a 1 FinPROCEDIMIENTO FUNCION verificar(ent cifras: arreglo [] de entero; ENT N,meta: entero; ENT elegidos: arreglo [] de entero):booleano (* OBJ: verificar si el SUBCONJUNTO codificado en elegidos[..n-1] es solución PRE: cifras[k]>, para todo k tal que <=k<n. POS: retorna True, si el SUBCONJUNTO codificado es solución. Retorna False, en otro caso *) suma,i:entero suma i MQ (i<n) haga SI(elegidos[i]=1) suma suma + cifras[i] i i+1 FinMQ Devolver (suma=meta) Ahora, el algoritmo principal que soluciona el problema es el siguiente: FUNCION solex(ent cifras: arreglo [] de entero; ENT N,meta: entero; ENT_SAL elegidos: arreglo [] de entero):booleano (* OBJ: obtener la solución del problema PARTICION por método exhaustivo PRE: cifras[k]>, para todo todo k tal que <=k<n. POS: retorna True, si encuentra una solución. Retorna False en otro caso *) cont, posibles: entero exito: booleano elegidos //inicializa el vector elegidos en cero. exito False cont 1 posibles 2 N MQ ( exito cont<posibles) generar(elegidos,n) exito verificar(cifras,n,meta,elegidos) cont cont+1 FinMQ Devolver exito Note que, en caso de haber solución, este algoritmo deja en elegidos[..n-1] la codificación de una partición apropiada. 2

Solución recursiva (divide y vencerás) Básicamente consiste en expresar la solución del problema original como una combinación de las soluciones de algunos problemas más pequeños, de la misma naturaleza del original. El problema original habla de saber si hay un subconjunto de A={k,k 1, k 2,...,k N-1 } que sume un número objetivo M. La búsqueda de la solución se puede pensar como una secuencia de decisiones D D 1...D N-1, tal que en la decisión D j se resuelve si el número k j se incluye o no en el subconjunto buscado. La siguiente figura muestra cómo cambiarían las dos variables del problema después de tomar la decisión D. {k,k 1, k 2,...,k N-1 }, M k va en la solución k no va en la solución {k 1, k 2,...,k N-1 }, M-k {k 1, k 2,...,k N-1 }, M El rectángulo de la parte superior de la figura muestra las variables del problema en su estado inicial: el conjunto de elementos sobre los cuales no se ha tomado ninguna decisión y el número objetivo inicial, M. Los dos rectángulos de la parte inferior muestran lo que puede suceder después de tomar decisión sobre k. En el rectángulo de la izquierda están las variables del problema después de resolver que k está en el conjunto solución. En el rectángulo de la derecha están las variables del problema después de resolver que k no está en el conjunto solución. Note que CUALQUIER solución potencial incluye a k en el subconjunto o no lo incluye. (no existen otras opciones para k.) Los tres rectángulos muestran estados del mismo problema. Además, los dos de la parte inferior representan instancias más pequeñas porque el conjunto de números es más pequeño y/o el número objetivo es menor. Observe que si se resuelven los dos problemas que pueden resultar de tomar la decisión D, sería fácil usar estas dos soluciones para dar respuesta al problema original: bastaría calcular la disyunción de las soluciones obtenidas. Ahora, las dos soluciones necesarias se pueden obtener recursivamente dado que los dos subproblemas son de la misma naturaleza del original, es decir son versiones o instancias más pequeñas del original Si se establece que partir(a,s) expresa si hay o no un subconjunto de A cuya suma es S, la siguiente definición recursiva formaliza la discusión anterior partir({k,k 1, k 2,...,k N-1 },M) partir({k 1,k 2,...,k N-1 },M-k ) partir({k 1,k 2,...,k N-1 },M) 3

Enseguida se da la definición recursiva completa, incluidos los casos de base de la recursión. Además, esta se refiere a una decisión cualquiera D j ( j<n), y el conjunto se reemplaza por el índice del elemento sobre el cual se toma decisión. partir(j,s) expresa si hay o no un subconjunto de {k j,k j+1,...,k N-1 } cuya suma es S partir(j,s) False si j=n [caso en el que el conjunto queda vacío] partir(j,s) True si j<n y S= [caso en el que el número objetivo es ] partir(j,s) partir(j+1,s) si j<n y k j >S partir(j,s) partir(j+1,s-k j ) partir(j+1,s) si j<n y k j <S La anterior definición se traduce de manera directa en un algoritmo recursivo. FUNCION partir(ent cifras: arreglo [] de entero; ENT j,n,meta: entero; ENT_SAL elegidos: arreglo [] de entero): booleano (* OBJ: obtener la solución del problema PARTICION por método recursivo PRE: <=j<=n. cifras[k]>, para todo <=k<n. meta>=. POS: retorna True si hay solución. Retorna False en otro caso. Si hay solución, elegidos[..n-1] CODIFICA un subconjunto solución mediante una cadena binaria *) temp: booleano SI(j=N) (* no hay más números en el conjunto *) Devolver False SI (meta=) Devolver True SI (cifras[j]>meta) (* el número sobre el cual se está decidiendo es mayor que el objetivo *) Devolver partir(cifras,j+1,n,meta,elegidos) elegidos[j] 1 (* registra que el número cifras[j] va en el subconjunto solución *) temp partir(cifras,j+1,n,meta-cifras[j],elegidos) SI (temp) Devolver True elegidos[j] (* registra que el número cifras[j] no va en el subconjunto solución *) Devolver partir(cifras,j+1,n,meta,elegidos) Note que, en caso de haber solución, este algoritmo deja en elegidos[..n-1] la codificación de una partición apropiada. POR HACER: i) estimar la complejidad temporal de este algoritmo y compararlo contra la del algoritmo exhaustivo, y ii) verificar si este algoritmo repite o hace cálculos innecesarios. Solución de programación dinámica Básicamente consiste en diseñar un proceso iterativo que calcule la ecuación recursiva obtenida, y lo haga de una manera más rápida. La ecuación en cuestión es: partir(j,s) expresa si hay o no un subconjunto de {k j,k j+1,...,k N-1 } cuya suma es S 4

partir(j,s) False si j=n partir(j,s) True si j<n y S= partir(j,s) partir(j+1,s) si j<n y k j >S partir(j,s) partir(j+1,s-k j ) partir(j+1,s) si j<n y k j <S Normalmente, la técnica de programación dinámica requiere la definición de estructuras de datos adicionales que sirvan para almacenar algunos resultados intermedios con el objeto de evitar que se repitan cálculos o que se hagan algunos innecesarios. Recuerde que el problema se trata de saber si hay un subconjunto de A={k,k 1, k 2,...,k N-1 } cuyos elementos sumen un número objetivo M. Lo primero que se recomienda, para obtener una solución de programación dinámica es hacer el diagrama de necesidades (o invariante) para la recurrencia partir(j,s): M S S-k j j j+1 N En este caso, el plano cartesiano ilustra que el valor de la función booleana (recurrente) partir en (j,s) se puede calcular fácilmente si se tiene calculada la recurrencia en los puntos (j+1,s) y (j+1,s-k j ). Dicho de otra forma, para calcularla en el punto (j,s) se necesita o se requiere tenerla calculada en los puntos (j+1,s) y (j+1,s-k j ). Ahora, si los cálculos se guardan en una gran matriz de dimensión (M+1)x(N+1), de tipo booleano, entonces esta debería llenarse de derecha a izquierda y de abajo hacia arriba, como se ilustra enseguida, con excepción de la primera fila y la última columna: M S S-k j 1 1 1 1 1 1 1 1 1 1 1 1 j j+1 N 5

Si se sigue el orden de cálculo mencionado, en el momento en que se quiere calcular el valor de la celda (S,j) de la matriz (marcada con líneas horizontales) ya estarán calculadas las celdas necesarias (casillas rayadas diagonalmente), también estarán calculadas todas las casillas sombreadas, y faltarán por calcular las casillas blancas. El resultado estará en la casilla (M,), dado que allí estará el valor de partir(,m) que, según la definición, dice si hay o no un subconjunto de {k,k 1,...,k N-1 } cuya suma es M. El siguiente algoritmo define la matriz y la llena en el orden establecido arriba. FUNCION solprogdin(ent cifras: arreglo [] de entero; ENT N,M: entero): booleano (* OBJ: obtener la solucion del problema PARTICION por programación dinámica PRE: cifras[k]>, para todo k>= y k<n. N<MAX y M<MAX POS: retorna True, si encuentra una solución. retorna False en otro caso *) mat: matriz[max][max] de booleano s,j: entero PARA s HASTA M HACER mat[s][n] False PARA j HASTA N HACER mat[][j] True PARA(j N-1 HASTA HACER PARA s 1 HASTA M HACER SI (cifras[j]>s) mat[s][j] mat[s][j+1] SI (cifras[j] s) mat[s][j] mat[s][j+1] mat[s-cifras[j]][j+1] Devolver mat[m][] POR HACER: i) estimar la complejidad temporal de este algoritmo y compararlo contra la del algoritmo exhaustivo y la del algoritmo recursivo, ii) El anterior algoritmo es mejorable en espacio: se puede usar un par de vectores de tamaño M+1, en vez de una matriz, y iii) rehaga este algoritmo para que, durante el llenado de la matriz, también se vaya haciendo el registro de una solución (arreglo elegidos) 6