562. Longest Line of Consecutive One in Matrix

Author: Partho Biswas

README.md

@@ -620,6 +620,7 @@ BFS, DFS, Dijkstra, Floyd–Warshall, Bellman-Ford, Kruskal, Prim's, Minimum Spa
 |43| **[64. Minimum Path Sum](https://tinyurl.com/ugnoql2)** | [Python](https://tinyurl.com/wu6rdaw/64_Minimum_Path_Sum.py), [Swift](https://tinyurl.com/wuja3c4/64_Minimum_Path_Sum.swift)| --- | Medium | --- |
 |44| **[91. Decode Ways](https://tinyurl.com/t5yx86t)** | [Python](https://tinyurl.com/wu6rdaw/91_Decode_Ways.py), [Swift](https://tinyurl.com/wuja3c4/91_Decode_Ways.swift)| [Vid 1](https://tinyurl.com/wxc7jlj) | Medium | --- |
 |45| **[975. Odd Even Jump](https://tinyurl.com/y5ovyklj)** | [Python](https://tinyurl.com/wu6rdaw/975_Odd_Even_Jump.py), [Swift](https://tinyurl.com/wuja3c4/975_Odd_Even_Jump.swift)| [Vid 1](https://tinyurl.com/vxyed3g), **[Art 1](https://tinyurl.com/wbjrnyt)** | Hard | DP using stack. Vary tricky and Interesting problem, loved it |
+|46| **[562. Longest Line of Consecutive One in Matrix](https://tinyurl.com/u2fb4a6)** | [Python](https://tinyurl.com/wu6rdaw/562_Longest_Line_of_Consecutive_One_in_Matrix.py.py), [Swift](https://tinyurl.com/wuja3c4/562_Longest_Line_of_Consecutive_One_in_Matrix.py.swift)| [Art 1](https://tinyurl.com/vqppbae), [Art 2](https://tinyurl.com/t3xtfq8) | Medium |  |
 
 
 </p>

leetcode.com/python/562_Longest_Line_of_Consecutive_One_in_Matrix.py

@@ -0,0 +1,138 @@
+# Approach 1: Brute force. Time limit exceeded. 57 / 57 test cases passed, but took too long.
+# # https://tinyurl.com/vqppbae
+class Solution(object):
+    def longestLine(self, M):
+        """
+        :type M: List[List[int]]
+        :rtype: int
+        """
+        rowCount, colCount = len(M), len(M[0]) if M else 0
+        if rowCount <= 0 or colCount <= 0:
+            return 0
+        maxOnes = 0
+
+        # Checks horizontal lines for max ones
+        for rowIdx in range(rowCount):
+            currentOnes = 0
+            for colIdx in range(colCount):
+                if M[rowIdx][colIdx] == 1:
+                    currentOnes += 1
+                    maxOnes = max(maxOnes, currentOnes)
+                else:
+                    currentOnes = 0
+
+        # Checks vertical lines for max ones
+        for colIdx in range(colCount):
+            currentOnes = 0
+            for rowIdx in range(rowCount):
+                if M[rowIdx][colIdx] == 1:
+                    currentOnes += 1
+                    maxOnes = max(maxOnes, currentOnes)
+                else:
+                    currentOnes = 0
+
+        # Checks upper diagonal lines for max ones
+        for diagonalCol in range(max(rowCount, colCount)):
+            currentOnes = 0
+            for rowIdx, colIdx in zip(range(rowCount), range(diagonalCol, colCount)):
+                if M[rowIdx][colIdx] == 1:
+                    currentOnes += 1
+                    maxOnes = max(maxOnes, currentOnes)
+                else:
+                    currentOnes = 0
+
+        # Checks lower diagonal lines for max ones
+        for diagonalCol in range(max(rowCount, colCount)):
+            currentOnes = 0
+            for rowIdx, colIdx in zip(range(diagonalCol, rowCount), range(colCount)):
+                if M[rowIdx][colIdx] == 1:
+                    currentOnes += 1
+                    maxOnes = max(maxOnes, currentOnes)
+                else:
+                    currentOnes = 0
+
+        # Checks upper anti-diagonal lines for max ones
+        for diagonalCol in range(max(rowCount, colCount)):
+            currentOnes = 0
+            for rowIdx, colIdx in zip(range(rowCount), range(colCount - 1 - diagonalCol, -1, -1)):
+                if M[rowIdx][colIdx] == 1:
+                    currentOnes += 1
+                    maxOnes = max(maxOnes, currentOnes)
+                else:
+                    currentOnes = 0
+
+        # Checks lower anti-diagonal lines for max ones
+        for diagonalCol in range(max(rowCount, colCount)):
+            currentOnes = 0
+            for rowIdx, colIdx in zip(range(diagonalCol, rowCount), range(colCount - 1, -1, -1)):
+                if M[rowIdx][colIdx] == 1:
+                    currentOnes += 1
+                    maxOnes = max(maxOnes, currentOnes)
+                else:
+                    currentOnes = 0
+
+        return maxOnes
+
+
+
+
+# Approach 2: Better Brute force. Accepted
+# https://tinyurl.com/t3xtfq8
+from collections import defaultdict
+
+class Solution(object):
+    def longestLine(self, M):
+        rowCount, colCount = len(M), len(M[0]) if M else 0
+        if rowCount <= 0 or colCount <= 0:
+            return 0
+
+        maxOnes = 0
+        linesDict = defaultdict(list)
+        for rowIdx in range(rowCount):
+            for colIdx in range(colCount):
+                val = M[rowIdx][colIdx]
+                linesDict[0, rowIdx].extend([val])
+                linesDict[1, colIdx].extend([val])
+                linesDict[2, rowIdx + colIdx].extend([val])
+                linesDict[3, rowIdx - colIdx].extend([val])
+
+        for line in linesDict.values():
+            currentMaxOnes = self.onesCount(line)
+            maxOnes = max(maxOnes, currentMaxOnes)
+        return maxOnes
+
+    def onesCount(self, line):
+        ans, count = 0, 0
+        for num in line:
+            if num == 1:
+                count += 1
+                ans = max(ans, count)
+            else:
+                count = 0
+        return ans
+
+
+# Approach 3: 3-D Dynamic Programming
+# https://tinyurl.com/vqppbae
+from collections import defaultdict
+
+class Solution(object):
+    def longestLine(self, M):
+        rowCount, colCount = len(M), len(M[0]) if M else 0
+        if rowCount <= 0 or colCount <= 0:
+            return 0
+
+        maxOnes = 0
+        dp = [[[0 for _ in range(4)] for _ in range(colCount)] for _ in range(rowCount)]
+        for rowIdx in range(rowCount):
+            for colIdx in range(colCount):
+                val = M[rowIdx][colIdx]
+                if val:
+                    # 0 = Horizontal, 1 = Vertical, 2 = Diagonal and 3 = Anti-diagonal
+                    dp[rowIdx][colIdx][0] = (dp[rowIdx][colIdx - 1][0] + 1) if colIdx > 0 else 1
+                    dp[rowIdx][colIdx][1] = (dp[rowIdx - 1][colIdx][1] + 1) if rowIdx > 0 else 1
+                    dp[rowIdx][colIdx][2] = (dp[rowIdx - 1][colIdx - 1][2] + 1) if (colIdx > 0 and rowIdx > 0) else 1
+                    dp[rowIdx][colIdx][3] = (dp[rowIdx - 1][colIdx + 1][3] + 1) if (colIdx < colCount - 1 and rowIdx > 0) else 1
+                    maxOnes = max([maxOnes, dp[rowIdx][colIdx][0], dp[rowIdx][colIdx][1], dp[rowIdx][colIdx][2], dp[rowIdx][colIdx][3]])
+
+        return maxOnes