key point: Unique Paths II fast version

Unique Paths I

class Solution:
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        dp=[[0 for j in range(m)] for i in range(n)]
        for i in range(n):
            for j in range
 
(m):
                if i==0 or j==0:
                    dp[i][j]=1
                else:
                    dp[i][j]=dp[i-1][j]+dp[i][j-1]
        return dp[n-1][m-1]

Unique Paths II
versions of 99.64%, version of 100%

complex version of 99.64%

class Solution:
    def uniquePathsWithObstacles(
 
self, obstacleGrid):
        """
        :type obstacleGrid: List[List[int]]
        :rtype: int
        """
        if obstacleGrid[0][0]==1:
            flag1=flag2=1
        else:
            flag1=flag2=0
        for i in range(len(obstacleGrid)):
            if obstacleGrid[i][0]==1 or flag1==1:
                flag1=
 
1
                obstacleGrid[i][0]=0
            else:
                obstacleGrid[i][0]=-1
        for j in range(1,len(obstacleGrid[0])):
            if obstacleGrid[0][j]==1 or flag2==1:
                flag2=1
                obstacleGrid[0][j]=0
            else:
                obstacleGrid[0][j]=-1
        for i in range(1, len(obstacleGrid)):
            for j in range(1,len(obstacleGrid[0])):
                if obstacleGrid[i][j]==1:
                    obstacleGrid[i][j]=0
                else:
                    obstacleGrid[i][j]=obstacleGrid[i-1][j]+obstacleGrid[i][j-1]
        return -obstacleGrid[len(obstacleGrid)-1][len(obstacleGrid[0])-1]

simple version of 99.64%

class Solution:
  def uniquePathsWithObstacles(self, obstacleGrid):
      m = len(obstacleGrid)
      n = len(obstacleGrid[0])
      ResGrid = [[0 for x in range(n+1)] for x in range(m+1)]
      ResGrid[0][1] = 1
  
      for i in range(1, m+1):
          for j in range(1, n+1):
              if not obstacleGrid[i-1][j-1]:
                  ResGrid[i][j] = ResGrid[i][j-1]+ResGrid[i-1][j]
  
      return ResGrid[m][n]

version of 100%

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid):
        """
        :type obstacleGrid: List[List[int]]
        :rtype: int
        """
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])

        l = [[0] * (n + 1) for i in range(m + 1)]
        l[0][1] = 1

        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if obstacleGrid[i - 1][j - 1] == 0:
                    l[i][j] = l[i - 1][j] + l[i][j - 1]
        return l[m][n]