Hackerrank最大化任务点解决方案

Question

我需要帮助调试我的代码以应对以下挑战 - https://www.hackerrank.com/challenges/maximizing-mission-points/problem

我已按照 - https://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/的代码行。

我的代码如下：

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

class SegmentTreeRMQ {
    int st[][];

    int minVal(int x, int y) {
        return (x < y) ? x : y;
    }

    int getMid(int s, int e) {
        return s + (e - s) / 2;
    }

    int RMQUtil(int sx1, int sy1, int sx2, int sy2, int x1, int y1, int x2, int y2, int index1, int index2)
    {
        // If segment of this node is a part of given range, then
        // return the min of the segment
        if (x1 <= sx1 && y1 <= sy1 && x2 >= sx2 && y2 >= sy2)
            return st[index1][index2];

        // If segment of this node is outside the given range
        if ((sx1 < x1 && sy1 < y1) || (sx2 > x2 && sy2 > y2))
            return Integer.MIN_VALUE;

        // If a part of this segment overlaps with the given range
        int midx = getMid(sx1, sx2);
        int midy = getMid(sy1, sy2);
        return minVal(RMQUtil(sx1, sy1, midx, midy, x1, y1, x2, y2, 2 * index1 + 1, 2 * index2 + 1),
                RMQUtil(midx + 1, midy + 1, sx2, sy2, x1, y1, x2, y2, 2 * index1 + 2, 2 * index2 + 2));
    }

    int RMQ(int n, int m, int x1, int y1, int x2, int y2)
    {
        // Check for erroneous input values
        /*if (x1< 0 || x2 > n - 1 || x1 > x2) {
            System.out.println("Invalid Input "+x1+" "+x2);
            return -1;
        }
        if (y1< 0 || y2 > m - 1 || y1 > y2) {
            System.out.println("Invalid Input");
            return -1;
        }*/


        return RMQUtil(0, 0, n - 1, m - 1, x1, y1, x2, y2, 0, 0);
    }

    int constructSTUtil(int arr[][], int x1, int y1, int x2, int y2, int si, int sj)
    {
        // If there is one element in array, store it in current
        //  node of segment tree and return
        if (x1 == x2 && y1 == y2) {
            st[si][sj] = arr[x1][y1];
            return arr[x1][y1];
        }

        // If there are more than one elements, then recur for left and
        // right subtrees and store the minimum of two values in this node
        int midx = getMid(x1, x2);
        int midy = getMid(y1, y2);
        st[si][sj] = minVal(constructSTUtil(arr, x1, y1, midx, midy, si * 2 + 1, sj * 2 + 1),
                constructSTUtil(arr, midx + 1, midy + 1, x2, y2, si * 2 + 2, sj * 2 + 2));
        return st[si][sj];
    }

    void constructST(int arr[][], int n, int m)
    {
        // Allocate memory for segment tree

        //Height of segment tree
        int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
        int y = (int) (Math.ceil(Math.log(m) / Math.log(2)));
        //Maximum size of segment tree
        int max_size_x = 2 * (int) Math.pow(2, x) - 1;
        int max_size_y = 2 * (int) Math.pow(2, y) - 1;
        st = new int[max_size_x][max_size_y]; // allocate memory

        // Fill the allocated memory st
        constructSTUtil(arr, 0, 0, n - 1, m - 1, 0, 0);
    }
}

class City implements Comparator<City> {
    int latitude;
    int longitude;
    int height;
    int points;
    public City() {

    }
    public int compare(City c1, City c2){
        return c1.height - c2.height;
    }
}

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int d_lat = in.nextInt();
        int d_long = in.nextInt();
        ArrayList<City> cities = new ArrayList<City>();
        for(int a0 = 0; a0 < n; a0++){
            int latitude = in.nextInt();
            int longitude = in.nextInt();
            int height = in.nextInt();
            int points = in.nextInt();
            // Write Your Code Here
            City city = new City();
            city.latitude = latitude;
            city.longitude = longitude;
            city.height = height;
            city.points = points;
            cities.add(city);
        }
        Collections.sort(cities, new City());
        int max_lat = Integer.MIN_VALUE;
        int min_lat = Integer.MAX_VALUE;
        int max_long = Integer.MIN_VALUE;
        int min_long = Integer.MAX_VALUE;
        for(City city : cities){
            if(city.latitude > max_lat){
                max_lat = city.latitude;
            }
            if(city.latitude < min_lat){
                min_lat = city.latitude;
            }
            if(city.longitude > max_long){
                max_long = city.longitude;
            }
            if(city.longitude < min_long){
                min_long = city.longitude;
            }
        }
        int lat_diff = max_lat-min_lat;
        int long_diff = max_long-min_long;
        int[][] arr = new int[lat_diff+1][long_diff+1];
        for(City city : cities){
            arr[city.latitude - min_lat ][city.longitude - min_long]=city.points;
        }
        SegmentTreeRMQ tree = new SegmentTreeRMQ();
        tree.constructST(arr, lat_diff, long_diff);
        int max_till_now = Integer.MIN_VALUE;
        int max_till_city = 0;
        for(City city : cities){
            int x = city.latitude;
            int y = city.longitude;
            max_till_city = tree.RMQ(lat_diff+1,long_diff+1,x-d_lat,y-d_long,x+d_lat,y+d_long);
            if(max_till_now < max_till_city){
                max_till_now = max_till_city;
            }
        }
        System.out.println(max_till_now);
        in.close();
    }
}

我需要知道的是，我还需要更新查询吗？如果是，请给我一些指示。

谢谢， Apoorv Srivastava