第五周算法作业

Leetcode No.5 No.64 No.120作业报告

No.5 最长回文子串

• 思路

计算以当前节点为中间点的最长回文串
可能存在两种情况，中间点两个字符不相等或者相等
不相等时, 以该点为中心向两边扩散
相等时，以这两个点为中心向两边扩散

• 代码

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 动态规划
        # 输入的s的长度
        sLength = len(s)
        # 目前已知的最长回文子串长度，起点和终点
        bestResult = 1
        bestStart = 0
        bestEnd = 0

        if sLength == 1:
            return s

        for i in range(1, sLength):
            # 计算以当前节点为中间点的最长回文串
            # 可能存在两种情况，中间点两个字符不相等或者相等
            # 不相等时, 以该点为中心两边扩散
            currentStart = i - 1
            currentEnd = i + 1
            currentResult = 1
            while currentStart>=0 and currentEnd<sLength:
                if s[currentStart]==s[currentEnd]:
                    currentResult = currentResult + 2
                    currentStart = currentStart - 1
                    currentEnd = currentEnd + 1
                else:
                    break
            if currentResult > bestResult:
                bestResult = currentResult
                bestEnd = currentEnd - 1
                bestStart = currentStart + 1

            # 相等时，以这两个点为中心向两边扩散
            if s[i-1]==s[i]:
                currentStart = i - 2
                currentEnd = i + 1
                currentResult = 2
                while currentStart>=0 and currentEnd<sLength:
                    if s[currentStart]==s[currentEnd]:
                        currentResult = currentResult + 2
                        currentStart = currentStart - 1
                        currentEnd = currentEnd + 1
                    else:
                        break
                if currentResult > bestResult:
                    bestResult = currentResult
                    bestEnd = currentEnd - 1
                    bestStart = currentStart + 1
        return s[bestStart: bestEnd+1]

• 作业截图
  

No.64 最小路径和

• 思路

使用动态规划，从右下角往左上角更新当前节点到终点（右下角）的最短路径长度

• 代码

class Solution(object):
    def minPathSum(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        m = len(grid)
        n = len(grid[0])
        # 二维数组初始值设为右下角的值
        init = grid[m-1][n-1]
        dp = [[init for j in range(n)] for i in range(m)]
        
        # 初始化最下边
        for i in range(n-2, -1, -1):
            dp[m-1][i] = dp[m-1][i+1] + grid[m-1][i]
        # 初始化最右边
        for i in range(m-2, -1, -1):
            dp[i][n-1] = dp[i+1][n-1] + grid[i][n-1]

        for i in range(m-2, -1, -1):
            for j in range(n-2, -1, -1):
                dp[i][j] = min( dp[i][j+1], dp[i+1][j] )+grid[i][j]

        return dp[0][0]

• 作业截图
  

No.120 三角形最小路径和

• 思路

使用动态规划，自底向上更新最短路径

• 代码

class Solution(object):
    def minimumTotal(self, triangle):
        """
        :type triangle: List[List[int]]
        :rtype: int
        """
        # 使用动态规划，自底向上更新最短路径
        # n为三角形总行数
        n = len(triangle)
        
        dp = [0] * n
        if n == 1:
            return triangle[0][0]
        
        # 先初始化最下面一行
        for i in range(n):
            dp[i] = triangle[n-1][i]

        # 自底向上更新前i个
        for i in range(n):
            # i: 0 ,,, n-2
            for j in range(n-i-1):
                #print(n-i-2, j)
                #print("dp[j], dp[j+1]:",dp[j], dp[j+1])
                dp[j] = min(dp[j], dp[j+1])+triangle[n-i-2][j]

        return dp[0]

• 作业截图