11.17-刷题日结

290. 单词规律https://leetcode-cn.com/problems/word-pattern/

---

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

 我的想法是：

1. 使用split划分str字符串形成数组ret，然后用toCharArray，把pattern变成字符数组pa，判断两个数组长度是否一致，否则false；
2. 然后扫描pa[ i ]，判断map中是否有相应的key，以及对应的value（ret[ i ]）,以免出现不同的key对应相同的value，然后map.put(pa[ i ],ret[ i ]);

3. 再扫描ret，通过map的对应关系，来确定是否ret[ i ]和map.get(pa[i])是否相等，相等就true，否则就false。

class Solution {
    public boolean wordPattern(String pattern, String s) {
        String[] ret = s.split(" ");
        char[] pa = pattern.toCharArray();
        int n = ret.length;
        if(n!=pa.length)
            return false;
        Map<Character,String> map = new HashMap<Character,String>();
        //先扫描一遍pa，找到对应关系
        for(int i =0;i<n;i++){
            //不存在相等的key以及key对应的value
            if(!map.containsKey(pa[i])&& !map.containsValue(ret[i]))
                map.put(pa[i],ret[i]);
        }
        //再扫描ret，通过map的对应关系，来确定是否对应
        for(int i =0;i<n;i++){          
            if(!ret[i].equals(map.get(pa[i])))
                return false;
        }
        return true;
    }
}

 优化后的代码：

看到大佬写的代码，才知道，map.put()，会返回一个值，可以通过返回的值相等来判断

class Solution {
    public boolean wordPattern(String pattern, String str) {
        String[] words = str.split(" ");
        if (words.length != pattern.length()) {
            return false;
        }
        Map<Object, Integer> map = new HashMap<>();
        for (Integer i = 0; i < words.length; i++) {
             /*
                如果key不存在，插入成功，返回null；如果key存在，返回之前对应的value。

                以pattern = "abba", str = "dog cat cat dog"为例，
                第1次：map.put('a',0)返回null，map.put("dog",0)返回null，两者相等；
                第2次：map.put('b',1)返回null，map.put("cat",1)返回null，两者相等；
                第3次：map.put('b',2)返回1，map.put("cat",2)返回1，两者相等；
                第4次：map.put('a',3)返回0，map.put("dog",3)返回0，两者相等，
                结果为 true。

                以pattern = "abba", str = "dog cat cat fish"为例，
                第1次：map.put('a',0)返回null，map.put("dog",0)返回null，两者相等；
                第2次：map.put('b',1)返回null，map.put("cat",1)返回null，两者相等；
                第3次：map.put('b',2)返回1，map.put("cat",2)返回1，两者相等；
                第4次：map.put('a',3)返回0，map.put("fish",3)返回null，两者不相等，
                结果为 false。
            */
            if (map.put(pattern.charAt(i), i) != map.put(words[i], i)) {
                return false;
            }
        }
        return true;
    }
}

763. 划分字母区间https://leetcode-cn.com/problems/partition-labels/

输入：S = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca", "defegde", "hijhklij"。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。

 太菜了，直接看的官方答案，附加自己的理解；

1. 数组list获取每个字符出现的最后一个位置下标；
2. 从左到右遍历字符串，定义变量start和end，end每次都等于当前字符的下标和end的最大值；
3. 当。当前字符的下标和end相等，说明当前片段访问结束，开始下一个片段的访问，让start=end+1；

4. 重复上述过程，直到遍历完字符串。

上述做法使用贪心的思想寻找每个片段可能的最小结束下标，因此可以保证每个片段的长度一定是符合要求的最短长度，如果取更短的片段，则一定会出现同一个字母出现在多个片段中的情况。由于每次取的片段都是符合要求的最短的片段，因此得到的片段数也是最多的。

由于每个片段访问结束的标志是访问到下标 \textit{end}end，因此对于每个片段，可以保证当前片段中的每个字母都一定在当前片段中，不可能出现在其他片段，可以保证同一个字母只会出现在同一个片段。 

class Solution {
    public List<Integer> partitionLabels(String s) {
        int[] last = new int[26];
        int length = s.length();
        for (int i = 0; i < length; i++) {
            last[s.charAt(i) - 'a'] = i;
        }
        List<Integer> partition = new ArrayList<Integer>();
        int start = 0, end = 0;
        for (int i = 0; i < length; i++) {
            end = Math.max(end, last[s.charAt(i) - 'a']);
            if (i == end) {
                partition.add(end - start + 1);
                start = end + 1;
            }
        }
        return partition;
    }
}