LeetCode 第27场双周赛

1.通过翻转子数组使两个数组相等

按照题意，由于可以翻转任意相邻的元素无限次，所以等同于可以对两个数组进行一轮冒泡排序，那么最终两个数组排序后的结果应该相同的，本质上也是所有元素的频率是一样的
1.通过翻转子数组使两个数组相等

    public boolean canBeEqual(int[] target, int[] arr) {
        int[] freq1 = new int[1001];
        int[] freq2 = new int[1001];
        for(int num:target){
            freq1[num]++;
        }
        for(int num:arr){
            freq2[num]++;
        }
        for(int i=0;i<1001;i++){
            if(freq1[i]!=freq2[i]) return false;
        }
        return true;
    }

2.检查一个字符串是否包含所有长度为 K 的二进制子串

2.检查一个字符串是否包含所有长度为 K 的二进制子串
按照题意如果去暴力所有的2进制子串，则有$2^K$个可能，而且穷举每一位是比较困难的，所以我们换个思路尝试去判断指定字符串的每个长度为K的子串的对应的值，是否能够取遍（0，$2^K$）如果满足则返回true，否则返回false.

    public boolean hasAllCodes(String s, int k) {    
        int left=0,right=0;
        int max = 1<<k;
        System.out.println(max);
        Set<Integer> set = new HashSet<>();
        while(right<s.length()){
            
            if(right-left+1==k){
                int curNum=0;int times=1;
                for(int i=right;i>=left;i--){
                   curNum+=(s.charAt(i)-'0')*times;
                    times*=2;
                }
                //System.out.println(curNum);
                if(curNum<max) set.add(curNum);
                left++;
            }
            right++;
        }
        return set.size()==max;
    }

3.课程安排 IV

课程安排 IV
很典型的图的可达性问题，最浅显的思路是dfs，大佬们提了floyd算法可惜我不会。这里主要是两个问题，
一、如何存图：这里应该是要存一个邻接矩阵；
二、优化：如果直接使用dfs算法会存在大量重复，这题数据卡得比较紧，不能使用简单的dfs通过，我们通过存图以后，对每个点进行一次dfs，利用visited来避免重复及环，缓存每个点所能达到的所有点，最后判断query中所求点是否在他能达到的所有点之中

    boolean[] visited;//防止重复访问，主要是防止在环里出不来
    public List<Boolean> checkIfPrerequisite(int n, int[][] prerequisites, int[][] queries) {
        List<Boolean> res = new LinkedList<>();
        Map<Integer,List<Integer>> map = new HashMap<>();//存图的邻接矩阵
        visited = new boolean[n];
        for(int[] pre:prerequisites){
            if(!map.containsKey(pre[0])) {
                List<Integer> list = new LinkedList<>();
                list.add(pre[1]);
                map.put(pre[0],list);
            
            }
             else map.get(pre[0]).add(pre[1]);
        }
        Map<Integer,Set<Integer>> can = new HashMap<>();//所有点的可达set
        for(int i=0;i<n;i++){
            Arrays.fill(visited,false);
            Set<Integer> set = new HashSet<>();
            dfs(i,map,set);
            can.put(i,set);
        }
        for(int[] query:queries){
            if(can.get(query[0]).contains(query[1])) res.add(true);
             else res.add(false);          
        }
        return res;
    }
    public void dfs(int start, Map<Integer,List<Integer>> map,Set<Integer> set){        
        set.add(start);//添加该点进入目标的set
        if( visited[start]) return;//防止环
        visited[start] = true;       
        if(map.containsKey(start)){
            for(int num:map.get(start)){
                dfs(num,map,set);
            }
        }
        else return;    
    }

4(wo bu hui le)