java四叉二维线段树，TLE4个过不去，有大佬能帮忙看一下复杂度对么？

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
import java.util.Comparator;

public class Main implements Runnable {
    static BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    static StreamTokenizer st = new StreamTokenizer(buf);

//    private static InputStream getInputStream() {
//        try {
//            return new FileInputStream("/Users/hl/Downloads" +
//                    "/P3810_5.in");
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        }
//        return System.in;
//    }

    public static int nextInt() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }

    public static String nextString() throws IOException {
        st.nextToken();
        return st.sval;
    }

    public static void setNumStrMode() {
        st.ordinaryChars('0', '9');
        st.wordChars('0', '9');
        st.ordinaryChar('.');
        st.wordChars('.', '.');
    }

    //main
    public static void main(String[] args) {
        Main main = new Main();
        new Thread(null, new Main(), "", 1 << 29).start();
    }

    @Override
    public void run() {
        mainFunc();
    }

    private void mainFunc() {
        try {
            int n = nextInt();
            int k = nextInt();
            int[][] elems = new int[n][3];
            for (int i = 0; i < n; i++) {
                elems[i][0] = nextInt();
                elems[i][1] = nextInt();
                elems[i][2] = nextInt();
            }
            int[] f = solve(n, k, elems);

            for (int x : f) {
                bw.write(x + "\n");
            }
            bw.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //code
    public int[] solve(int n, int k, int[][] elems) {
        Arrays.sort(elems, new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                return a[0] - b[0];
            }
        });
        rL = 1;
        rR = k;
        rB = 1;
        rT = k;

        int[] f = new int[n];
        int i = 0;
        while (i < elems.length) {
            int j = i;
            while (j < elems.length && elems[j][0] == elems[i][0]) {
                insert(elems[j][1], elems[j][2]);
                j++;
            }
            while (i < j) {
                int q = query(elems[i][1], elems[i][2]);
                f[q - 1]++;
                i++;
            }
        }
        return f;
    }

    int rL, rR, rT, rB;
    SegNode2D root = new SegNode2D();

    private void insert(int x, int y) {
        insert(1, x, x, y, y, root, rL, rR, rB, rT);
    }

    private int query(int x, int y) {
        return query(rL, x, rB, y, root, rL, rR, rB, rT);
    }

    private int query(int x1, int x2, int y1, int y2, SegNode2D node, int nL, int nR, int nB, int nT) {
        if (node == null || x1 > nR || x2 < nL || y1 > nT || y2 < nB) {
            return 0;
        }
        if (x1 <= nL && nR <= x2 && y1 <= nB && nT <= y2) {
            return node.value;
        }

        int ans = 0;

        int midX = nL + (nR - nL >> 1);
        int midY = nB + (nT - nB >> 1);

        if (x1 <= midX && y1 <= midY) {
            ans += query(x1, x2, y1, y2, node.lb, nL, midX, nB, midY);
        }

        if (x2 > midX && y1 <= midY) {
            ans += query(x1, x2, y1, y2, node.rb, midX + 1, nR, nB, midY);
        }

        if (x1 <= midX && y2 > midY) {
            ans += query(x1, x2, y1, y2, node.lt, nL, midX, midY + 1, nT);
        }

        if (x2 > midX && y2 > midY) {
            ans += query(x1, x2, y1, y2, node.rt, midX + 1, nR, midY + 1, nT);
        }
        return ans;
    }

    private void insert(int v, int x1, int x2, int y1, int y2, SegNode2D node, int nL, int nR, int nB, int nT) {
        if (x1 <= nL && nR <= x2 && y1 <= nB && nT <= y2) {
            node.value += v;
            node.tag += v;
            return;
        }
        if (x1 > nR || x2 < nL || y1 > nT || y2 < nB) {
            return;
        }
        pushDown(node);
        int midX = nL + (nR - nL >> 1);
        int midY = nB + (nT - nB >> 1);

        if (x1 <= midX && y1 <= midY) {
            insert(v, x1, x2, y1, y2, node.lb, nL, midX, nB, midY);
        }

        if (x2 > midX && y1 <= midY) {
            insert(v, x1, x2, y1, y2, node.rb, midX + 1, nR, nB, midY);
        }

        if (x1 <= midX && y2 > midY) {
            insert(v, x1, x2, y1, y2, node.lt, nL, midX, midY + 1, nT);
        }

        if (x2 > midX && y2 > midY) {
            insert(v, x1, x2, y1, y2, node.rt, midX + 1, nR, midY + 1, nT);
        }
        pushUp(node);
    }

    private void pushUp(SegNode2D node) {
        node.value = getValue(node.lb) + getValue(node.rb) + getValue(node.lt) + getValue(node.rt);
    }

    private int getValue(SegNode2D node) {
        return node == null ? 0 : node.value;
    }

    private void pushDown(SegNode2D node) {
        if (node.lt == null) {
            node.lt = new SegNode2D();
        }
        if (node.rt == null) {
            node.rt = new SegNode2D();
        }
        if (node.lb == null) {
            node.lb = new SegNode2D();
        }
        if (node.rb == null) {
            node.rb = new SegNode2D();
        }
        if (node.tag > 0) {
            node.lt.value += node.tag;
            node.lt.tag += node.tag;

            node.rt.value += node.tag;
            node.rt.tag += node.tag;

            node.lb.value += node.tag;
            node.lb.tag += node.tag;

            node.rb.value += node.tag;
            node.rb.tag += node.tag;

            node.tag = 0;
        }
    }

    static class SegNode2D {
        int value;
        int tag;

        SegNode2D lt;
        SegNode2D rt;
        SegNode2D lb;
        SegNode2D rb;
    }
    //end code
}