Given a string

s

and a list of strings

dict

, you need to add a closed pair of bold tag

<

b

>

and

<

/b

>

to wrap the substrings in s that exist in dict. If two such substrings overlap, you need to wrap them together by only one pair of closed bold tag. Also, if two substrings wrapped by bold tags are consecutive, you need to combine them.

Example 1:

Input:

s = "abcxyz123"
dict = ["abc","123"]

Output:

"
<
b
>
abc
<
/b
>
xyz
<
b
>
123
<
/b
>
"

Example 2:

Input:

s = "aaabbcc"
dict = ["aaa","aab","bc"]

Output:

"
<
b
>
aaabbc
<
/b
>
c"

Note:

1. The given dict won't contain duplicates, and its length won't exceed 100.
2. All the strings in input have length in range [1, 1000].

class Solution {
    private class Interval{
        int start;
        int end;

        public Interval(int start, int end){
            this.start = start;
            this.end = end;
        }
    }

    public String addBoldTag(String s, String[] dict) {

        if (s == null || dict == null || s.length() == 0 || dict.length == 0) return s;

        List<Interval> intervals = new ArrayList<>();
        for (String word : dict){
            for (int i = 0; i < s.length(); i++){
                if (s.startsWith(word, i)){
                    int start = i;
                    int end = start + word.length() - 1;
                    intervals.add(new Interval(start, end));
                }
            }
        }

        Collections.sort(intervals, (a, b) -> {
            if (a.start == b.start){
                return a.end - b.end;
            }
            return a.start - b.start;
        });
        //System.out.println("interval size: " + intervals.size());

        if (intervals.size() == 0) return s;

        List<Interval> sorted = new ArrayList<>();
        Interval prev = intervals.get(0);
        //System.out.println("prev: " + prev);
        for (int i = 1; i < intervals.size(); i++){
            Interval cur = intervals.get(i);
            if (prev.end >= cur.start - 1){
                prev.end = Math.max(prev.end, cur.end);
            }
            else{
                sorted.add(prev);
                prev = cur;
            }
        }
        sorted.add(prev);

        //System.out.println("sorted: " + sorted.get(0).start + " " + sorted.get(0).end);

        int index = 0;
        StringBuilder sb = new StringBuilder();
        int intervalIndex = 0;
        Interval cur = sorted.get(intervalIndex);
        while (index < s.length()){
            if (index != cur.start){
                sb.append(s.charAt(index));
                index++;
                continue;
            }

            sb.append("<b>");
            sb.append(s.substring(cur.start, cur.end + 1));
            sb.append("</b>");
            index = cur.end + 1;

            //System.out.println("sb now: " + sb.toString() + " index: " + index);

            intervalIndex++;
            if (intervalIndex == sorted.size()) break;
            cur = sorted.get(intervalIndex);
        }

        for (; index < s.length(); index++){
            sb.append(s.charAt(index));
        }

        return sb.toString();
    }
}