static int maxLength(List<Integer> arr) {
        int n = arr.size();
        int ans = 0;
        int i = 0;

        while (i < n) {
            while (i < n && arr.get(i) == 0) {
                i++;
            }

            int start = i;
            int negCount = 0;
            int firstNeg = -1;
            int lastNeg = -1;

            while (i < n && arr.get(i) != 0) {
                if (arr.get(i) < 0) {
                    negCount++;
                    if (firstNeg == -1) {
                        firstNeg = i;
                    }
                    lastNeg = i;
                    }
                i++;
            }
            if (negCount % 2 == 0) {
                ans = Math.max(ans, i - start);
            } else {
                if (firstNeg != -1) {
                    ans = Math.max(ans, i - firstNeg - 1);
                }
                if (lastNeg != -1) {
                    ans = Math.max(ans, lastNeg - start);
                }
            }
            i++;
        }

        return ans;
    }

static int minimumPouringWaterPenalty(List<Integer> parent, List<Integer> waterLevel, int overhydratedPenalty, int underhydratedPenalty) {
        Map <Integer, List<Integer>> map = new HashMap<Integer,List<Integer>>();
        for(int i = 0; i < parent.size(); i++){
            map.putIfAbsent(parent.get(i), new ArrayList<>());
            map.get(parent.get(i)).add(i);
        }
        int [][] waterL = new int [parent.size()][2];
        for(int [] arr : waterL){
            Arrays.fill(arr,-1);
        }
        dfs(0,waterL,waterLevel,map);
        int ifNoWater =  waterL[0][1]*underhydratedPenalty;
        int globalMin = Integer.MAX_VALUE;
        for(int i = 0; i < parent.size(); i++){
            int currMax = 0;
            globalMin = Math.min(globalMin,(ifNoWater - waterL[i][1]*underhydratedPenalty + waterL[i][0]*overhydratedPenalty));
        }
        return globalMin;
}

public static int[] dfs(int node, int [][] waterL, List<Integer> waterLevel, Map <Integer, List<Integer>> map){
    int [] total = new int[2];
    total[0] = 0;
    total[1] = 0;
    if(waterLevel.get(node) > 0){
        total[0] +=1;
    }
    else if(waterLevel.get(node) < 0){
        total[1] += 1;
    }
    if(waterL[node][0] != -1){
        return waterL[node];
    }
    if(map.get(node)!= null){
        for(int i : map.get(node)){
            int [] temp = dfs(i, waterL,waterLevel,map);
            total[0] += temp[0];
            total[1] += temp[1];
        }
    }
    waterL[node] = total;
    return total;
}

static int findMinDays(int n, int m) {
        int res = 0;
        while (n < m) {
            if ((m & 1) == 1) {
                m++;
            } else {
                m /= 2;
            }
            res++;
        }
        return res + (n - m);
    }