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 $a_{i}$. Gesucht wird eine Untermenge $A_{1}\subset A$, so dass

$E:=\left|\sum _{a_{i}\in A_{1}}a_{i}-\sum _{a_{i}\in A\setminus A_{1}}a_{i}\right|$

minimal wird. Eine Aufteilung, für die $E=0$ 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 ${\mathcal {NP}}$-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 $2^{N-1}$ 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 $S$ die Summe der $N$ gegebenen Zahlen. Falls sie ungerade ist, existiert offensichtlich keine perfekte Aufteilung. Andernfalls wird für alle $0\leq i\leq N$ und alle $0\leq j\leq S/2$ geprüft, ob es eine Auswahl von Zahlen in der Familie $\{a_{1},a_{2},...,a_{i}\}$ der ersten $i$ Zahlen gibt, deren Summe genau $j$ ergibt. Für $i=0$ und $j=0$ ist dies offenbar der Fall, genauso für $i=1$ und $j=a_{1}$. Für $i>1$ und alle anderen $j$ 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 $(i,j)$ existiert genau dann, wenn entweder bereits eine für $(i-1,j)$ existiert, oder wenn $j>a_{i}$ ist und eine Auswahl für $(i-1,j-a_{i})$ existiert. Die Antwort auf das Entscheidungsproblem gibt der letzte Eintrag in der Tabelle (für $i=N$ und $j=S/2$) an.

Die Komplexität dieses Algorithmus ist ${\mathcal {O}}(N\cdot S)$.

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

Karps 21 NP-vollständige Probleme

Erfüllbarkeitsproblem der Aussagenlogik | Cliquenproblem | Mengenpackungsproblem | Knotenüberdeckungsproblem | Mengenüberdeckungsproblem | Feedback Arc Set | Feedback Vertex Set | Hamiltonkreisproblem | Integer Linear Programming | 3-SAT | graph coloring problem | Covering by cliques | Problem der exakten Überdeckung | 3-dimensional matching | Steinerbaumproblem | Hitting set | Rucksackproblem | Job sequencing | Partitionsproblem | Maximaler Schnitt