力扣---2020.5.23

76. 最小覆盖子串

class Solution {
    public String minWindow(String s, String t) {
        //needs存字符串T中对应元素出现的次数
        HashMap<Character,Integer> needs = new HashMap<>();
        //windows存字符串S中出现的T中元素的次数
        HashMap<Character,Integer> windows = new HashMap<>();

        //初始化，先把T中元素出现的次数统计到needs中
        for(int i=0;i<t.length();i++){
            needs.put(t.charAt(i),needs.getOrDefault(t.charAt(i),0)+1);
        }

        int left = 0;
        int right = 0;

        int start = 0;
        int end = 0;

        int count = 0;
        int minLen = Integer.MAX_VALUE;
        //当right小于s的长度时
        while(right<s.length()){

            char temp = s.charAt(right);
            //如果windows中的当前元素同时存在needs中的元素
            if(needs.containsKey(temp)){
                //就将当前元素统计到windows中
                windows.put(temp,windows.getOrDefault(temp,0)+1);
                //当前元素对应的次数与needs中的元素次数一样时，count++
                if(windows.get(temp).compareTo(needs.get(temp))==0){
                    count++;
                }
            }
            
            //右指针向前移动一位
            right++;
            //当count等于needs的长度时,代表找到一个覆盖子串
            while(count==needs.size()){
                //更新最小的覆盖子串的长度
                if(right-left<minLen){
                    start = left;
                    end = right;
                    minLen = end-start;
                }

                //缩小滑动窗口，左指针向前移
                char c = s.charAt(left);
                if(needs.containsKey(c)){
                    windows.put(c,windows.getOrDefault(c,1)-1);
                    if(windows.get(c)<needs.get(c)){
                        count--;
                    }
                }
                left++;
            }
        }
        return minLen==Integer.MAX_VALUE?"":s.substring(start,end);
    }
}

面试题 08.03. 魔术索引

class Solution {
    public int findMagicIndex(int[] nums) {
        for(int i = 0;i<nums.length;i++){
            if(nums[i]==i){
                return i;
            }
        }
        return -1;
    }
}

class Solution {
    public int findMagicIndex(int[] nums) {
        for(int i=0;i<nums.length; ){
            if(nums[i]==i)
                return i;
            i=Math.max(nums[i],i+1);
        }
        return -1;
    }
}

class Solution {
    public int findMagicIndex(int[] nums) {
        return getAnswer(nums, 0, nums.length - 1);
    }

    public int getAnswer(int[] nums, int left, int right) {
        if (left > right) {
            return -1;
        }
        int mid = (right - left) / 2 + left;
        int leftAnswer = getAnswer(nums, left, mid - 1);
        if (leftAnswer != -1) {
            return leftAnswer;
        } else if (nums[mid] == mid) {
            return mid;
        }
        return getAnswer(nums, mid + 1, right);
    }
}

面试题 17.04. 消失的数字

class Solution {
    public int missingNumber(int[] nums) {
        int res = nums.length;
        for (int i = 0; i < nums.length; i++){
            res ^= i;
            res ^= nums[i];
        }
        return res;
    }
}

class Solution {
    public int missingNumber(int[] nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) 
            sum += nums[i];
        int res = nums.length * (nums.length + 1) / 2 - sum;
        return res;
   }
}

你知道的越多，你不知道的越多。