Question

我已经实施了一个简短的算法，可以判断所有酒店预订是否可行。问题与Keywords and Reserved Words非常相似，但我试图实现自己的逻辑。

（非常抱歉这么久的解释）

在我的算法中

int K =可用房间数
ArrayList<Integer>到达=来宾的到达时间
ArrayList<Integer>离开=客人离开时间
int arrival_guest =下一位客人
ArrayList<ArrayList<Integer>>安排=房间分配

例如

到达= [1,3,5]
离开= [2,6,8]和
K = 1

现在，在我们开始迭代之前， ArrayList<ArrayList<Integer>> arrange将是[[2]]，因为最初所有房间都可用，int arriving_guest = 1当第一位客人入住时，它将指向下一位客人< /强>

现在进行第一次迭代，其中客人的到达时间为3，出发时间为6

检查第一个房间是否可用

由于首次出发时间为2，所以他的房间可以送给第二位客人，因此arrange将成为[[2,6]]

递增arriving_guest以指向下一位客人

现在进行第二次迭代，其中客人的到达时间为5，出发时间为8

检查第一个房间是否可用

由于第2位客人的出发时间为6，所以他的房间不能送给第3位客人，因此应为第3位客人分配新房间，arrange将成为[[2,6],[8]]

递增arriving_guest以指向下一位客人

在算法结束时

所需房间= arrange.size() = 2

可用房间= K = 1

因此它会返回上面的false值

如果我将算法应用于以下测试用例，则无法

到达：[14,29,0,35,34,15,17,7,28,13,40,28,11,40]

离开：[51,77,37,63,76,25,57,23,40,32,63,41,21,68]

K：9

我的算法是

private static boolean bookingsPossible(ArrayList<Integer> arrive, ArrayList<Integer> depart, int K) { // TODO Auto-generated method stub int arriving_guest = 1; ArrayList<ArrayList<Integer>> arrange = new ArrayList<ArrayList<Integer>>(); arrange.add(new ArrayList<Integer>(){{ add(depart.get(0)); }}); for(int i=0;i<depart.size();i++) { int temp = 0; System.out.println("i is "+i); while(temp <= i) { System.out.println("arriving guest "+arriving_guest); if(arriving_guest < arrive.size() && arriving_guest < depart.size()) { System.out.println("i is in if "+i); if(temp <= (arrange.size() -1)) { System.out.println("Temp is "+temp); int vacatetime = arrange.get(temp).get(arrange.get(temp).size() - 1); System.out.println("Vacate Time "+vacatetime+" Arrival Time "+arrive.get(arriving_guest)); if(vacatetime <= arrive.get(arriving_guest)) { arrange.get(temp).add(depart.get(arriving_guest)); arriving_guest++; System.out.println("Arrangement made "+arrange.toString()); break; } } else { System.out.println("Adding room"); ArrayList<Integer> p = new ArrayList<Integer>(); p.add(depart.get(arriving_guest)); arrange.add(p); System.out.println("Arrangement made "+arrange.toString()); arriving_guest++; break; } } else { break; } temp++; } } System.out.println("Rooms needed "+arrange.size()); System.out.println("Final Arrangement made "+arrange.toString()); return arrange.size() <= K ? true : false; }

Answer 1

如果我们对问题进行概括，则变为以下：给定间隔（a_i，b_i），找到最大数量的分段交叉点。

算法如下：

制作另一组数组：（a_i，false）或（b_i，true），其中第一个值表示值，第二个是布尔标志，如果它是一个开始或段的结尾。
按第一个坐标排序，在平局的情况下，确保结束对先行。
遍历生成的数组并保持本地房间数。如果它是段的开头，则增加一个房间数，如果它是最终减少。

以下是算法的实现：

public class HotelBooking {

    private static class Pair implements Comparable<Pair>{
        final int x;
        final boolean isEnd;

        public Pair(int x, boolean isEnd) {
            this.x = x;
            this.isEnd = isEnd;
        }

        @Override
        public int compareTo(Pair o) {
            int cmp = this.x - o.x;
            //in case of tie be sure that end pair comes first
            return cmp == 0 ? isEnd ? -1 : 1 : cmp;
        }
    }

    public boolean hotel(ArrayList<Integer> arrive, ArrayList<Integer> depart, int K) {
        if(arrive.size() == 0 || K == 0) return false; //base case
        else if(arrive.size() == 1 && K > 1) return false; //base case
        else {
            int n = depart.size();
            List<Pair> intervals = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                intervals.add(new Pair(arrive.get(i), false));
                intervals.add(new Pair(depart.get(i), true));
            }
            Collections.sort(intervals);
            int count = 0; //
            int maxRooms = 0;
            for (int i = 0; i < intervals.size(); i++) {
                Pair pair = intervals.get(i);
                count += pair.isEnd ? -1 : 1;
                maxRooms = Math.max(maxRooms, count);
            }

            return maxRooms > K ? false : true;
        }
    }
}

酒店预订可能

1 个答案: