Themenlink: Lituo

Sie haben ein konvexes n Polygon mit einem ganzzahligen Wert für jeden Scheitelpunkt. Gegeben sei ein Array von Ganzzahlen values , wobei der Wert des th-Scheitelpunkts values[i] ist (d. h. im Uhrzeigersinn ).i

Angenommen, das Polygon ist in n - 2 Dreiecke unterteilt. Für jedes Dreieck ist der Wert dieses Dreiecks das Produkt der Scheitelpunktbeschriftungen , und der Triangulationswert ist die n - 2 Summe der Werte aller Dreiecke nach der Triangulation.

Gibt die niedrigstmögliche Punktzahl für ein Polygon nach der Triangulation zurück .

Beispiel 1:

Eingabe: Werte = [1,2,3]
 Ausgabe: 6
 Erklärung: Das Polygon wurde mit einer Punktzahl von 6 für eindeutige Dreiecke trianguliert.

Beispiel 2:

Eingabe: Werte = [3,7,4,5]
 Ausgabe: 144
 Erklärung: Es gibt zwei Triangulationen mit möglichen Punktzahlen: 3*7*5 + 4*5*7 = 245, oder 3*4*5 + 3 *4*7 = 144. Die Mindestpunktzahl beträgt 144.

Beispiel 3:

Eingabe: Werte = [1,3,1,4,1,5]
 Ausgabe: 13
 Erklärung: Der Score-Fall der niedrigsten Score-Triangulation ist 1*1*3 + 1*1*4 + 1*1*5 + 1 * 1 * 1 = 13.

Hinweis:

n == values.length
3 <= n <= 50
1 <= values[i] <= 100

Offizielle Erläuterungen

class Solution {
public:
    int minScoreTriangulation(vector<int>& values) {
        // 记忆化存储已经计算过的子问题的解
        unordered_map<int, int> memo;
        int n = values.size();

        // 定义 dp 函数
        function<int(int, int)> dp = [&](int i, int j) -> int {
            // 三角形的边长小于 3，不需要划分，返回 0
            if (i + 2 > j) {
                return 0;
            }
            // 三角形的边长等于 3，只有一个三角形，返回这个三角形的分数
            if (i + 2 == j) {
                return values[i] * values[i + 1] * values[j];
            }
            // 计算 memo 的 key
            int key = i * n + j;
            // 如果当前子问题的解没有计算过
            if (!memo.count(key)) {
                int minScore = INT_MAX;
                // 枚举划分位置 k，计算每种划分方式的分数，取最小值
                for (int k = i + 1; k < j; k++) {
                    minScore = min(minScore, values[i] * values[k] * values[j] + dp(i, k) + dp(k, j));
                }
                // 存储当前子问题的解
                memo[key] = minScore;
            }
            // 返回当前子问题的解
            return memo[key];
        };
        // 返回最终问题的解
        return dp(0, n - 1);
    }
};

ChatGPT-Fragenerklärungs-Anmerkungsversion

class Solution {
public:
    int minScoreTriangulation(vector<int>& values) {
        int n = values.size();
        // dp[i][j]表示从第i个点到第j个点所需的最小分数
        vector<vector<int>> dp(n, vector<int>(n));
        // 遍历区间长度
        for (int len = 3; len <= n; len++) {
            // 遍历区间起点
            for (int i = 0; i + len - 1 < n; i++) {
                // 区间终点
                int j = i + len - 1;
                // 初始化dp[i][j]
                dp[i][j] = INT_MAX;
                // 遍历区间中间点
                for (int k = i + 1; k < j; k++) {
                    // 求解dp[i][j]
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + values[i] * values[j] * values[k]);
                }
            }
        }
        // dp[0][n-1]即为答案
        return dp[0][n - 1];
    }
};

unordered_map<int, int>

unordered_map<int, int> ist ein assoziativer Container in C++ STL (Standard Template Library), der eine Reihe von Schlüssel-Wert-Paaren einem eindeutigen Wert zuordnen kann. In diesem speziellen Code wird unordered_map<int, int> memo; verwendet, um die berechneten Ergebnisse für die spätere Verwendung zu speichern, um wiederholte Berechnungen zu vermeiden und dadurch die Effizienz des Codes zu verbessern.

Vektor<int>&

vector<int>& stellt eine Referenz dar, die verwendet wird, um eine Variable vom Typ vector<int> als Parameter einer Funktion zu übernehmen, sodass die Variable direkt in der Funktion geändert werden kann, anstatt eine neue Kopie zu erstellen. Durch die Verwendung von Referenzen vermeiden Sie das Kopieren großer Datenmengen in Funktionen und verbessern so die Effizienz Ihres Programms. Gleichzeitig können Referenzen auch verwendet werden, um den Rückgabewert einer Funktion an den Aufrufer zu übergeben.

Funktion<int(int, int)> dp = [&](int i, int j) -> int

Dieser Code verwendet einen Lambda-Ausdruck und hat folgende Struktur:

[&](int i, int j) -> int {
    // 函数体
    return 0;
}

Darunter &stellt , die Variable in dem Bereich dar, in dem der Lambda-Ausdruck verwendet wird, int i, int jstellt die Parameterliste dar und -> intstellt den Rückgabewert type dar int. Dies definiert eine intLambda-Funktion mit einem Rückgabewert von zwei ganzzahligen Parametern.

Bei diesem Problem wird diese Lambda-Funktion als dynamische Programmierfunktion verwendet, um die vom i-ten Punkt bis zum j-ten Punkt erforderliche Mindestpunktzahl zu berechnen.

Leetcode 1039. Mindestpunktzahl für Polygontriangulation