all complexity style chnaged

Author: Yashgabani845

dsa-solutions/lc-solutions/0000-0099/0004-Median-of-two-Sorted-Array.md

@@ -76,7 +76,7 @@ def findMedianSortedArrays(nums1, nums2):
         return (merged[n // 2 - 1] + merged[n // 2]) / 2.0
 ```
 
-#### Approach 2: Binary Search (O(log(min(m, n))))
+#### Approach 2: Binary Search $(O(log(min(m, n))))$
 
 **Intuition:**
 To achieve $O(log(min(m, n)))$ complexity, use binary search on the smaller array. The goal is to find a partition where the left half of both arrays combined is less than or equal to the right half.

dsa-solutions/lc-solutions/0000-0099/0005-Longest-palindrome-substring.md

@@ -70,8 +70,8 @@ def longestPalindrome(s: str) -> str:
 ```
 
 ### Complexity Analysis
-- **Time complexity**: `O(n^3)` - We check each substring, and checking each substring takes `O(n)` time.
-- **Space complexity**: `O(1)` - We use a constant amount of extra space.
+- **Time complexity**: $O(n^3)$ - We check each substring, and checking each substring takes $O(n)$ time.
+- **Space complexity**: $O(1)$ - We use a constant amount of extra space.
 
 ### Approach 2: Dynamic Programming
 
@@ -112,8 +112,8 @@ def longestPalindrome(s: str) -> str:
 ```
 
 ### Complexity Analysis
-- **Time complexity**: `O(n^2)` - We fill an `n * n` table.
-- **Space complexity**: `O(n^2)` - We use an `n * n` table to store the DP results.
+- **Time complexity**: $O(n^2)$ - We fill an `n * n` table.
+- **Space complexity**: $O(n^2)$ - We use an `n * n` table to store the DP results.
 
 ### Approach 3: Expand From Centers
 
@@ -148,8 +148,8 @@ def longestPalindrome(s: str) -> str:
 ```
 
 ### Complexity Analysis
-- **Time complexity**: `O(n^2)` - We expand around each center, which takes `O(n)` time.
-- **Space complexity**: `O(1)` - We use a constant amount of extra space.
+- **Time complexity**: $O(n^2)$ - We expand around each center, which takes $O(n)$  time.
+- **Space complexity**: $O(1)$ - We use a constant amount of extra space.
 
 ### Approach 4: Manacher's Algorithm
 
@@ -185,8 +185,8 @@ def longestPalindrome(s: str) -> str:
 ```
 
 ### Complexity Analysis
-- **Time complexity**: `O(n)` - Manacher's algorithm runs in linear time.
-- **Space complexity**: `O(n)` - We use an array of length `n` to store the lengths of palindromes.
+- **Time complexity**: $O(n)$ - Manacher's algorithm runs in linear time.
+- **Space complexity**: $O(n)$ - We use an array of length `n` to store the lengths of palindromes.
 
 ### Conclusion
 We discussed four approaches to solve the "Longest Palindromic Substring" problem, each with varying complexities and trade-offs. The dynamic programming and center expansion approaches provide a good balance of simplicity and efficiency for practical use cases, while Manacher's algorithm offers the optimal theoretical performance.

dsa-solutions/lc-solutions/0000-0099/0006-ZigZag-Conversion.md

@@ -204,24 +204,24 @@ class Solution:
 
 #### Approach 1: Iterative Approach
 
-- **Time Complexity**: O(n), where n is the length of the input string `s`. We iterate through the entire string once.
-- **Space Complexity**: O(n), where n is the length of the input string `s`. We use a StringBuilder to store the output.
+- **Time Complexity**: $O(n)$, where n is the length of the input string `s`. We iterate through the entire string once.
+- **Space Complexity**: $O(n)$, where n is the length of the input string `s`. We use a StringBuilder to store the output.
 
 #### Approach 2: Using StringBuilder Rows
 
-- **Time Complexity**: O(n), where n is the length of the input string `s`. We iterate through the entire string once to fill the rows of the StringBuilder.
-- **Space Complexity**: O(n), where n is the length of the input string `s`. We use a StringBuilder to store the output.
+- **Time Complexity**: $O(n)$, where n is the length of the input string `s`. We iterate through the entire string once to fill the rows of the StringBuilder.
+- **Space Complexity**:$O(n)$, where n is the length of the input string `s`. We use a StringBuilder to store the output.
 
 #### Approach 3: Direct Construction
 
-- **Time Complexity**: O(n), where n is the length of the input string `s`. We iterate through the entire string once to construct the output string.
-- **Space Complexity**: O(n), where n is the length of the input string `s`. We use a StringBuilder to store the output.
+- **Time Complexity**: $O(n)$, where n is the length of the input string `s`. We iterate through the entire string once to construct the output string.
+- **Space Complexity**: $O(n)$, where n is the length of the input string `s`. We use a StringBuilder to store the output.
 
 #### Approach 4: Using Mathematical Formula
 
-- **Time Complexity**: O(n), where n is the length of the input string `s`. We iterate through the entire string once to construct the output string.
-- **Space Complexity**: O(n), where n is the length of the input string `s`. We use a StringBuilder to store the output.
+- **Time Complexity**: $O(n)$, where n is the length of the input string `s`. We iterate through the entire string once to construct the output string.
+- **Space Complexity**: $O(n)$, where n is the length of the input string `s`. We use a StringBuilder to store the output.
 
 ### Conclusion
 
-We explored four different approaches to solve the Zigzag Conversion problem, each offering a unique perspective and trade-offs in terms of simplicity and efficiency. All four approaches have a linear time complexity of O(n), where n is the length of the input string `s`. The space complexity varies slightly among the approaches but remains linear in terms of the input size.
+We explored four different approaches to solve the Zigzag Conversion problem, each offering a unique perspective and trade-offs in terms of simplicity and efficiency. All four approaches have a linear time complexity of $O(n)$, where n is the length of the input string `s`. The space complexity varies slightly among the approaches but remains linear in terms of the input size.

dsa-solutions/lc-solutions/0000-0099/0007-Reverse-Integers.md

@@ -155,8 +155,8 @@ class Solution:
 
 ### Complexity Analysis
 
-- **Time Complexity**: O(log(x)). There are roughly log10(x) digits in `x`.
-- **Space Complexity**: O(1).
+- **Time Complexity**: $O(log(x))$. There are roughly log10(x) digits in `x`.
+- **Space Complexity**: $O(1)$.
 
 ### Conclusion
 

dsa-solutions/lc-solutions/0000-0099/0008-String-to-Integer.md

@@ -139,8 +139,8 @@ class Solution {
 
 ### Complexity Analysis
 
-- **Time Complexity**: O(n), where n is the length of the string `s`.
-- **Space Complexity**: O(1), due to the constant number of variables used.
+- **Time Complexity**: $O(n)$, where n is the length of the string `s`.
+- **Space Complexity**: $O(1)$, due to the constant number of variables used.
 
 ## Conclusion
 

dsa-solutions/lc-solutions/0000-0099/0009-Palindrome-number.md

@@ -225,13 +225,13 @@ class Solution:
 
 ### Approach 1: Reversing the Entire Number
 
-- **Time Complexity**: O(log10(x)), where x is the input number.
-- **Space Complexity**: O(1).
+- **Time Complexity**: $O(log10(x))$, where x is the input number.
+- **Space Complexity**: $O(1)$.
 
 ### Approach 2: Reversing Half of the Number
 
-- **Time Complexity**: O(log10(x)), where x is the input number.
-- **Space Complexity**: O(1).
+- **Time Complexity**: $O(log10(x))$, where x is the input number.
+- **Space Complexity**: $O(1)$.
 
 ## Conclusion
 

dsa-solutions/lc-solutions/0000-0099/0010-Regular-Expression-Matching.md

@@ -220,10 +220,10 @@ class Solution:
 ```
 Complexity Analysis
 Time Complexity
-Let T, P be the lengths of the text and the pattern respectively. The work for every call to dp(i, j) for i=0,...,T; j=0,...,P is done once, and it is O(1) work. Hence, the time complexity is O(TP).
+Let T, P be the lengths of the text and the pattern respectively. The work for every call to dp(i, j) for i=0,...,T; j=0,...,P is done once, and it is $O(1)$ work. Hence, the time complexity is $O(TP)$.
 
 Space Complexity
-The only memory we use is the O(TP) boolean entries in our cache. Hence, the space complexity is O(TP)
+The only memory we use is the $O(TP)$ boolean entries in our cache. Hence, the space complexity is $O(TP)$
 
 
 Now, just as you asked, the last part should include the summary and links to the problem, solution, and profile. Let's add that: