lintcode 826电脑维修

826,一个n * m矩阵代表一个电脑的阵列，给你一个list< Point >代表坏掉的电脑坐标。现在我们从(0,0)出发修电脑，要求：

  1.必须修完当前行所有坏掉的电脑才能走向下一行。

  2.如果要走向下一行，修理工必须先返回到这一行的最左端或者最右端。

  求最短的访问距离。

 

  输入的矩阵大小为 n x m ，n <= 200，m <= 200。

  坏掉的机器 num <= 1000。

  修完最后一台电脑后，也需要返回最后一行的最左端或最右端。

# example：

# Input:

# n = 3

# m = 10

# list = [[0,0],[0,9],[1,7]]

# Output: 15

# Explanation:

# Starting from (0,0), fix 0, then go to (0,9) to fix 1 and go from (0,9) to next line (1,9), then go to (1,7) to fix 3, then go back to (1,9) and go to (2,9).

 

 # 一个n * m矩阵代表一个电脑的阵列，给你一个list< Point >代表坏掉的电脑坐标。现在我们从(0,0)出发修电脑，要求：
 # 1.必须修完当前行所有坏掉的电脑才能走向下一行。
 # 2.如果要走向下一行，修理工必须先返回到这一行的最左端或者最右端。
 # 求最短的访问距离。
 #
 # 输入的矩阵大小为 n x m ，n <= 200，m <= 200。
 # 坏掉的机器 num <= 1000。
 # 修完最后一台电脑后，也需要返回最后一行的最左端或最右端。

 # example：
 # Input:
 # n = 3
 # m = 10
 # list = [[0,0],[0,9],[1,7]]
 # Output: 15
 # Explanation:
 # Starting from (0,0), fix 0, then go to (0,9) to fix 1 and go from (0,9) to next line (1,9), then go to (1,7) to fix 3, then go back to (1,9) and go to (2,9).

 class Solution:
     """
     @param n: 行
     @param m: 列
     @param badcomputers: 坏电脑
     @return: 答案
     """

     def maintenance(self, n, m, badcomputers):
         dp = [[0, 0] for i in range(n)]  # 每一行作为一个子问题，用该数组存储该行的左边解和右边解的步数
         matrix = [[0 for i in range(m)] for j in range(n)]  # 初始化一个n*m的元素为0的矩阵
         # 坏电脑矩阵元素设为1
         for node in badcomputers:
             matrix[node[0]][node[1]] = 1
         for i in range(n):
             right = -1  # 右边距
             left = -1  # 左边距
             for j in range(m):
                 if matrix[i][j] != 0:
                     right = j  # max(most_right, j)
                     left = max(left, m - 1 - j)
             if i == 0:
                 if right == -1:
                     dp[0][0] = 0
                     dp[0][1] = m - 1
                 else:
                     dp[0][0] = 2 * right
                     dp[0][1] = m - 1
                 continue
             if right == -1:  # 如果该行没有坏电脑，直接进入下一行
                 dp[i][0] = dp[i - 1][0] + 1
                 dp[i][1] = dp[i - 1][1] + 1
             else:  # 取当前行相对上一行的最优解
                 dp[i][0] = min(dp[i - 1][0] + 2 * right,
                                dp[i - 1][1] + m - 1) + 1
                 dp[i][1] = min(dp[i - 1][1] + 2 * left,
                                dp[i - 1][0] + m - 1) + 1
         return min(dp[n - 1][0], dp[n - 1][1])

 if __name__ == '__main__':
     # n = 3
     # m = 10
     # list = [[0, 0], [0, 9], [1, 7]]
     n = 3
     m = 10
     list = [[0, 3], [1, 7], [1, 2]]
     solution = Solution()
     res = solution.maintenance(n, m, list)
     print(res)

826.py