follow Up — 20181101

406. Minimum Size Subarray Sum

 public class Solution {
     /**
      * @param nums: an array of integers
      * @param s:    An integer
      * @return: an integer representing the minimum size of subarray
      */
     public int minimumSize(int[] nums, int s) {
         // write your code here
         if (nums == null || nums.length == 0) {
             return -1;
         }
         int sum = 0;
         int ans = Integer.MAX_VALUE;
         int i = 0;
         int j = 0;
         while (i < nums.length && j < nums.length) {
             while (sum < s && j < nums.length) {
                 sum += nums[j];
                 j++;
             }
             while (sum >= s) {
                 ans = Math.min(ans, j - i);
                 sum -= nums[i];
                 i++;
             }
         }
         return ans == Integer.MAX_VALUE ? -1 : ans;
     }
 }

384. Longest Substring Without Repeating Characters

 public class Solution {
     /**
      * @param s: a string
      * @return: an integer
      */
     public int lengthOfLongestSubstring(String s) {
         if (s == null || s.length() == 0) {
             return 0;
         }
         int[] map = new int[256];
         int i = 0;
         int j = 0;
         int ans = Integer.MIN_VALUE;
         while (i < s.length() && j < s.length()) {
             while (j < s.length() && map[s.charAt(j)] == 0) {
                 map[s.charAt(j)] = 1;
                 ans = Math.max(ans, j - i + 1);
                 j++;
             }
             map[s.charAt(i)] = 0;
             i++;
         }
         return ans == Integer.MIN_VALUE ? -1 : ans;
     }
 }

386. Longest Substring with At Most K Distinct Characters

 public class Solution {
     /**
      * @param s: A string
      * @param k: An integer
      * @return: An integer
      */
     public int lengthOfLongestSubstringKDistinct(String s, int k) {
         // write your code here
         if (s == null || s.length() == 0 || k == 0) {
             return 0;
         }
         int left = 0;
         int r = 0;
         int ans = 0;
         int sum = 0;
         int[] cnt = new int[256];
         for (r = 0; r < s.length(); r++) {
             cnt[s.charAt(r)]++;
             if (cnt[s.charAt(r)] == 1) {
                 sum++;
             }
             while (sum > k) {
                 cnt[s.charAt(left)]--;
                 if (cnt[s.charAt(left)] == 0) {
                     sum--;
                 }
                 left++;
             }
             ans = Math.max(ans, r - left + 1);
         }
         return ans;
     }
 }

465. Kth Smallest Sum In Two Sorted Arrays

 class Pair {
     int x;
     int y;
     int sum;

     public Pair(int x, int y, int sum) {
         this.x = x;
         this.y = y;
         this.sum = sum;
     }
 }

 public class Solution {
     /**
      * @param A: an integer arrays sorted in ascending order
      * @param B: an integer arrays sorted in ascending order
      * @param k: An integer
      * @return: An integer
      */
     public int kthSmallestSum(int[] A, int[] B, int k) {
         // write your code here
         if (A == null || A.length == 0) {
             return 0;
         }
         if (B == null || B.length == 0) {
             return 0;
         }
         if (k == 0) {
             return 0;
         }

         Comparator<Pair> pairComparator = new Comparator<Pair>() {
             @Override
             public int compare(Pair o1, Pair o2) {
                 return o1.sum - o2.sum;
             }
         };

         PriorityQueue<Pair> minHeap = new PriorityQueue<>(pairComparator);
         int[] dx = new int[]{1, 0};
         int[] dy = new int[]{0, 1};
         boolean[][] visit = new boolean[A.length][B.length];
         minHeap.add(new Pair(0, 0, A[0] + B[0]));
         visit[0][0] = true;

         for (int i = 1; i < k; i++) {
             Pair center = minHeap.poll();
             for (int j = 0; j < 2; j++) {
                 if (center.x + dx[j] > A.length - 1 || center.y + dy[j] > B.length - 1 || visit[center.x + dx[j]][center.y + dy[j]]) {
                     continue;
                 }
                 minHeap.add(new Pair(center.x + dx[j], center.y + dy[j], A[center.x + dx[j]] + B[center.y + dy[j]]));
                 visit[center.x + dx[j]][center.y + dy[j]] = true;
             }
         }
         return minHeap.peek().sum;
     }
 }