leetcode1039

先提供一种递归的实现，属于回溯法思想。思路比较简单，但是提交会超时。

class Solution:
    def __init__(self):
        self.dic = {}

    def minScoreTriangulation(self, A: 'List[int]') -> int:
        tp = tuple(A)
        if tp in self.dic.keys():
            return self.dic[tp]
        else:
            n = len(A)
            if n == 3:
                r = A[0] * A[1] * A[2]
                self.dic.update({tuple(A):r})
                return r
            result = sys.maxsize
            cur = 0
            for i in range(n//2):#n>3
                if i > 0:
                    temp = A.pop(0)
                    A.append(temp)
                for j in range(2,n-1):
                    part1 = A[0:j+1]
                    part2 = A[j:] + A[0:1]
                    tuple1 = tuple(part1)
                    tuple2 = tuple(part2)
                    p1 = self.minScoreTriangulation(part1)
                    p2 = self.minScoreTriangulation(part2)
                    cur = p1 + p2
                    result = min(result,cur)
            self.dic.update({tp:result})
            return result

尝试使用字典记录已经计算过的项，但是执行效率没有明显的改善。

这道题目想要提升效率，需要使用动态规划的思想。我没有思路。

动态规划最核心的是寻找递归公式，也就是把题目中隐含的数学关系用一个式子写出来。

这类问题对于我这样数学不好的人来说，的确比较困难。

以我的水平，能写出“超时”的解就可以了。谁让咱技能树没有点数学这个天赋呢。

下面提供一个高大上的实现：

from functools import lru_cache

class Solution:
    def minScoreTriangulation(self, A):
        @lru_cache(None)
        def dp(i, j):
            if j - i + 1 < 3:
                return 0
            return min(A[i]*A[j]*A[k] + dp(i, k) + dp(k, j) for k in range(i + 1, j))
        return dp(0, len(A) - 1)

参考：https://leetcode.com/problems/minimum-score-triangulation-of-polygon/discuss/286754/C%2B%2BPython-O(n3)-DP-explanation-%2B-diagrams