import { JavaObject } from '../../java/lang/JavaObject';
export declare class KursblockungMatrix extends JavaObject {
    private readonly RND;
    private readonly matrix;
    private readonly rows;
    private readonly cols;
    private readonly permR;
    private readonly permC;
    private readonly r2c;
    private readonly c2r;
    private readonly besuchtR;
    private readonly abgearbeitetC;
    private readonly vorgaengerCzuR;
    private readonly queueR;
    private readonly potentialR;
    private readonly potentialC;
    private readonly distanzC;
    /**
     * Erzeugt eine neue Matrix mit {@code rows} Zeilen und {@code cols} Spalten.
     *
     * @param rows Die Anzahl der Zeilen der Matrix.
     * @param cols Die Anzahl der Spalten der Matrix.
     */
    constructor(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;
    isTranspiledInstanceOf(name: string): boolean;
}
export declare function cast_de_nrw_schule_svws_core_kursblockung_KursblockungMatrix(obj: unknown): KursblockungMatrix;