update

Author: genkimaru

pom.xml

@@ -9,8 +9,8 @@
     <version>1.0-SNAPSHOT</version>
 
     <properties>
-        <maven.compiler.source>22</maven.compiler.source>
-        <maven.compiler.target>22</maven.compiler.target>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
     <dependencies>

src/main/java/com/leetcode/binarytree/BSTValidator.java

@@ -8,23 +8,20 @@
 public class BSTValidator {
 
     public boolean isValidBST(TreeNode root) {
-        if (root.left != null) {
-            if (root.val < root.left.val) {
-                return false;
-            }
-           return  isValidBST(root.left);
+        return validate(root, Long.MIN_VALUE, Long.MAX_VALUE);
+    }
 
+    public boolean validate(TreeNode node, long min, long max) {
+        if (node == null) {
+            return true;
         }
-        if (root.right != null) {
-
-            if (root.val > root.right.val) {
-                return false;
-            }
-          return   isValidBST(root.right);
+        if (node.val <= min || node.val >= max) {
+            return false;
         }
-        return true;
+        return  validate(node.left, min, node.val) && validate(node.right, node.val, max);
     }
 
+
     public static void main(String[] args) {
         int[] arr = {3, 4, 2, 5, 1, 6};
 

src/main/java/com/leetcode/dynamicplan/DynPlanOne.java renamed to src/main/java/com/leetcode/dynamicplan/ClimbingStairs.java

@@ -8,7 +8,7 @@
  *   name:  Climbing Stairs
  *    fibonacci sequence
  */
-public class DynPlanOne {
+public class ClimbingStairs {
 
     public static int fibonacci(int n) {
         if (n == 1) {

src/main/java/com/leetcode/heap/HeapOne.java renamed to src/main/java/com/leetcode/heap/KthLargest.java

@@ -6,7 +6,7 @@
 /**
  *   Kth Largest Element in an Array
  */
-public class HeapOne {
+public class KthLargest {
 
     public static int partition(int[] nums, int low, int high) {
         int pivot = nums[high];
@@ -49,7 +49,7 @@ public static void main(String[] args) {
 
         int[] nums = new int[]{9,8,7,6,5,4,3,2,1};
         int k = 2;
-        int kthLargest = new HeapOne().findKthLargest(nums, k);
+        int kthLargest = new KthLargest().findKthLargest(nums, k);
         System.out.println(kthLargest);
     }
 }

src/main/java/com/leetcode/slidingwindow/MaxSlidingWindow.java

@@ -0,0 +1,32 @@
+package com.leetcode.slidingwindow;
+
+import java.util.ArrayList;
+import java.util.function.IntFunction;
+
+public class MaxSlidingWindow {
+
+
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        ArrayList<Integer> result = new ArrayList<>();
+        for(int i = 0 , j= k -1; j < nums.length ; i++ , j++){
+            int max = Integer.MIN_VALUE;
+            for(int x = i ; x <= j ; x ++){
+                if(nums[x] > max){
+                    max = nums[x];
+                }
+            }
+            result.add(max);
+        }
+        return result.stream().mapToInt(Integer::intValue).toArray();
+    }
+
+    public static void main(String[] args) {
+
+       int[] nums = {1,3,-1,-3,5,3,6,7};
+        int k = 3;
+        int[] ints = new MaxSlidingWindow().maxSlidingWindow(nums, k);
+        for(int i : ints){
+            System.out.println(i);
+        }
+    }
+}

src/main/java/com/leetcode/slidingwindow/MinWindow.java

@@ -0,0 +1,61 @@
+package com.leetcode.slidingwindow;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MinWindow {
+
+
+    public String minWindow(String s, String t) {
+            Map<Character, Integer> targetMap = new HashMap<>();
+            for (char c : t.toCharArray()) {
+                targetMap.put(c, targetMap.getOrDefault(c, 0) + 1);
+            }
+
+            int left = 0, right = 0;
+            int minLen = Integer.MAX_VALUE;
+            int minStart = 0;
+            int count = t.length();
+
+            while (right < s.length()) {
+                char c = s.charAt(right);
+                if (targetMap.containsKey(c)) {
+                    if (targetMap.get(c) > 0) {
+                        count--;
+                    }
+                    targetMap.put(c, targetMap.get(c) - 1);
+                }
+
+                while (count == 0) {
+                    if (right - left + 1 < minLen) {
+                        minLen = right - left + 1;
+                        minStart = left;
+                    }
+
+                    char leftChar = s.charAt(left);
+                    if (targetMap.containsKey(leftChar)) {
+                        targetMap.put(leftChar, targetMap.get(leftChar) + 1);
+                        if (targetMap.get(leftChar) > 0) {
+                            count++;
+                        }
+                    }
+
+                    left++;
+                }
+
+                right++;
+            }
+
+            return minLen == Integer.MAX_VALUE ? "" : s.substring(minStart, minStart + minLen);
+        }
+
+
+    public static void main(String[] args) {
+
+        String str = "ADOBECODEBANC";
+        String substr = "ABC";
+        String s = new MinWindow().minWindow(str, substr);
+        System.out.println(s);
+
+    }
+}