Intuition behind using a two pointers approach

I am solving a question on LeetCode.com:

>A string S of lowercase English 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. <br>
For the input: "ababcbacadefegdehijhklij" the output is: [9,7,8]

A highly upvoted solution is as below:

public List<Integer> partitionLabels(String S) {
    if(S == null || S.length() == 0){
        return null;
    }
    List<Integer> list = new ArrayList<>();
    int[] map = new int[26];  // record the last index of the each char

    for(int i = 0; i < S.length(); i++){
        map[S.charAt(i)-'a'] = i;
    }
    // record the end index of the current sub string
    int last = 0;
    int start = 0;
    for(int i = 0; i < S.length(); i++){
        last = Math.max(last, map[S.charAt(i)-'a']);
        if(last == i){
            list.add(last - start + 1);
            start = last + 1;
        }
    }
    return list;
}

I understand what we are doing in the first for loop (we just store the index of the last occurrence of a character), but I am not too sure about the second one:

a. Why do we calculate the max() and compare last==i?
b. How does it help us achieve what we seek - in the above example, when we encounter a at position 8 (0-indexed), what guarantees that we won't encounter, say b, at a position greater than 8? Because, if we do, then considering 8 as the end position of our substring is incorrect.

Thanks!

If we encounter a character S[i] we may cut the string only after it's last occurence, hence map[S.charAt(i)-'a']. We maximize the value in last because we need to ensure that all the processed characters will have their last occurence in the prefix, so we look at the rightmost of such indices, hence the max. If we encounter a character S[i] such that i is it's last occurrence and all characters before have their last occurrences before i, we may add the substring start..i to the result, and set start = i + 1 for the next substring.

The idea is this. Whenever the last occurrence of a particular character matches the current index, it means that this particular character appears only in this part.

To understand this better, just do this.

int last = 0;
int start = 0;
for(int i = 0; i < S.length(); i++){
   last = Math.max(last, map[S.charAt(i)-'a']);
   System.out.println(last+" "+i);
   if(last == i){
      list.add(last - start + 1);
	  start = last + 1;
   }
}

Take your example string "ababcbacadefegdehijhklij".

Now, the output would be

8 0
8 1
8 2
8 3
8 4
8 5
8 6
8 7
8 8
14 9
15 10
15 11
15 12
15 13
15 14
15 15
19 16
22 17
23 18
23 19
23 20
23 21
23 22
23 23

The last occurrence of a is at the 8th position. Now we are at 0th position. Increment i. So, the till we get to 8th position, we cant be sure that each part contains at most 1 character. Suppose the next character is b and it occurs finally in 10th position, then we need to confirm till 10th position.

if(last == i){

}

The above if just confirms that the part is over and we can start a new part from the next index. Before doing this, we are adding the length of the current part to the output.