add a solution for 395

fishercoder1534 · fishercoder1534 · commit a1fada8ee426 · 2021-10-20T15:58:45.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_395.java b/src/main/java/com/fishercoder/solutions/_395.java
@@ -37,4 +37,63 @@ int findLongestSubstring(char[] chars, int start, int end, int k) {
             return end - start;
         }
     }
+
+    public static class Solution2 {
+        /**
+         * classic sliding window approach.
+         * credit: https://leetcode.com/problems/longest-substring-with-at-least-k-repeating-characters/discuss/170010/Java-O(n)-Solution-with-Detailed-Explanation-Sliding-Window/774350
+         */
+        public int longestSubstring(String s, int k) {
+            int res = 0;
+            for (int numUniqueTarget = 1; numUniqueTarget <= 26; numUniqueTarget++) {
+                res = Math.max(res, slidingWindowHelper(s, k, numUniqueTarget));
+            }
+            return res;
+        }
+
+        // sliding window template
+        private int slidingWindowHelper(String s, int k, int numUniqueTarget) {
+            int[] map = new int[26];
+            int start = 0;
+            int end = 0;
+            int res = 0;
+            int uniqueLetterCount = 0;
+            int numNoLessThanK = 0;
+            while (end < s.length()) {
+                char c1 = s.charAt(end);
+                if (map[c1 - 'a'] == 0) {
+                    //we increment this when we include a new letter into our sliding window
+                    uniqueLetterCount++;
+                }
+                map[c1 - 'a']++;
+                if (map[c1 - 'a'] == k) {
+                    //we increment this number when we find a letter's frequency reaches k
+                    numNoLessThanK++;
+                }
+                end++;
+
+                while (uniqueLetterCount > numUniqueTarget) {
+                    //as long as the counter (the number of qualified letters) is greater than our target number,
+                    //we can move the left pointer to the right,
+                    //this keeps the interval within our sliding window always valid
+                    char c2 = s.charAt(start);
+                    if (map[c2 - 'a'] == k) {
+                        //we decrement this numNoLessThanK when we find this letter's frequency equals
+                        //to k because we'll move past this letter, i.e. our sliding window no longer includes it
+                        numNoLessThanK--;
+                    }
+                    map[c2 - 'a']--;
+                    if (map[c2 - 'a'] == 0) {
+                        uniqueLetterCount--;
+                    }
+                    start++;
+                }
+
+                if (uniqueLetterCount == numNoLessThanK) {
+                    res = Math.max(res, end - start);
+                }
+            }
+            return res;
+        }
+    }
 }
diff --git a/src/test/java/com/fishercoder/_395Test.java b/src/test/java/com/fishercoder/_395Test.java
@@ -6,26 +6,63 @@
 
 import static junit.framework.Assert.assertEquals;
 
-/**
- * Created by fishercoder on 12/31/16.
- */
 public class _395Test {
 
     private static _395.Solution1 solution1;
+    private static _395.Solution2 solution2;
+    private static String s;
+    private static int k;
+    private static int expected;
 
     @BeforeClass
     public static void setup() {
         solution1 = new _395.Solution1();
+        solution2 = new _395.Solution2();
     }
 
     @Test
     public void test1() {
-        assertEquals(5, solution1.longestSubstring("ababbc", 2));
+        s = "ababbc";
+        expected = 5;
+        k = 2;
+        assertEquals(expected, solution1.longestSubstring(s, k));
+        assertEquals(expected, solution2.longestSubstring(s, k));
     }
 
     @Test
     public void test2() {
-        assertEquals(3, solution1.longestSubstring("aaabb", 3));
+        s = "aaabb";
+        k = 3;
+        expected = 3;
+        assertEquals(expected, solution1.longestSubstring(s, k));
+        assertEquals(expected, solution2.longestSubstring(s, k));
+    }
+
+    @Test
+    public void test3() {
+        s = "bbaaacbd";
+        k = 3;
+        expected = 3;
+        assertEquals(expected, solution1.longestSubstring(s, k));
+        assertEquals(expected, solution2.longestSubstring(s, k));
+    }
+
+    @Test
+    public void test4() {
+        s = "weitong";
+        k = 2;
+        expected = 0;
+        assertEquals(expected, solution1.longestSubstring(s, k));
+        assertEquals(expected, solution2.longestSubstring(s, k));
+    }
+
+    @Test
+    public void test5() {
+        s = "a";
+        k = 2;
+        expected = 0;
+        assertEquals(expected, solution1.longestSubstring(s, k));
+        assertEquals(expected, solution2.longestSubstring(s, k));
     }
 
 }
