Set Intersection (InterviewBit)

public class Solution {

    public int setIntersection(ArrayList<ArrayList<Integer>> A) {

        int n = A.size();

        // sort based on ascending order by end values
        // if end value is same, sort based on start value
        // the idea is to keep the range as max as possible from the beginning
        Collections.sort(A, (a,b) -> a.get(1) == b.get(1) ? b.get(0) - a.get(0) : a.get(1) - b.get(1));

        // init:
        // the min set size will be 2 for a given range [x,y] since (x < y) and we can take any two elements from that range
        // we are taking a greedy approach here, by taking the largest values in the set
        // example: [5, 10]
        // we can actually take {5,6} for a valid answer, but it might not be a good idea
        // we have sorted the array in ascending order by end value
        // so if we take the highest values in the current range, there is a larger chance of having an overlap
        // so we should consinder {9,10} -> {secondMaxEnd, maxEnd}
        int maxEnd = A.get(0).get(1);
        int secondMaxEnd = A.get(0).get(1) - 1;
        int setSize = 2;

        // interated from the next range in the list
        for(int i=1; i<n; i++){

            int nextStart = A.get(i).get(0);
            int nextEnd = A.get(i).get(1);

            // example: [1,3][1,4]
            // maxEnd = 3, secondMaxEnd = 2
            // we sorted based on the end value (ascending)
            // the next interval's end must be >= previous one; 4 >= 3
            // maxEnd and secondMaxEnd are the highest values we could have taken for previous range (greedy)
            // if this maxEnd and secondMaxEnd are part of next range (maxEnd >= currentStart && secondMaxEnd >= currentStart)
            // we can use the same maxEnd and secondMaxEnd in the set to have min size, without including any other element in the set
            // that set, for this example will be {2, 3} -> {secondMaxEnd, maxEnd}
            if(maxEnd >= nextStart && secondMaxEnd >= nextStart){
                continue;
            }

            // example: [1,4][4,5]
            // maxEnd = 4, secondMaxEnd = 3
            // maxEnd (4) >= nextStart (4) but secondMaxEnd (3) is not >= nextStart (4) -> previous condition
            // let's check if at least maxEnd is >= nextStart
            // so there is 1 element overlapped, which we can re-use
            // so, we just need to add more extra element to the set (so increase the size by 1)
            // what happens to the maxEnd and secondMaxEnd now?
            // we need to keep the overlapped element and extend the range
            // new maxEnd = 5
            // new secondMaxEnd = 4 (overlapped)

            // interesting example:
            // {secondMax, maxEnd} : {12, 14}  -> {nextStart, nextEnd} : {13, 15}
            // observe that secondMaxEnd will not be always one lower than maxEnd
            // you can take this sample to check:
            // [[4, 6], [2, 10], [6, 12], [12, 14], [11, 14], [13, 15], [3, 19], [8, 20], [7, 20]]
            if(maxEnd >= nextStart){
                secondMaxEnd = maxEnd;
                maxEnd = nextEnd;
                setSize += 1;

            // example: [1,4][5,6]
            // maxEnd = 4, secondMaxEnd = 3
            // we cannot use any existing element (no overlap)
            // so set size will have to be incresed by 2
            // to extend the max range, we will use the new max range
            }else{
                maxEnd = nextEnd;
                secondMaxEnd = nextEnd - 1;
                setSize += 2;
            }


        }

        return setSize;

    }

}