Algorithm 有没有算法可以在航班上连续分配3个座位，同时有一些预定的座位？

我想通过良好的算法来分配连续3个座位，同时有一些预定的座位

基本上，我不想在3个连续免费座位中找到任何一个进行预订？

---

我试图通过贪婪的方式，检查连续3个未预订的座位，然后计算座位总数以分配3个连续的座位。

我对你问题的解释：

你一排有N个座位。有K个座位（1个索引）已预订。查找3个座位中没有预订座位的连续区段的数量

O（K log K）解决方案：

让预定的座位（按顺序）是B1、B2。。。Bk.存储以下元素的排序列表：

[0,B1,B2,...,Bk,N+1]

对于每个自由座位段（2个预订座位之间的所有座位都是自由的），拥有3个座位的连续段的方式数为

max（0，S-2）

，其中S是该段的自由座位数

例如，有10个座位，第3和第9个座位有人

该列表将包含：

[0,3,9,11]

第一部分将有

3-0-1=2

免费座位。因此，max（0,2-2）为0

第二部分将有

9-3-1=5个
免费座位。因此，最大值（0,5-2）为3

第三节将有
11-9-1=1
自由座位。因此，max（0,1-2）为0

因此，有3种方法可以让3个座位中的3个相邻部分

这里的复杂性是
O（K log K）
，因为有
K
元素要在
K log K
时间中排序，每个
K+1
段需要
O（1）
时间进行计算。如果N非常大（数十亿）而K较小（约100000），则更可行

O（N）溶液

每3个座位检查一次，如果都是免费的。如果K大于（百万）而N小于（当然仍然大于或等于K），这是可行的
`公共整数GetAvailableSets（整数n，字符串s）{
字符串str[]=s.split（“”）；
已占用列表=新建ArrayList（）；
int available=0；
占用=数组.asList（str）；
对于（inti=1；iPython中@Benson Lin的O（K log K）解决方案的实现

def解决方案（N:int，S:str，N:int）->int:
"""
返回选项计数
"""
取值范围（N）内的[uuu]为[[]
对于s.split（“”）中的s：
行=int（s[：-1]）-1
如果行>N：
提出例外（“非法预订”）
采取[行].追加（ord（s[-1]）-ord（'A'））
总数=0
对于采用的行：
row.sort（）
行追加（ord（'K'）-ord（'A'）+1）
last=-1
cnt=0
对于范围内的idx（列（行））：
自由座位=第[idx]排-最后-1
cnt+=最大值（0，自由座位-（n-1））
最后=行[idx]
总碳纳米管+=碳纳米管
返回总数
导入java.util.HashMap；
导入java.util.Map；
导入java.util.concurrent.ConcurrentHashMap；
公共类解决方案{
公共静态void main（字符串[]args）{
系统输出打印项次（“countFamilySeats”+familySeats（1，“1D 4C 5E”）；
}
公共静态int familySeats（int planeRows、字符串占用的座位）{
Map seatMap=newhashmap（）；
int countFamilySeats=0；
if（occupiedSeats==null | | occupiedSeats.isEmpty（））{
返回行*3；
}
//对于过道：我已经提到了Z字符
对于（int i=1；i=3&&combinedSeats.contains（“Z”））{
字符串[]温度=combinedSeats.split（“Z”）；
系统输出打印长度（温度长度）；
用于（字符串t1:temp）{
系统输出打印LN（“通道分隔”+t1）；
如果（t1.length（）>=3）
countFamilySeats++；
}
}否则{
System.out.println（“此部分不适用于家庭”+组合座椅）；
}
}
}否则{
countFamilySeats+=3；
}
System.out.println（“直到此行：“+entry.getKey（）+”允许家庭座位：“+countFamilySeats”）；
}
在这里输入代码
返回countFamilySeats；
}
}
我在招聘测试中做了类似的编码工作。我用比特算法完成了这项工作。
一排座位的占用座位图可以编码为位掩码，例如：0b1001000011，其中1表示占用座位
然后我填充所有已占用座位的哈希映射（rowNum->该行的已占用座位映射）

要针对座椅进行测试，按位或使用：测试占用或所需的_掩码==所需的_掩码，
如果所需的掩码是连续座位的编码模式（例如：0001111000或001100000）。对于给定的N行，复杂性将为O（N），假设每行连续座位分配的选项数量有限（最大的飞机A380有10个座位，一行由两个岛隔开，因此所有连续组合都可以编码为位掩码）
您到底想搜索什么？三个连续的免费座位的数量或（基于给定的预订座位）下一棵树是否有连续的空闲座位？@Radinator：是的，我想找到总共可能有3个空闲的有争议的座位来分配，同时编辑了这个问题。我会遍历所有元素，每隔一个座位测试一次。如果是索引n上的空闲座位，测试座位
n-1
和
n+1
是否空闲。或者迭代，测试座位
n
，
n+1
和
n+2
是免费的。@Radinator:你是对的，我也在做同样的事情，但是有没有标准的算法，如果有，那么我想学习。复习：嗨，请不要只用源代码回答。试着提供一个关于你的
//n - number of rows, s- occupied seats
 `public int getAvailableSeats(int n, String s) {
    String str[] = s.split(" ");
    List<String> occupied = new ArrayList<>();
    int available = 0;

    occupied = Arrays.asList(str);

    for(int i = 1; i<= n ; i++) {

            if(!occupied.contains(i+"A") && !occupied.contains(i+"B") && !occupied.contains(i+"C")) {
                available++;
            }
            if(!(occupied.contains(i+"D") && occupied.contains(i+"G"))  && !(occupied.contains(i+"E") || occupied.contains(i+"F"))) {
                available++;
            }
            if(!occupied.contains(i+"H") && !occupied.contains(i+"J") && !occupied.contains(i+"K")) {
                available++;
            }
   }
    return available;
    }`

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Solution {

    public static void main(String[] args) {
        System.out.println("countFamilySeats" + familySeats(1, "1D 4C 5E"));
        
    }
    public static  int familySeats(int planeRows,String occupiedSeats){
            Map<Integer, String> seatMap = new HashMap<>();
            int countFamilySeats = 0;
        if (occupiedSeats == null || occupiedSeats.isEmpty()) {
            return planeRows * 3;
        }
          //for the Aisles : i have mentioned Z character
        for (int i = 1; i <= planeRows; i++) {
            String myData = new String("ABCZDEFGZHJK");
            seatMap.put(i, myData);
        }
        String[] occupiedSeatsArray = occupiedSeats.split(" ");
        
        System.out.println(seatMap.size());
        // int i=0;
        for (String occupied : occupiedSeatsArray) {
            char seatRow = occupied.charAt(0);
            char seatName = occupied.charAt(1);
            int row = Character.getNumericValue(seatRow);
            String seatNameCurrent = seatMap.get(row);

            String newSeatName = seatNameCurrent != null ? seatNameCurrent.replace(seatName, 'X') : null;
            System.out.println("Updating : " +newSeatName + " for row " + row);
            seatMap.put(row, newSeatName);
        }

        // AB?|DE?F|HJK
        for (Map.Entry<Integer, String> entry : seatMap.entrySet()) {
            
            String seatMapWithOccupiedData = entry.getValue();
            
            if (seatMapWithOccupiedData!=null && seatMapWithOccupiedData.contains("X")) {
                String[] tempSeatName = entry.getValue().split("X");
                for (String combinedSeats : tempSeatName) {
                    if (combinedSeats.length() <= 3) {
                        continue;
                    }
                    System.out.println("X is found : " + combinedSeats);
                    if (combinedSeats.length() >= 3 && !combinedSeats.contains("Z")) {
                        countFamilySeats++;
                    } else if (combinedSeats.length() >= 3 && combinedSeats.contains("Z")) {
                        String[] temp = combinedSeats.split("Z");
                        System.out.println(temp.length);
                        for (String t1 : temp) {
                            System.out.println("AISLE Separation " + t1);
                            if (t1.length() >= 3)
                                countFamilySeats++;
                        }
                    } else {
                        System.out.println("This portion is not suitable for family" + combinedSeats);
                    }

                }
            } else {
                countFamilySeats += 3;
            }

            System.out.println(" Till this row :"+entry.getKey()+"  family seats allowed :  " + countFamilySeats);
            
        }
        

    enter code here
        return countFamilySeats;
    }

}