[leetcode] Partition Labels

A string S of lowercase letters is given. We want to partition this string into as many parts as possible so that each letter appears in at most one part, and return a list of integers representing the size of these parts.

Example 1:

Input: S = "ababcbacadefegdehijhklij"
Output: [9,7,8]
Explanation:
The partition is "ababcbaca", "defegde", "hijhklij".
This is a partition so that each letter appears in at most one part.
A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.

Note:

1. S will have length in range [1, 500].
2. S will consist of lowercase letters ('a' to 'z') only.

---

分析：题目翻译一下：给定一个字符串，要求将字符串分片，使得每一片中出现的字符仅在这个分片中出现。

第一个思路：用一map保存每个字符串出现的次数，如果走到某个字符处，前面所有字符对应的值都为0，那么就说明这个分片找到了。根据这个原理，可以写出下面代码：

class Solution {
    public List<Integer> partitionLabels(String S) {
        Map<Character,Integer> map = new HashMap<>();
        Set<Character> set = new HashSet<>();
        List<Integer> list = new ArrayList<>();

        for ( char c : S.toCharArray() )
            map.put(c,map.getOrDefault(c,0)+1);
        //System.out.println(map);

        int left = 0;
        int count = 0;
        while ( left < S.length() ){
            char c = S.charAt(left);
            set.add(c);
            map.put(c,map.get(c) - 1);
            count += 1;
            boolean ise = true;
            for ( char temp : set ){
                if ( map.get(temp) != 0 ) ise = false;
            }
            if ( ise ){
                list.add(count);
                count = 0;
                set.clear();
            }
            left ++;
        }
        return list;
    }
}

    运行时间42ms，非常耗时。不过这个方法是最直观的方法。下面分析如何改进。

第二个思路：上一个方法是不停的对map进行-1操作，然后判断是否为0。这个题目也可以用map来保存每个字符最后出现的位置，并且用一个变量保存前面出现过的字符中最远的位置。如果cur指针走到这个位置，就说明前面的都被访问过了，就得到了这个分片。show me the code：

class Solution {
    public List<Integer> partitionLabels(String S) {
        Map<Character,Integer> map = new HashMap<>();
        List<Integer> list = new ArrayList<>();
        
        for ( int i = 0 ; i < S.length() ; i ++ )
            map.put(S.charAt(i),i);

        int left = 0, right = 0, cur = 0;
        while ( cur < S.length() ){
            char c = S.charAt(cur);
            right = Math.max(right,map.get(c));
            if ( cur == right ){
                list.add(right-left+1);
                left = right+1;
            }
            cur++;
        }
        return list;
    }
}

  运行时间14ms，击败36.70%，还是很慢。为什么呢？

第三个思路：其实也不散完整的思路，对上面进行改进，因为map工作量比较大，因此不妨用一个26长度的数组取代map(这个方法在用到map和字符串的时候非常常见)。

class Solution {
    public List<Integer> partitionLabels(String S) {
        List<Integer> list = new ArrayList<>();
        int[] a = new int[26];
        for ( int i = 0 ; i < S.length() ; i ++ )
            a[S.charAt(i)-'a'] = i;

        int left = 0, right = 0, cur = 0;
        while ( cur < S.length() ){
            char c = S.charAt(cur);
            right = Math.max(right,a[c-'a']);
            if ( cur == right ){
                list.add(right-left+1);
                left = right+1;
            }
            cur++;
        }
        return list;
    }
}

  运行时间12ms，击败52.83%。已经尽力了。。

总结：关键在于想到map中保存每个字符最后出现的次数，并且在循环过程中如何判断是否满足分片条件。