RMQ наоборот

import java.io.*;
import java.util.*;

public class Main {

    public static class MyList implements Comparable<MyList> {
        private int left;
        private int right;
        private int value;

        MyList(int left, int right, int value) {
            this.left = left;
            this.right = right;
            this.value = value;
        }

        int getLeft() {
            return left;
        }

        int getRight() {
            return right;
        }

        int getValue() {
            return value;
        }

        @Override
        public int compareTo(MyList list) {
            if (this.left == list.left) {
                if (this.value == list.value) return this.right - list.left;
                return -this.value + list.value;
            }
            return this.left - list.left;
        }
    }

    private static int[] t;
    private static int value;
    private static boolean canHasAns = true;

    private static void useMin(int v, int left, int right, int a, int b) {
        if (a > right || b < left) return;
        if (a == left && b == right) {
            if (t[v] > value && t[v] != Integer.MAX_VALUE) {
//                canHasAns = false;
                return;
            }
            t[v] = value;
            return;
        }
        int mid = (left + right) / 2;
        useMin(v * 2 + 1, left, mid, a, Math.min(b, mid));
        useMin(v * 2 + 2, mid + 1, right, Math.max(a, mid + 1), b);
    }

    private static void pushMin(int v) {
        if (v * 2 + 2 < t.length) {
            int v_left = v * 2 + 1;
            t[v_left] = value;
            v_left++; // стал v_right
            t[v_left] = value;
        }
    }

    private static void setMin(int i) {
        t[i] = Math.min(t[i * 2 + 1], t[i * 2 + 2]);
    }

    public static void main(String[] args) {
        try (Scanner in = new Scanner(new FileReader("rmq.in")); BufferedWriter writer = new BufferedWriter(new FileWriter("rmq.out"))) {
//        Scanner in = new Scanner(System.in);
            // БЛОК 1
            int n = in.nextInt();
            int m = in.nextInt();
            MyList megaList[] = new MyList[m];
            for (int i = 0; i < m; i++)
                megaList[i] = new MyList(in.nextInt() - 1, in.nextInt() - 1, in.nextInt());
//            Arrays.sort(megaList);

            // БЛОК 2
            // пытаемся построить на ДО
            int newN = getNewN(n);
            t = new int[newN * 2 - 1];
            for (int i = 0; i < newN * 2 - 1; i++)
                t[i] = Integer.MAX_VALUE;
            for (int i = 0; i < m; i++) {
                int mainLeft = megaList[i].getLeft();
                int mainRight = megaList[i].getRight();
                value = megaList[i].getValue();
                useMin(0, 0, newN - 1, mainLeft, mainRight);
                if (!canHasAns) {
                    System.out.println("inconsistent");
                    return;
                }
            }

            // посчитать res
            pushUntilLeave(0);
            int[] res = new int[n];
            for (int i = 0; i < n; i++) {
                res[i] = t[newN - 1 + i];
            }
            System.out.println(Arrays.toString(res));

            // БЛОК 3
            // check on segment tree:
            t = new int[newN * 2 - 1];
            // build
            for (int i = 0; i < newN * 2 - 1; i++)
                t[i] = Integer.MAX_VALUE;
            System.arraycopy(res, 0, t, newN - 1, n);
            for (int i = newN - 2; i >= 0; i--)
                setMin(i);
            //
            for (MyList i : megaList) {
                int left = i.getLeft();
                int right = i.getRight();
                int value = i.getValue();
                int k = getMin(0, 0, newN - 1, left, right);
                if (value != k) {
                    writer.write("inconsistent");
                    System.out.println("inconsistent");
                    return;
                }
            }
            writer.write("consistent" + '\n');
            System.out.println("consistent" + '\n');
            for (int i = 0; i < n; i++) {
                writer.write(res[i] + " ");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void pushUntilLeave(int v) {
        if (v * 2 + 2 < t.length) {
            int v_left = v * 2 + 1;
            if (t[v_left] == Integer.MAX_VALUE || t[v_left] < t[v] && t[v] != Integer.MAX_VALUE)
                t[v_left] = t[v];
            pushUntilLeave(v_left);
            v_left++; // стал v_right
            if (t[v_left] == Integer.MAX_VALUE || t[v_left] < t[v] && t[v] != Integer.MAX_VALUE)
                t[v_left] = t[v];
            pushUntilLeave(v_left);
        }
    }

    private static int getMin(int v, int left, int right, int a, int b) {
        if (a > right || b < left) return Integer.MAX_VALUE;
        if (a == left && b == right) return t[v];
        int mid = (left + right) / 2;
        return Math.min(getMin(v * 2 + 1, left, mid, a, Math.min(b, mid)),
                getMin(v * 2 + 2, mid + 1, right, Math.max(a, mid + 1), b));
    }

    private static int getNewN(int n) {
        int res = 1;
        while (res < n)
            res <<= 1;
        return res;
    }
}