Merge pull request #2337 from ppxyn1/main

[ppxyn1] WEEK 15 solutions

Author: TonyKim9401

longest-palindromic-substring/ppxyn1.py

@@ -0,0 +1,27 @@
+#idea: -
+#Time Complexity: O(n^2)
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        ans = ''
+        def check_func(l, r):
+            while l >= 0 and r < len(s):
+                if s[l] != s[r]:
+                    break
+                l -= 1
+                r += 1
+            return s[l+1:r]
+
+        for i in range(len(s)):
+            odd = check_func(i, i)
+            even = check_func(i, i+1)
+            if len(odd) > len(even):
+                longer = odd 
+            else: 
+                longer = even
+
+            if len(longer) > len(ans):
+                ans = longer
+
+        return ans
+
+

rotate-image/ppxyn1.py

@@ -0,0 +1,32 @@
+# idea: -
+# Time Complexity: O(n^2)
+
+'''
+1 2 3
+4 5 6
+7 8 9
+'''
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        n = len(matrix)
+        # Transpose (diagonal elements are fixed)
+        '''
+        1 4 7
+        2 5 8
+        3 6 9
+        '''
+        for i in range(n):
+            for j in range(i+1,n):
+                matrix[i][j] , matrix[j][i] = matrix[j][i], matrix[i][j] 
+        
+        # Reverse each row
+        '''
+        7 4 1
+        8 5 2
+        9 6 3
+        '''
+        for r in matrix:
+            r.reverse()

subtree-of-another-tree/ppxyn1.py

@@ -0,0 +1,36 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+
+
+# idea : BFS
+# Time Complexity : O(size of root * size of subRoot)
+from collections import deque
+
+class Solution:
+    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
+        queue = deque([root])
+
+        while queue:
+            node = queue.popleft()
+            
+            if node:
+                if self.isSame(node, subRoot):
+                    return True
+                queue.append(node.left)
+                queue.append(node.right)
+
+        return False
+
+    def isSame(self, r, s):
+        if not r and not s:
+            return True
+        if not r or not s:
+            return False
+        if r.val != s.val:
+            return False
+        return self.isSame(r.left, s.left) and self.isSame(r.right, s.right)
+