Leetcode -- Day 17 & Day 18 & Day 19

substring

Question 1

Implement strStr()

Implement strStr().

Returns the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Below is my first direct solution, which looks complex in different case checking using if, else. 

public int strStr(String haystack, String needle) {
        if (haystack == null || needle == null)
            return -1;
            
        int len1 = haystack.length();
        int len2 = needle.length();
        
        if (len2==0)
            return 0;
            
        if (len1 <= len2){
            if (haystack.equals(needle)) return 0;
            else return -1;
        }
            
        for (int i = 0; i < len1; i ++){
            if (haystack.charAt(i) == needle.charAt(0)){
                if (i+len2 > len1)
                    return -1;
                String temp = haystack.substring(i, i+len2);
                if (needle.equals(temp))
                    return i;
            }
        }
        return -1;
    }

Question 2

Longest Substring Without Repeating Characters

Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. For "bbbbb" the longest substring is "b", with the length of 1.

If we check it one by one character, it will exceed the time limit. So we must use a hashmap to remember the value and location each character has. And then if we find a repeat char, then we let the start index equals that char index + 1;

public int lengthOfLongestSubstring(String s) {
        if (s == null || s.length() < 1)
            return 0;
        int start = 0;
        int res = 1;
        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); i ++){
            char c = s.charAt(i);
            if (map.containsKey(c) && map.get(c) >= start){
                start = map.get(c) + 1;
            }
            else{
                res = Math.max(res, i-start+1);
            }
            map.put(c, i);
        }
        return res;
    }

Question 3

Longest Palindromic Substring

Given a string S, find the longest palindromic substring inS. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

 Remember to deal with the same character repeat issue. So we will want two pointers. 

P2 move forward, if met same char, move one index further. And then start to compare p2+1 and p1-- is the same or not.

public String longestPalindrome(String s) {
        if (s == null || s.length() <=1)
            return s;
        
        int start = 0;
        int longest = 0;
        for (int i = 0; i < s.length();){
            int p1 = i;
            int p2 = i;
            while(p2<s.length()-1 && s.charAt(p2) == s.charAt(p2+1)){
                p2 ++;
            }
            i = p2 + 1;
            while(p1>0 && p2<s.length()-1 && s.charAt(p1-1) == s.charAt(p2+1)){
               p1--;
               p2++;
            }
            int len = p2 - p1 + 1;
            if (len > longest){
                start = p1;
                longest = len;
            }
        }
        return s.substring(start, start + longest);
    } 

Question 4

Substring with Concatenation of All Words

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in wordsexactly once and without any intervening characters.

For example, given:
s: "barfoothefoobarman"
words: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

We need to use two hashmaps here. One for record all word phrase in the String[] words. Another one for record the second loop for the string's substring to compare whether is it in the first hashmap and whether it appear the same times as it occurs in the first map.

String temp = s.substring(i+j*wordLen,i+(j+1)*wordLen);

Note: for the above one, every time we get a substring with len = wordLen(i.e. "foo" = 3)

public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<Integer>();
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        int wordNum = words.length;
        int wordLen = words[0].length();
        
        if (wordNum*wordLen > s.length())
            return res;
            
        for (int i = 0; i < words.length; i ++){
            if (!map.containsKey(words[i]))
                map.put(words[i], 1);
            else
                map.put(words[i], map.get(words[i])+1);
        }
        
        for (int i = 0; i <= s.length() - wordLen*wordNum; i++){
            HashMap<String, Integer> found = new HashMap<String, Integer>();
            int j;
            for (j = 0; j < wordNum; j ++){
                String temp = s.substring(i+j*wordLen,i+(j+1)*wordLen);
                if (!map.containsKey(temp)) break;
                if (!found.containsKey(temp)) 
                    found.put(temp, 1);
                else
                    found.put(temp, found.get(temp)+1);
                if (found.get(temp)>map.get(temp))
                    break;
            }
            if (j == wordNum)
                res.add(i);
        }
        return res;
    } 

Question 5

Minimum Window Substring

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,
S = "ADOBECODEBANC"
T = "ABC"

Minimum window is "BANC".

Note:
If there is no such window in S that covers all characters in T, return the emtpy string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

We use two int[256] instead of hashset here. Very complex. Still need foFind and found this two array.

And every two while loop, we can get a new window size, we need to check whether it is the minimum one.

public String minWindow(String s, String t) {
        String res = "";
        if (s.length() < t.length())
            return res;
            
        int[] toFind = new int[256];
        int[] found = new int[256];
        
        for (int i = 0; i < t.length(); i++){
            char c = t.charAt(i);
            toFind[c] ++;
        }
        
        int start = 0; 
        int end = 0;
        int need = t.length();
        int minWindow = Integer.MAX_VALUE;
        
        while(end < s.length()){
            while (need > 0 && end < s.length()){
                char c = s.charAt(end);
                if (toFind[c] > 0){
                    if (found[c] < toFind[c] )
                        need --;
                    found[c] ++;
                }
                end ++;
            }
            
            while (need == 0){
                if (end - start < minWindow){
                    res = s.substring(start, end);
                    minWindow = end-start;
                }
                char c = s.charAt(start);
                if (toFind[c] > 0){
                    found[c] --;
                    if (found[c] < toFind[c])
                        need ++;
                }
                start ++;
            }
        }
        
        return res;
    }

Question 6

Longest Substring with At Most Two Distinct Characters

Given a string, find the length of the longest substring T that contains at most 2 distinct characters.
For example,Given s = “eceba”,
T is "ece" which its length is 3.

I use a hashmap to record the two distinct characters. And then loop through the string. If the hashmap found.size() == 2 && the hashmap.containsKey(next char) == false, means we already get two distinct chars and cannot put in the third one, as it is another distinct char. So we need to stop here and count the number of chars of this substring. What we need to remember is that the size of the hashmap should always be 2, so, we will check each time from the start =0 to start = i. If the s.charAt(start) in the map, then we need to substract 1. Until all the map.size() is not 2, we will stop and count the Math.max(i-start+1,max).

public class Solution {  
    public int lengthOfLongestSubstringTwoDistinct(String s) {  
        //input check  
        if(s== null || s.length()==0) return 0;  
        Map<Character, Integer> map = new HashMap<Character, Integer>();  
        int start = 0;  
        int max = 0;  
        for(int i=0; i<s.length(); i++) {  
            char c = s.charAt(i);  
            if(map.containsKey(c)) {  
                map.put( c,   map.get(c) + 1 );  
            } else if(map.size() < 2) {  
                map.put(c, 1);  
            } else {//map does not contain current character, and map size>=2  
                //map size == 2, to satisfy at most 2 distinct character
                //i - current character
                while((map.size()==2) && start<i) {  
                    char temp = s.charAt(start);  
                    int x = map.get(temp);  
                    --x;  
                    if(x==0) map.remove(s.charAt(start));  
                    else map.put(s.charAt(start), x);  
                    ++start;  
                }  
                map.put(c,1);  
            }  
            max = Math.max(max, i-start+1); //i-start+1: current length, max: previous max length 
        }  
        return max;  
    }  
}