updates #131 in jav

Author: anishLearnsToCode

Diff for: src/HelloWorld.java

@@ -1,5 +1,12 @@
+import java.util.Map;
+
+import static java.util.Map.entry;
+
 public class HelloWorld {
     public static void main(String[] args) {
-        System.out.println(PalindromePartitioning.partition("abbab"));
+        Map<String, Object> map = Map.of(
+                "hello", null,
+                "", null
+        );
     }
 }

Diff for: src/PalindromePartitioning.java

@@ -1,79 +1,30 @@
 // https://leetcode.com/problems/palindrome-partitioning
 // T: O(n * 2^n)
-// S: O(n * 2^n)
+// S: O(n) for recursion call stack
 
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 
 public class PalindromePartitioning {
-    private record Range(int start, int end) { }
-
-    public static List<List<String>> partition(String s) {
-        final List<List<String>> palindromicPartitions = new ArrayList<>();
-        addValidPartitionsToResult(s, palindromicPartitions);
-        return palindromicPartitions;
-    }
-
-    private static void addValidPartitionsToResult(String s, List<List<String>> result) {
-        if (isPalindrome(s)) result.add(List.of(s));
-        for (int i = 1 ; i < s.length() ; i++) {
-           LinkedList<Range> segments = new LinkedList<>();
-           segments.add(new Range(0, i));
-           segments.add(new Range(i, s.length()));
-           addValidPartitionsToResult(s, result, segments);
-        }
-    }
-
-    private static void addValidPartitionsToResult(String s, List<List<String>> result, LinkedList<Range> segments) {
-        if (!isPalindrome(s, getSecondLast(segments))) return;
-        final Range lastSegment = lastSegment(segments);
-        if (isPalindrome(s, lastSegment)) {
-            result.add(getPartitions(s, segments));
-        }
-        if (lastSegment.start + 1 < s.length()) {
-            segments.pollLast();
-        }
-        for (int i = lastSegment.start + 1 ; i < s.length() ; i++) {
-            segments.addLast(new Range(lastSegment.start, i));
-            segments.addLast(new Range(i, lastSegment.end));
-            addValidPartitionsToResult(s, result, segments);
-            segments.pollLast();
-            segments.pollLast();
-        }
-        if (lastSegment.start + 1 < s.length()) {
-            segments.add(lastSegment);
-        }
-    }
-
-    private static List<String> getPartitions(String s, List<Range> segments) {
-        final List<String> result = new LinkedList<>();
-        for (Range range : segments) {
-            result.add(s.substring(range.start, range.end));
-        }
+    public List<List<String>> partition(String s) {
+        final int length = s.length();
+        final boolean[][] dp = new boolean[length][length];
+        final List<List<String>> result = new ArrayList<>();
+        addValidPartitions(s, 0, dp, result, new LinkedList<>());
         return result;
     }
 
-    private static Range getSecondLast(List<Range> segments) {
-        return segments.get(segments.size() - 2);
-    }
-
-    private static Range lastSegment(List<Range> segments) {
-        return segments.get(segments.size() - 1);
-    }
-
-    public static boolean isPalindrome(String s) {
-        return isPalindrome(s, 0, s.length());
-    }
-
-    private static boolean isPalindrome(String s, Range range) {
-        return isPalindrome(s, range.start, range.end);
-    }
+    private void addValidPartitions(String s, int start, boolean[][] dp, List<List<String>> result, LinkedList<String> current) {
+        if (start == s.length()) result.add(new ArrayList<>(current));
 
-    public static boolean isPalindrome(String s, int start, int end) {
-        for (int i = start ; i < start + (end - start) / 2 ; i++) {
-            if (s.charAt(i) != s.charAt(end - i + start - 1)) return false;
+        for (int end = start ; end < s.length() ; end++) {
+            if (s.charAt(start) == s.charAt(end) && (end - start <= 2 || dp[start + 1][end - 1])) {
+                dp[start][end] = true;
+                current.addLast(s.substring(start, end + 1));
+                addValidPartitions(s, end + 1, dp, result, current);
+                current.pollLast();
+            }
         }
-        return true;
     }
 }