import { JavaObject } from '../../java/lang/JavaObject';
import { Random } from '../../java/util/Random';
import { Class } from '../../java/lang/Class';
export declare class KursblockungMatrix extends JavaObject {
    /**
     * Ein {@link Random}-Objekt zur Steuerung des Zufalls über einen Anfangs-Seed.
     */
    private readonly _random;
    /**
     * Die Werte der Matrix [Zeile][Spalte].
     */
    private readonly matrix;
    /**
     * Die Anzahl der Zeilen der Matrix.
     */
    private readonly rows;
    /**
     * Die Anzahl der Spalten der Matrix.
     */
    private readonly cols;
    /**
     * Die aktuelle Permutation der Zeilen für potentiellen Nichtdeterminismus. Interne Algorithmen iterieren so über
     *  die Matrix-Zeilen in zufälliger Reihenfolge, damit aus mehreren optimalen Lösungen eine zufällige ausgewählt
     *  wird. Die echten Zeilen der Matrix bleiben unverändert.
     */
    private readonly permR;
    /**
     * Die aktuelle Permutation der Spalten für potentiellen Nichtdeterminismus. Interne Algorithmen iterieren so über
     *  die Matrix-Spalten in zufälliger Reihenfolge, damit aus mehreren optimalen Lösungen eine zufällige ausgewählt
     *  wird. Die echten Spalten der Matrix bleiben unverändert.
     */
    private readonly permC;
    /**
     * Die Zuordnung einer Zeile zu einer Spalte (für das bipartite Matching).
     */
    private readonly r2c;
    /**
     * Die Zuordnung einer Spalte zu einer Zeile (für das bipartite Matching).
     */
    private readonly c2r;
    /**
     * Definiert, ob eine linker Zeilen-Knoten bereits besucht wurde (für das bipartite Matching).
     */
    private readonly besuchtR;
    /**
     * Definiert, ob eine rechter Spalten-Knoten bereits besucht wurde (für das bipartite Matching).
     */
    private readonly abgearbeitetC;
    /**
     * Definiert, den Zeilen-Vorgänger-Knoten eines rechten Spalten-Knotens (für das bipartite Matching).
     */
    private readonly vorgaengerCzuR;
    /**
     * Definiert eine Warteschlange mit maximal <i>rows</i> Knoten (für das bipartite Matching).
     */
    private readonly queueR;
    /**
     * Definiert ein linkes Knotengewicht (Potential) zur Umgewichtung der ausgehenden Kanten (für das bipartite
     *  Matching).
     */
    private readonly potentialR;
    /**
     * Definiert ein rechtes Knotengewicht (Potential) zur Umgewichtung der eingehenden Kanten (für das bipartite
     *  Matching).
     */
    private readonly potentialC;
    /**
     * Definiert die Entfernung vom aktuellen Zeilen-Knoten zu den jeweiligen Spalten-Knoten (für das bipartite
     *  Matching).
     */
    private readonly distanzC;
    /**
     *Erzeugt eine neue Matrix mit {@code rows} Zeilen und {@code cols} Spalten.
     *
     * @param pRandom Ein {@link Random}-Objekt zur Steuerung des Zufalls über einen Anfangs-Seed.
     * @param rows    Die Anzahl der Zeilen der Matrix.
     * @param cols    Die Anzahl der Spalten der Matrix.
     */
    constructor(pRandom: Random, rows: number, cols: number);
    /**
     * Berechnet zur aktuellen Matrix ein maximales bipartites Matching. Die Methode geht davon aus, dass in der Matrix
     * ausschließlich die Werte 0 und 1 vorkommen. Werte ungleich 0 werden andernfalls als 1 (eine Kante im Graphen)
     * interpretiert. Nichtquadratische Matrizen sind erlaubt. Das Ergebnis der Methode ist eine größtmögliche Zeilen-
     * zu Spaltenzuordnung. Der Algorithmus hat eine Laufzeit von O(n³).
     *
     * @param  nichtdeterministisch definiert, ob das Ergebnis zufällig sein soll, falls es mehrere optimale Lösungen
     *                              gibt.
     * @return                      die Zeilen- zu Spaltenzuordnung, negative Werte entsprechen einer Nichtzuordnung.
     */
    gibMaximalesBipartitesMatching(nichtdeterministisch: boolean): Array<number>;
    /**
     *Berechnet zur aktuellen Matrix ein minimales gewichtetes Matching. Die Methode geht davon aus, dass in der
     * Matrix ganzzahlige Werte vorkommen, d.h. es existiert eine Kante von jedem linken Knoten zu jedem rechten Knoten.
     * Negative Werte und nichtquadratische Matrizen sind erlaubt. Zur Berechnung eines maximalen Matching kann man
     * vorher alle Zellenwerte negieren. Das Ergebnis der Methode ist eine Zeilen- zu Spaltenzuordnung, deren Summe
     * minimal ist. Der Algorithmus verwendet mehrere Runden eines SSSP-Algorithmus (Dijkstra). Damit dies bei negativen
     * Werten funktioniert, werden die Kanten mit Hilfe von Knoten-Potentialen umgewichtet. Der Algorithmus hat eine
     * Laufzeit von O(n³).
     *
     * @see                         <a href= "https://en.wikipedia.org/wiki/Shortest_path_problem">Wikipedia -
     *                              Shortest_path_problem</a>
     * @see                         <a href= "https://en.wikipedia.org/wiki/Johnson%27s_algorithm">Wikipedia - Johnsons
     *                              Algorithm</a>
     * @param  nichtdeterministisch definiert, ob das Ergebnis zufällig sein soll, falls es mehrere optimale Lösungen
     *                              gibt.
     * @return                      die Zeilen- zu Spaltenzuordnung, negative Werte entsprechen einer Nichtzuordnung.
     */
    gibMinimalesBipartitesMatchingGewichtet(nichtdeterministisch: boolean): Array<number>;
    /**
     *Interne Methode zum Permutieren oder Initialisieren der Arrays {@link KursblockungMatrix#permR} und
     * {@link KursblockungMatrix#permC}.
     *
     * @param nichtdeterministisch falls {@code true} werden {@link KursblockungMatrix#permR} und
     *                             {@link KursblockungMatrix#permC} permutiert, sonst initialisiert.
     */
    private initialisierPermRundPermC;
    /**
     *Interne Methode zum Initialisieren eines Arrays so, dass das Array mit den Zahlen {@code 0,1,2...} gefüllt wird.
     *
     * @param perm Das Array, welches mit den Zahlen {@code 0,1,2...} gefüllt wird.
     */
    private static initialisiere;
    /**
     *Interne Methode zum zufälligen Permutieren eines Arrays.
     *
     * @param perm Das Array, dessen Inhalt zufällig permutiert wird.
     */
    private permutiere;
    /**
     *Erlaubt Zugriff auf den Inhalt des Arrays.
     *
     * @return Die Array-Referenz.
     */
    getMatrix(): Array<Array<number>>;
    /**
     *Erzeugt String-Ausgabe des Arrays sowie der Zeilen-zu-Spalten-Zuordnung {@link KursblockungMatrix#r2c}. Diese
     * Methode ist für Debug-Zwecke gedacht.
     *
     * @param  kommentar          Ein Kommentar der über der Matrix angezeigt wird.
     * @param  zellenbreite       Die Breite bei der Ausgabe der Zelle.
     * @param  mitKnotenPotential Falls {@code true}, werden die Kantenwerte umgewichtet entsprechenden der
     *                            Knotenpotentiale, andernfalls bleiben die Kantenwerte unverändert.
     * @return                    Eine String-Representation der Matrix.
     */
    convertToString(kommentar: string, zellenbreite: number, mitKnotenPotential: boolean): string;
    /**
     * Füllt die Matrix mit ganzzahligen zufälligen Zahlenwerten aus dem Intervall {@code [von;bis]}.
     *
     * @param von Der kleinstmögliche zufällige Wert (inklusive).
     * @param bis Der größtmögliche zufällige Wert (inklusive).
     */
    fuelleMitZufallszahlenVonBis(von: number, bis: number): void;
    /**
     * Füllt die Matrix mit dem übergebenen Wert.
     *
     * @param wert  Der Wert, der alle Zellen überschreibt.
     */
    fuelleMitWert(wert: number): void;
    /**
     *Liefert die Anzahl an Zeilen der Matrix.
     *
     * @return die Anzahl an Zeilen der Matrix.
     */
    gibZeilen(): number;
    /**
     *Liefert die Anzahl an Spalten der Matrix.
     *
     * @return die Anzahl an Spalten der Matrix.
     */
    gibSpalten(): number;
    transpilerCanonicalName(): string;
    isTranspiledInstanceOf(name: string): boolean;
    static class: Class<KursblockungMatrix>;
}
export declare function cast_de_svws_nrw_core_kursblockung_KursblockungMatrix(obj: unknown): KursblockungMatrix;
//# sourceMappingURL=KursblockungMatrix.d.ts.map