【LeetCode】Sama的个人记录_41

/**
 *【很精妙的解法】
 *  1.用一个数据arr[26]记录每个字母最后出现的位置
 *  2.用一次遍历S填好arr数组
 *  3.再遍历S，每次遍历到一个字母时，就尝试更新end的值(合法的结束位置)；当此时的i就是「合法的结束位置时」，将一段长度加入最终结果中
 *
 *  再解释一下什么是「合法的结束位置」：
 *  比如abcbcayyy，当遍历到a时，这个合法的结束位置end就被拉到了5
 *  遍历到b时，尝试更新这个合法的结束位置end，但是由于3 < 5，更新失败
 *  只有遍历到第二个a时，满足end == i，才将这段长度加入res中
 */
class Solution_763 {
    public List<Integer> partitionLabels(String S) {
        int[] arr = new int[26];
        for(int i = 0; i < S.length(); i++){
            arr[S.charAt(i) - 'a'] = i;
        }
        int start = 0;
        int end = 0;
        List<Integer> res = new ArrayList<>();
        for(int i = 0; i < S.length(); i++){
            end = Math.max(end, arr[S.charAt(i) - 'a']);
            if(i == end){
                res.add(end - start + 1);
                start = end + 1;
            }
        }
        return res;
    }
}

 
 
 

class Solution {
    /**
     * increasing记录上升区间的长度
     * decreasing记录下降区间的长度
     * 尝试更新最大长度 = increasing + decreasing + 1
     */
    public int longestMountain(int[] A) {
        if(A.length < 3){
            return 0;
        }
        int maxHeight = 0;
        int i = 1;
        while (i < A.length){
            int increasing = 0;     // 重置上升区间长度
            int decreasing = 0;     // 重置下降区间长度
            while(i < A.length && A[i] > A[i - 1])  { increasing++; i++; }
            while(i < A.length && A[i] < A[i - 1])  { decreasing++; i++; }
            if(increasing > 0 && decreasing > 0){
                maxHeight = Math.max(maxHeight, increasing + decreasing + 1);
            }
            while (i < A.length && A[i] == A[i - 1])   i++;     // 防止卡死
        }
        return maxHeight;
    }
}
// 总结：
// 题目很长，但是很好很好很好理解
// 但这题的正确率在leetcode并不高————你需要考虑太多的情况，尤其是“平顶”使题目变得麻烦起来
// 而这里，是高赞的一个极其优雅的写法

 
 
 

1. BFS
2. 对于一个字符串的每一个位置的字符，尝试用26个字母去替换————这复杂度很高，但我们无法避免
3. BFS是采用层序遍历形式的BFS，即先取size()，然后for循环清空整个队列
4. 进阶：双向BFS————上图很清晰

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        // 一些情况直接返回0
        if(wordList == null || wordList.size() == 0 || !wordList.contains(endWord)){
            return 0;
        }
        Set<String> WordSet = new HashSet<>(wordList);  // 可用可不用，比wordList.contains要快一些
        Set<String> used = new HashSet<>();         // 在BFS的时候防止遍历到重复元素
        int step = 1;                               // 步数计数器（依据题意初始化为1）

        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);

        while (!queue.isEmpty()){
            // 这种BFS是典型的层序遍历样式————因为从这一层到下一层，step + 1
            int size = queue.size();
            for(int i = 0; i < size; i++){
                String s = queue.poll();
                char[] arr = s.toCharArray();
                // 对于该字符串的每一个位置的字母，尝试用26种字母替换【这一步是我们想省也省不了的】
                for(int j = 0; j < s.length(); j++){
                    for(int k = 'a'; k < 'a' + 26; k++){
                        if(arr[j] == (char)k){
                            continue;
                        }
                        // 暂存一下，一会儿用来复原
                        char tmp = arr[j];
                        arr[j] = (char)k;
                        String nextS = String.valueOf(arr);
                        if(nextS.equals(endWord)){
                            // 成功转化为endWord ! ! !
                            return step + 1;
                        }else{
                            // 入队
                            if(WordSet.contains(nextS) && !used.contains(nextS)){
                                queue.offer(nextS);
                                used.add(nextS);
                            }
                        }
                        // 复原
                        arr[j] = tmp;
                    }
                }
            }
            step++;
        }
        return 0;
    }
}

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if(wordList == null || wordList.size() == 0 || !wordList.contains(endWord)){
            return 0;
        }
        Set<String> wordSet = new HashSet<>(wordList);
        Set<String> used = new HashSet<>();
        int step = 1;

        Queue<String> queue1 = new LinkedList<>();      // 从beginWord开始的队列
        Queue<String> queue2 = new LinkedList<>();      // 从endWord开始的队列
        queue1.offer(beginWord);
        queue2.offer(endWord);

        while (!queue1.isEmpty() && !queue2.isEmpty()){
            // 短的队列作为当前队列queue
            Queue<String> queue = (queue1.size() < queue2.size() ? queue1 : queue2);
            // 另一个队列作为目标集合target
            Set<String> target = new HashSet<>((queue1.size() >= queue2.size() ? queue1 : queue2));
            // 其余跟单向的BFS一样
            int size = queue.size();
            for(int i = 0; i < size; i++){
                String s = queue.poll();
                char[] arr = s.toCharArray();
                for(int j = 0; j < s.length(); j++){
                    for(int k = 'a'; k < 'a' + 26; k++){
                        if(arr[j] == k){
                            continue;
                        }
                        char tmp = arr[j];
                        arr[j] = (char)k;
                        String nextS = String.valueOf(arr);
                        if(target.contains(nextS)){
                            return step + 1;
                        }else{
                            if(wordSet.contains(nextS) && !used.contains(nextS)){
                                queue.offer(nextS);
                                used.add(nextS);
                            }
                        }
                        arr[j] = tmp;
                    }
                }
            }
            step++;
        }
        return 0;
    }
}