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)