Question

我想制作一个以简单的方式在电影院中分配席位的应用程序。

我有一个LinkedList，随机填充0'座位可用'或1'座位被采取'。这个LinkedList是由变量int'tacesTotal'生成的，然后LinkedList用Math.random函数填充1或0。

这个想法是用户给出一个变量，即他们想要预订的座位数，之后，（可能是递归的）方法将寻找（例子）5个标有0（可用）的座位。 / p>

如果在彼此之后（旁边）没有可用的5个座位，则该方法必须寻找4个可用座位和1个座位分开。如果没有4个座位，应用程序将寻找3个席位和2个席位等。

我的第一个问题是;我知道我可以使用LinkedList.contains（）来检查是否存在某个值，但是如何检查（例如）0是否连续5次出现？

我的第二个问题是;如果没有5个座位，我该如何处理这个方法，我将需要寻找4个座位和1个座位（例如）？

我真的坚持这一点，非常感谢帮助。

public class Main {

    static int seatCount = 10;
    int verzoekAantal = 3;
    int consecutiveLength = 0; // Consecutive free seats length
    int index = 0;
    int startIndex = -1; // Store the start of consecutive free seats
    LinkedList<Seat> consecutiveList = new LinkedList<>(); // Store startIndex -> length

    public static void main(String[] args) {
//        System.out.println(Arrays.toString(fillList(seatCount).toArray()));
        System.out.println(fillSeats(3).toString());
    }

    //Deze methode geeft via de Math package een willekeurig getal, 1 (bezet) of 0 (vrij)
    static int giveRandomAvailability() {
        return intValue(Math.random() * 2);
    }


    //Deze methode creëert een LinkedList van grootte 'seatCount' en vult de plaatsen een voor een met 0 of 1 op willekeur
    static LinkedList fillList(int seats){
        LinkedList<Seat> list = new LinkedList<Seat>();
        seats = seatCount;

        for(int i = 0; i < seats; i++){
            Seat seat = new Seat();
            seat.availability = giveRandomAvailability();
            seat.seatNumber = (i + 1);
            list.add(seat);
        }

        return list;
    }

    static Map fillSeats(int n){
        LinkedList<Seat> newList = fillList(seatCount);
        int consecutiveLength = 0; // Consecutive free seats length
        int index = 0;
        int startIndex = -1; // Store the start of consecutive free seats
        int remConsecutiveLength = 0;
        System.out.println(newList.toString());
        Map<Integer, Integer> consecutiveMap = new HashMap<>(); // Store startIndex -> length

        for (Seat seat : newList) {
            if (seat.IsFree()) {
                if (startIndex < 0) {
                    startIndex = index;
                }
                consecutiveLength ++;
            } else {
                consecutiveMap.put(startIndex + 1, consecutiveLength);
                if (consecutiveLength >= n) {
                    System.out.println("SEATS FOUND, " + n + " seats available counting from " + (seat.seatNumber - n));
                }

//                if(consecutiveLength > remConsecutiveLength) {
//                    remConsecutiveLength = consecutiveLength;
//                }
                startIndex = -1;
                consecutiveLength = 0;
            }
            index++;
        }
        if (startIndex >= 0) {
            consecutiveMap.put(startIndex + 1, consecutiveLength);
        }
//                    if (remConsecutiveLength < n) {
//                    while(n > 1) {
//                        System.out.println("Looking for seats which are not next to eachother");
//                        n--;
//                        fillSeats(n);
//                    }
//                }
        Map<Integer, Integer> treeMap = new TreeMap<Integer, Integer>(consecutiveMap);
        return treeMap;
    }
}

Answer 1

回答问题的第一部分：

如果你想找到n个连续的空座位，你必须循环你的LinkedList并计算免费座位，直到你找到n个连续，或者你通过所有座位。

public List<Seat> findNConsecutiveEmptySeats(List<Seat> seats, int n) {
    List<Seat> freeSeats = new LinkedList<Seat>();
    for(Seat s : seats) {
        if(s.isEmpty()) {
            freeSeats.add(s);
        } else {
            freeSeats.clear();
        }
        if(freeSeats.size() >= n) {
            break;
        }
     }
     if(freeSeats.size() < n) {
        freeSeats.clear();
     }
     return freeSeats;
}

要回答问题的第二部分，您需要使用n = 5调用上一个方法。如果返回的列表包含5个席位，那么找到它们很棒，请将其返回。如果它包含一个空列表，则调用n = 4然后n = 1的方法。等...

public List<Seat> findNEmptySeats(List<Seat> seats, int n) {
    List<Seats> freeSeats = findNConsecutiveEmptySeats(seats, n);
    if(freeSeats.size() == n) {
        return freeSeats;
    }
    freeSeats = findConsecutiveEMptySeats(seats, n-1);
    freeSeats.addAll(findConsecutiveEMptySeats(seats, 1));
    if(freeSeats.size() == n) {
        return freeSeats;
    }
    freeSeats = findConsecutiveEMptySeats(seats, n-2);
    freeSeats.addAll(findConsecutiveEMptySeats(seats, 2));
    if(freeSeats.size() == n) {
        return freeSeats;
    }

    ...

}

注意： 此代码不完整，例如在查找n-1个座位后，您需要在找到1个座位之前删除找到的座位，否则你可以找回已经找到的座位。

Answer 2

您需要找到连续席位并存储这些项目。

假设您将座位信息存储在Seat课程中，我们将List<Seat> seats作为输入。 n是您想要找到的座位数。

int consecutiveLength = 0; // Consecutive free seats length
int index = 0;
int startIndex = -1; // Store the start of consecutive free seats
Map<Integer, Integer> consecutiveMap = new HashMap<>(); // Store startIndex -> length

for (Seat seat : seats) {
  if (seat.isFree()) {
    if (startIndex < 0) {
      startIndex = index;
    }
    consecutiveLength ++;
  } else {
    consecutiveMap.put(startIndex, consecutiveLength);
    if (consecutiveLength == n) {
      // Found, do something here
    }
    // Reset
    startIndex = -1;
    consecutiveLength = 0;
  }
  index++;
}

在此之后，您可以访问consecutiveLength中的所有consecutiveMap。

您也可以通过上面consecutiveLength == n块中的测试else立即返回。

通过访问consecutiveLength的每个数字，您可以选择子选项（4连续+ 1单等）

修改

运行代码后，consecutiveMap看起来像

{1 -> 1, 3 -> 4, 8 ->1, ...}

它显示：在索引1处，连续1个席位。

在指数3处，有一个连续4个席位。 ....

您可以通过consecutiveMap.values()
访问列表中的连续长度
它会给你{1, 4, 1, 2, ...}。

并且您的问题减少为：在数组中选择多个项目，使其总和为n。您甚至可以对它们进行排序，以便从较大到较小的连续长度进行选择。

非常简单。

你也可以在这里暴力，因为每排座位数不是很大。

如何在彼此之后检查LinkedList中的多个值？

2 个答案: