Java 访谈点：可以预订酒店。解决方案在IDE上工作，但在站点上不工作

酒店经理必须为下一季处理N个提前预订的房间。他的旅馆有K个房间。预订包含到达日期和离开日期。他想知道旅馆里是否有足够的房间来满足需求。编写一个程序来解决这个问题

输入：
预订到达时间的第一个列表。
预订出发时间的第二个列表。
第三个是K，表示房间的数量

返回：
如果有足够的房间可供N预订，则为true
如果没有足够的房间预订，则为false

我的方法：
Heapsort到达列表，对depart应用相同的更改以维护索引关系。树集用于跟踪下一次签出时间。对于每个迭代：一个来宾被签入，签出时间被添加到TreeSet中。如果发生结帐，将删除一位客人，并从TreeSet轮询下一次结帐。如果发生超售，则返回false

我的解决方案在NetBeans上运行，但在网站上运行时失败。非常感谢您的帮助。
原始问题：

公共布尔酒店（ArrayList到达、ArrayList离开、int K）{
TreeSet ts=new TreeSet（）；//存储和轮询签出时间
分拣（到达、离开）；
int in=0；//当前来宾数
int out=Integer.MAX_VALUE；//下次签出时间
对于（int i=0；i=0；i--）{
heapify（到达、离开、n、i）；
}
//逐个从堆中提取元素
对于（int i=n-1；i>=0；i--）{
//将当前根移动到末尾
int temp=arrival.get（0）；
到达.set（0，到达.get（i））；
到达。设置（i，温度）；
//维持到达：离开关系
int tempD=depart.get（0）；
出发。集合（0，出发。得到（i））；
出发。集合（i，tempD）；
//在缩减的堆上调用max heapify
heapify（到达、离开、i、0）；
}
}
//将以节点i为根的子树重设为
//arr[]中的索引。n是堆的大小
void heapify（数组列表到达，数组列表离开，int n，int i）{
int max=i；//将最大值初始化为根
int l=2*i+1；//左=2*i+1
int r=2*i+2；//右=2*i+2
//如果左子级大于根级
如果（l到达.get（最大））{
最大=l；
}
//如果右边的子对象比目前为止最大的子对象大
如果（rarright.get（最大））{
最大=r；
}
//如果最大的不是根
如果（最大！=i）{
int swap=arrival.get（i）；
到达。设置（i，到达。获取（最大））；
到达。设置（最大，交换）；
//维持到达：离开关系
int swapD=离开。获取（i）；
出发。集合（i，出发。获取（最大））；
出发。集合（最大，swapD）；
//递归地重排受影响的子树
heapify（到达、离开、n、最大）；
}
}
//用于打印heapsort结果
公共作废打印排序（ArrayList到达，ArrayList离开）{
分拣（到达、离开）；
对于（int i=0；i

将TreeSet替换为TreeMap，因为重复的签出时间丢失了

public boolean hotel(ArrayList<Integer> arrive, ArrayList<Integer> depart, int K) {
    TreeMap<Integer, Integer> ts = new TreeMap<>(); // stores and polls checkout times
    sort(arrive, depart);
    int in = 0; // current number of guests
    int out = Integer.MAX_VALUE; // next checkout time
    for (int i = 0; i < arrive.size(); i++) {
        in++; // check in

        // new checkout time is earlier than current
        // no need to put it into ts just to take it out
        if (depart.get(i) < out) {
            // add current checkout to ts for future use
            ts.compute(out, (key, value) -> {
                if (value == null) {
                    return 1;
                } else {
                    return value + 1;
                }
            });
            out = depart.get(i);
        } else {
            ts.compute(depart.get(i), (key, value) -> {
                if (value == null) {
                    return 1;
                } else {
                    return value + 1;
                }
            });
        }

        if (out <= arrive.get(i)) { // check out
            in--;
            // poll next checkout time
            out = ts.firstKey();
            if (ts.get(out) == 1) {
                ts.remove(out);
            } else {
                ts.compute(out, (key, value) -> {
                    return value - 1;
                });
            }                
        }
        if (in > K) { // guests exceed room
            return false;
        }
    }

    return true;
}

公共布尔酒店（ArrayList到达、ArrayList离开、int K）{
TreeMap ts=new TreeMap（）；//存储和轮询签出时间
分拣（到达、离开）；
int in=0；//当前来宾数
int out=Integer.MAX_VALUE；//下次签出时间
对于（int i=0；i{
如果（值==null）{
返回1；
}否则{
返回值+1；
}
});
出去=离开。得到（i）；
}否则{
ts.compute（离开.获取（i），（键，值）->{
如果（值==null）{
返回1；
}否则{
返回值+1；
}
});
}
如果（出去）{
返回值-1；
});
}                
}
如果（in>K）{//客人超过房间
返回false；
}
}
返回true；
}

我建议不要使用treemap，所有在给定arraylist上使用普通逻辑的数据结构都可以解决这个问题

公共类解决方案{
公共布尔酒店（ArrayList到达，ArrayList离开，int K）
public boolean hotel(ArrayList<Integer> arrive, ArrayList<Integer> depart, int K) {
    TreeMap<Integer, Integer> ts = new TreeMap<>(); // stores and polls checkout times
    sort(arrive, depart);
    int in = 0; // current number of guests
    int out = Integer.MAX_VALUE; // next checkout time
    for (int i = 0; i < arrive.size(); i++) {
        in++; // check in

        // new checkout time is earlier than current
        // no need to put it into ts just to take it out
        if (depart.get(i) < out) {
            // add current checkout to ts for future use
            ts.compute(out, (key, value) -> {
                if (value == null) {
                    return 1;
                } else {
                    return value + 1;
                }
            });
            out = depart.get(i);
        } else {
            ts.compute(depart.get(i), (key, value) -> {
                if (value == null) {
                    return 1;
                } else {
                    return value + 1;
                }
            });
        }

        if (out <= arrive.get(i)) { // check out
            in--;
            // poll next checkout time
            out = ts.firstKey();
            if (ts.get(out) == 1) {
                ts.remove(out);
            } else {
                ts.compute(out, (key, value) -> {
                    return value - 1;
                });
            }                
        }
        if (in > K) { // guests exceed room
            return false;
        }
    }

    return true;
}