Merge pull request ByteByteGoHq#28 from Jer3myYu/java-solutions-sliding-windows

Destiny-02 · web-flow · commit fac15f2b6289 · 2025-01-14T21:10:40.000+11:00
Java Chapter 5: Sliding Windows
diff --git a/java/Sliding Windows/LongestSubstringWithUniqueChars.java b/java/Sliding Windows/LongestSubstringWithUniqueChars.java
@@ -0,0 +1,26 @@
+import java.util.HashSet;
+import java.util.Set;
+
+public class LongestSubstringWithUniqueChars {
+    public int longestSubstringWithUniqueChars(String s) {
+        int maxLen = 0;
+        Set<Character> hashSet = new HashSet<>();
+        int left, right;
+        left = right = 0;
+        while (right < s.length()) {
+            // If we encounter a duplicate character in the window, shrink 
+            // the window until it's no longer a duplicate.
+            while (hashSet.contains(s.charAt(right))) {
+                hashSet.remove(s.charAt(left));
+                left++;
+            }
+            // Once there are no more duplicates in the window, update
+            // 'maxLen' if the current window is larger.
+            maxLen = Math.max(maxLen, right - left + 1);
+            hashSet.add(s.charAt(right));
+            // Expand the window.
+            right++;
+        }
+        return maxLen;
+    }
+}
diff --git a/java/Sliding Windows/LongestSubstringWithUniqueCharsOptimized.java b/java/Sliding Windows/LongestSubstringWithUniqueCharsOptimized.java
@@ -0,0 +1,27 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class LongestSubstringWithUniqueCharsOptimized {
+    public int longestSubstringWithUniqueCharsOptimized(String s) {
+        int maxLen = 0;
+        Map<Character, Integer> prevIndexes = new HashMap<>();
+        int left, right;
+        left = right = 0;
+        while (right < s.length()) {
+            // If a previous index of the current character is present
+            // in the current window, it's a duplicate character in the
+            // window.
+            if (prevIndexes.containsKey(s.charAt(right)) && prevIndexes.get(s.charAt(right)) >= left) {
+                // Shrink the window to exclude the previous occurrence
+                // of this character.
+                left = prevIndexes.get(s.charAt(right)) + 1;
+            }
+            // Update 'maxLen' if the current window is larger.
+            maxLen = Math.max(maxLen, right - left + 1);
+            prevIndexes.put(s.charAt(right), right);
+            // Expand the window.
+            right++;
+        }
+        return maxLen;
+    }
+}
diff --git a/java/Sliding Windows/LongestUniformSubstringAfterReplacements.java b/java/Sliding Windows/LongestUniformSubstringAfterReplacements.java
@@ -0,0 +1,35 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class LongestUniformSubstringAfterReplacements {
+    public int longestUniformSubstringAfterReplacements(String s, int k) {
+        Map<Character, Integer> freqs = new HashMap<>();
+        int highestFreq = 0;
+        int maxLen = 0;
+        int left, right;
+        left = right = 0;
+        while (right < s.length()) {
+            // Update the frequency of the character at the right pointer 
+            // and the highest frequency for the current window.
+            freqs.put(s.charAt(right), freqs.getOrDefault(s.charAt(right), 0) + 1);
+            highestFreq = Math.max(highestFreq, freqs.get(s.charAt(right)));
+            // Calculate replacements needed for the current window.
+            int numCharsToReplace = (right - left + 1) - highestFreq;
+            // Slide the window if the number of replacements needed exceeds 
+            // 'k'. The right pointer always gets advanced, so we just need 
+            // to advance 'left'.
+            if (numCharsToReplace > k) {
+                // Remove the character at the left pointer from the hash map 
+                // before advancing the left pointer.
+                freqs.put(s.charAt(left), freqs.get(s.charAt(left)) - 1);
+                left++;
+            }
+            // Since the length of the current window increases or stays the 
+            // same, assign  the length of the current window to 'maxLen'.
+            maxLen = right - left + 1;
+            // Expand the window.
+            right++;
+        }
+        return maxLen;
+    }
+}
diff --git a/java/Sliding Windows/SubstringAnagrams.java b/java/Sliding Windows/SubstringAnagrams.java
@@ -0,0 +1,42 @@
+public class SubstringAnagrams {
+    public int substringAnagrams(String s, String t) {
+        int lenS = s.length();
+        int lenT = t.length();
+        if (lenT > lenS) return 0;
+        int count = 0;
+        int[] expectedFreqs = new int[26];
+        int[] windowFreqs = new int[26];
+        // Populate 'expectedFreqs' with the characters in string 't'.
+        for (char c : t.toCharArray()) {
+            expectedFreqs[c - 'a']++;
+        }
+        int left, right;
+        left = right = 0;
+        while (right < lenS) {
+            // Add the character at the right pointer to 'windowFreqs' 
+            // before sliding the window.
+            windowFreqs[s.charAt(right) - 'a']++;
+            // If the window has reached the expected fixed length, we 
+            // advance the left pointer as well as the right pointer to 
+            // slide the window.
+            if (right - left + 1 == lenT) {
+                if (compareFreqs(windowFreqs, expectedFreqs)) {
+                    count += 1;
+                }
+                // Remove the character at the left pointer from 
+                // 'windowFreqs' before advancing the left pointer.
+                windowFreqs[s.charAt(left) - 'a']--;
+                left += 1;
+            }
+            right += 1;
+        }
+        return count;
+    }
+
+    private boolean compareFreqs(int[] windowFreqs, int[] expectedFreqs) {
+        for (int i = 0; i < 26; i++) {
+            if (windowFreqs[i] != expectedFreqs[i]) return false;
+        }
+        return true;
+    }
+}
