Partitionsproblem
Das Partitionsproblem (auch Zahlenaufteilungsproblem, oft mit PARTITION notiert) ist ein Optimierungs- bzw. Entscheidungsproblem der Kombinatorik.

Formulierung des Partitionsproblems 

Die Aufgabenstellung beim Partitionsproblem lautet: Gegeben sei eine (Multi-)Menge von natürlichen Zahlen. Gesucht wird eine Aufteilung dieser Zahlen auf zwei Haufen, so dass die Differenz der Summen der Zahlen in den beiden Haufen möglichst klein ist.

Eine äquivalente Formulierung lautet präziser: Gegeben sei eine (Multi-)Menge A von N natürlichen Zahlen . Gesucht wird eine Untermenge , so dass

minimal wird. Eine Aufteilung, für die  ist, heißt perfekte Aufteilung.

Als zusätzliche Bedingung kann man die Lösungsmenge des Partitionsproblems von vornherein einschränken, indem man nur ausgewogene Aufteilungen zulässt, in denen beide Haufen gleich groß sind, das heißt, die Anzahl der Zahlen in den Untermengen muss für gerades N gleich sein und muss sich für ungerades N um 1 unterscheiden. Auch in diesem Fall ist das Partitionsproblem -vollständig.

Wandelt man die Fragestellung ab und fragt, „Gibt es eine perfekte Aufteilung?“, so wird das oben beschriebene Optimierungsproblem zu einem Entscheidungsproblem. Dabei sucht man nicht mehr nach der besten Aufteilung, sondern fragt nur noch nach deren Existenz.

Das Partitionsproblem gehört zu den 21 klassischen NP-vollständigen Problemen, von denen Richard M. Karp 1972 die Zugehörigkeit zur Klasse der NP-vollständigen Probleme zeigen konnte.

Phasenübergang im Partitionsproblem 

Man beobachtet beim Partitionsproblem zwei verschiedene sogenannte Phasen: Besteht die Menge A aus vielen kleinen Zahlen, so ist anschaulich klar, dass es viele perfekte Aufteilungen gibt, und es einfach ist, eine dieser Aufteilungen zu finden (einfache Phase). Besteht A hingegen aus wenigen großen Zahlen, so ist es unwahrscheinlich, dass überhaupt eine perfekte Aufteilung existiert, und man muss alle Möglichkeiten durchprobieren, um die beste Aufteilung zu finden (harte Phase).

Zwischen der einfachen und der harten Phase beobachtet man einen Übergang, den man in Analogie zur statistischen Physik Phasenübergang nennt. An diesem Phasenübergang fällt die Wahrscheinlichkeit, eine perfekte Aufteilung zu finden, sprunghaft von 1 in der einfachen Phase auf 0 in der harten Phase. Mit wachsender Anzahl N der Zahlen wird der Übergang immer schärfer.

Die Lage des Phasenübergangs in Abhängigkeit von der Anzahl und der Größe der einzelnen Zahlen lässt sich mit Methoden der statistischen Physik berechnen.

Alle momentan bekannten Algorithmen haben dabei eine „worst-case-Laufzeit“, die exponentiell mit der Anzahl der Zahlen N wächst, das heißt im schlimmsten Fall benötigt er zur Lösung des Entscheidungsproblem eine Rechenzeit, die exponentiell mit N ansteigt. In vielen Fällen liegt die tatsächlich benötigte Rechenzeit jedoch deutlich darunter: In der einfachen Phase stößt der Algorithmus schnell auf eine der vielen perfekten Lösungen und kann das Entscheidungsproblem somit mit „ja, es gibt eine perfekte Lösung“ beantworten und die Suche abbrechen. Auch in der harten Phase können geeignete Algorithmen (z. B. der cBLDM-Algorithmus) die Suche schnell mit einer negativen Entscheidung abschließen, falls keine Lösung existiert. Die „schwierigsten“ Probleme liegen somit direkt am Phasenübergang, wo erst alle  Aufteilungen durchprobiert werden müssen, bevor das Problem entschieden werden kann.

Lösung durch dynamische Programmierung 

Mithilfe der dynamischen Programmierung kann man das Partitionsproblem in pseudopolynomieller Zeit entscheiden.
Hierbei werden systematisch kleinere Teilprobleme betrachtet und ihre Lösungen tabelliert und rekursiv zusammengefügt.

Sei  die Summe der  gegebenen Zahlen. Falls sie ungerade ist, existiert offensichtlich keine perfekte Aufteilung.
Andernfalls wird für alle  und alle  geprüft, ob es eine Auswahl von Zahlen in der Familie  der ersten  Zahlen gibt, deren Summe genau  ergibt. Für   und  ist dies offenbar der Fall, genauso für    und . Für   und alle anderen  dagegen nicht. Dies ist der Anfang der Rekursion, der in der ersten Zeile einer Tabelle notiert wird. Für die weiteren Zeilen ergeben sich die Einträge nach folgender Rekursion: Eine Auswahl für
 existiert genau dann, wenn entweder bereits eine für  existiert, oder wenn   ist und eine Auswahl für  existiert.
Die Antwort auf das Entscheidungsproblem gibt der letzte Eintrag in der Tabelle (für  und ) an.

Die Komplexität dieses Algorithmus ist .

Das folgende Beispiel zeigt eine Implementierung des Algorithmus in der Programmiersprache C++.#include <iostream>
using namespace std;

// Diese Funktion prüft, ob es eine Aufteilung der Menge mit gleichen Summen gibt und gibt dann true zurück, sonst false
bool findPartition(int numbers[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++) // for-Schleife, die die Summe der Zahlen berechnet
    {
        sum += numbers[i];
    }
    if (sum % 2 != 0) // Wenn die Summe ungerade ist, wird false zurückgegeben
    {
        return false;
    }
    bool* part = new bool[sum / 2 + 1]; // Deklariert ein Array, in dem gespeichert wird, ob die Zahlen 0, 1, 2, ... als Summe einer Teilmenge der gegebenen Zahlen dargestellt werden können
    for (int i = 0; i <= sum / 2; i++) // for-Schleife, die das Array initialisiert
    {
        part[i] = false;
    }
    for (int i = 0; i < n; i++) // for-Schleife, die die Indexe der Zahlen durchläuft
    {
        for (int j = sum / 2; j >= numbers[i]; j--) // In dieser for-Schleife wird geprüft, ob Halbe Gesamtsumme - Zahl mit Index i als Summe einer Teilmenge von Zahlen mit Index kleiner als i dargestellt werden kann
        {
            if (part[j - numbers[i]] || j == numbers[i]) // Wenn die Summe j - Zahl mit Index i dargestellt werden kann oder die Zahl mit Index i gleich j ist, wird das Element für die Summe j auf true gesetzt
            {
                part[j] = true;
            }
        }
    }
    return part[sum / 2]; // Gibt das Element für die halbe Gesamtsumme der Zahlen zurück. Dieses Element vom Typ bool gibt an, ob diese Summe dargestellt werden kann.
}

// Hauptfunktion die das Programm ausführt
int main()
{
    int numbers[] = { 1, 3, 3, 2, 3, 2 };
    int n = sizeof(numbers) / sizeof(numbers[0]); // Variable für die Anzahl der Zahlen
    if (findPartition(numbers, n)) // Wenn eine Aufteilung mit gleichen Summen gefunden wurde
    {
        cout << "Es gibt eine Aufteilung mit gleichen Summen." << endl; // Ausgabe auf der Konsole
    }
    else
    {
        cout << "Es gibt keine Aufteilung mit gleichen Summen." << endl; // Ausgabe auf der Konsole
    }
}

Literatur 
	
 Steven S. Skiena: The Algorithm Design Manual. Corrected 2nd printing. Springer u. a., New York NY u. a. 1998, ISBN 0-387-94860-0.

Einzelnachweise 

Komplexitätstheorie