【leetcode 春季比赛3题 二叉搜索树染色】广度搜索

暴力：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeSet;

/**
 * Definition for a binary tree node. public class TreeNode { int val; TreeNode
 * left; TreeNode right; TreeNode(int x) { val = x; } }
 */
/**
 * [64,22,92,18,52,67,null,8,null,27,59,null,68,0,null,null,30,null,null,null,91]
 * [[0,27,30],[1,18,91],[0,18,59]]
 * @author butterfly
 *
 */
class Solution {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(64);

        root.right = new TreeNode(92);
        root.left = new TreeNode(22);

        root.left.left = new TreeNode(18);
        root.left.right = new TreeNode(52);
        root.right.left = new TreeNode(67);

        root.left.left.left = new TreeNode(8);
        root.left.right.left = new TreeNode(27);
        root.left.right.right =new TreeNode(59);
        root.right.left.right = new TreeNode(68);
        root.left.left.left.left = new TreeNode(0);
        root.left.right.left.right = new TreeNode(30);
        root.right.left.right.right = new TreeNode(91);

        Solution solution = new Solution();
        int ans = solution.getNumber(root, new int[][]{
            {0,27,30},{1,18,91},{0,18,59}
        });
        System.out.println(ans);
    }
    Map<Integer, Integer> idxMap = new HashMap<>();

    class Range {
        int start;
        int end;

        @Override
        public int hashCode() {
            return Objects.hash(this);
        }

        @Override
        public boolean equals(Object obj) {
            Range other = (Range) obj;
            if (end != other.end)
                return false;
            if (start != other.start)
                return false;
            return true;
        }

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

        boolean contains(Range range) {
            if (this.start <= range.start &&  range.end <=this.end) {
                return true;
            }
            return false;
        }

        boolean hasJiaoji(Range range) {
            if (range.start >= this.start && range.start <= this.end) {
                return true;
            }
            if (range.end >= this.start && range.end <= this.end) {
                return true;
            }
            return false;
        }

        Range chaji(Range range) {
            if (range.start >= this.start && range.start <= this.end) {
                return new Range(this.start, range.start - 1);
            } else if (range.end >= this.start && range.end <= this.end) {
                return new Range(range.end + 1, this.end);
            }
            return null;
        }

        List<Range> chaji2(Range range){
            List<Range> list = new ArrayList<>();
            if( this.contains(range)){
                if(this.start < range.start) {
                    list.add(new Range(this.start,range.start-1));
                }
                if( this.end > range.end){
                    list.add(new Range(range.end+1,this.end));
                }
                return list;
            }
            return null;
        }

        Range union(Range range) {
            if (contains(range)) {
                return new Range(range.start,range.end);
            } else if (range.contains(this)) {
                return new Range(this.start,this.end);
            }

            else if (hasJiaoji(range)) {
                if (range.start >= this.start && range.start <= this.end) {
                    return new Range(this.start, range.end);
                } else {
                    return new Range(range.start, this.end);
                }
            } else {
                return null;
            }
        }

        private Solution getOuterType() {
            return Solution.this;
        }

    }

    void travel(List<Integer> list, TreeNode root) {
        if (root != null) {
            list.add(root.val);
            travel(list, root.left);
            travel(list, root.right);
        }
    }

    public int getNumber(TreeNode root, int[][] ops) {
        List<Integer> list = new ArrayList();
        travel(list, root);
        Collections.sort(list);
        idxMap = new HashMap();
        for (int i = 0; i < list.size(); i++) {
            idxMap.put(list.get(i), i);
        }

        TreeSet<Range> redRangeList = new TreeSet<>(new Comparator<Range>() {

            @Override
            public int compare(Range o1, Range o2) {
                return o1.start - o2.start;
            }
        });

        for (int i = 0; i < ops.length; i++) {
            int type = ops[i][0];
            int s = ops[i][1];
            int e = ops[i][2];

            int start = idxMap.get(s);
            int end = idxMap.get(e);

            if (type == 0) {
                if (redRangeList.size() == 0) {
                    continue;
                }

                Range lanRange = new Range(start, end);
                Iterator<Range> it = redRangeList.iterator();
                while (it.hasNext()) {
                    Range redRange = it.next();
                    if (lanRange.contains(redRange)) {
                        it.remove();
                    }
                    if (redRange.start > lanRange.end) {
                        break;
                    }
                }

                if (redRangeList.size() == 0) {
                    continue;
                }

                List<Range> added = new ArrayList<>();
                boolean flag = false;
                it = redRangeList.iterator();
                while (it.hasNext()) {
                    Range range = it.next();
                    if (range.start > lanRange.end) {
                        break;
                    }
                    if(range.contains(lanRange)) {
                        flag = true;
                        List<Range> tmp = range.chaji2(lanRange);
                        it.remove();
                        added.addAll(tmp);
                    }
                    else if( range.hasJiaoji(lanRange)  ){
                        flag = true;
                        Range toAdd = range.chaji(lanRange);
                        added.add(toAdd);
                        it.remove();
                    }
                }
                for(Range add:added){
                    redRangeList.add(add);
                }
                if (!flag) {
                    // 都没有交集
                }
            }
            if (type == 1) {
                Range newRedRange = new Range(start, end);
                Iterator<Range> it = redRangeList.iterator();
                while (it.hasNext()) {
                    Range redRange = it.next();
                    if (newRedRange.contains(redRange)) {
                        it.remove();
                    }
                    if (redRange.start > newRedRange.end) {
                        break;
                    }
                }
                //
                boolean flag  = true;
                it = redRangeList.iterator();
                while (it.hasNext()) {
                    Range range = it.next();
                    if (range.start > newRedRange.end) {
                            break;
                    }
                    if( range.contains(newRedRange)) {
                        flag = false;
                        break;
                    }
                    else if( range.hasJiaoji(newRedRange)){
                        Range toAdd = range.union(newRedRange);
                        it.remove();
                        newRedRange = new Range(toAdd.start,toAdd.end);
                    }
                }
                if(flag)
                    redRangeList.add(newRedRange);
            }
        }
        int ans = 0;
        for(Range range:redRangeList){
            ans +=(range.end - range.start+1);
        }

        return ans;
    }
}