在我看来，使用BitSet比使用boolean[]数组要简单，因为BitSet有一个预定义的方法nextSetBit，它返回（正如它的名字所说）下一个集合位。我认为，对于你的任务来说，分治策略是不必要的。问题可以这样解决：

public static void main(String[] args) {
    int numStalls = 10; // get it from user input if you like
    BitSet bs = new BitSet();
    // set the leftmost and the rightmost bits (which represent walls)
    bs.set(0);
    bs.set(numStalls+1);
    // now we have 10 bits gap, which represent stalls
    // like this: X__________X
    for(int i=0; i<numStalls; i++) {
        bs.set(nextStall(bs));
        printStalls(bs);
    }
}

public static int nextStall(BitSet bs) {
    int bestPos = 0, maxDist = bs.nextSetBit(0);
    // iterate over the set bits
    for(int pos = maxDist; pos != -1; pos = bs.nextSetBit(pos+1)) {
        int dist = bs.nextSetBit(pos+1) - pos;
        // track the position of the stall with biggest gap on the right
        if(dist > maxDist) {
            maxDist = dist;
            bestPos = pos;
        }
    }
    // return the position on the middle of the best gap
    return bestPos+maxDist/2;
}

public static void printStalls(BitSet bs) {
    StringBuilder sb = new StringBuilder();
    // Iterate over all the bit positions except the walls
    // walls have positions 0 and bs.length()
    for(int i=1; i<bs.length()-1; i++) {
        sb.append(bs.get(i) ? "X" : "_");
    }
    System.out.println(sb);
}

如果允许使用Java-8，则解决方案可以更短：

public static int nextStall(BitSet bs) {
    // Find the position of the stall (or wall)
    // For which the next stall/wall is the most distant
    // bs.stream() returns stream of positions of the set bits
    int pos = bs.stream().boxed()
                .max(Comparator.comparingInt(v -> bs.nextSetBit(v+1) - v)).get();
    // Return the middle position in the gap
    return (pos+bs.nextSetBit(pos+1))/2;
}

public static void printStalls(BitSet bs) {
    // Iterate over all the bit positions except the walls
    // walls have positions 0 and bs.length()
    System.out.println(IntStream.range(1, bs.length() - 1)
            .mapToObj(idx -> bs.get(idx) ? "X" : "_").collect(Collectors.joining()));
}

使用优先级队列解决此问题的C++解决方案

# include<iostream>

# include<bits/stdc++.h>

using namespace std;
struct s
{
    int distance;
    int start;
    int ending;
};
struct fn
{
    bool operator()(s const&a,s const &b)
    {
        if(a.distance!=b.distance)
        {
            return a.distance<b.distance;
        }
        return a.start<b.start;
    }
};
int main()
{
    int n;
    cin >> n;
    int mat[n] = {0};
    priority_queue<s,vector<s>,fn> q;
    struct s temp;
    int l=1,r=n,coun=1;
    q.push({n,l,r});
    while(!q.empty())
    {
        temp = q.top();
        q.pop();
        int left = temp.start;
        int right = temp.ending;
        int mid = (left+right)/2;
        if(temp.distance>0)
        {
            if(right>mid)
            {
                q.push({right-mid,mid+1,right}); // first push right child then left
            }
            if(left<mid)
            {
                q.push({mid-left,left,mid-1});
            }
        }
        mat[mid-1] = coun;
        coun++;
        for(int i=0; i<n; i++)
        {
            if(mat[i]==0)
            {
                cout << "_" << " ";
            }
            else
            {
                cout << "X" << " ";
            }

        }
        cout << endl;
    }

}

我想这应该可以。

import java.util.*;

public class hinata {
static Scanner scan = new Scanner(System.in);
public static void main(String[] args){
    bfs(5,10);
}
static class node{int left, right,level; node(int left, int right, int level){this.left=left;this.right=right;this.level=level;}}
public static void bfs(int lev, int n){
    LinkedList<node> queue = new LinkedList<>(); boolean[] arr = new boolean[n];
    queue.addLast(new node(0,n-1,lev));
    int e = lev;
    while(!queue.isEmpty()){
        node curr = queue.removeLast();
        int l = curr.left, r = curr.right;
        if(e <= 0){break;}
        else{
            int mid = (l+r)>>1; arr[mid] = true;
            System.out.print(e+" : ");print(arr);
            --e;
            if(mid+1 <=r){
                queue.addFirst(new node(mid+1,r,e));
            }

            if(l <=mid-1){
                queue.addFirst(new node(l, mid-1,e));
            }
        }
    }
}

static void print(boolean[] arr){
    for(boolean i : arr){
        if(!i){System.out.print('_');}
        else{System.out.print('X');}
    }System.out.println();
}

}

这看起来类似于二叉树的层次顺序遍历，也就是说，在每一层，你把问题进一步分成两个子问题。
所以我的意思是，假设最初，你有l=0，r=n-1，其中n是输入的大小或小便池的数量。
然后你要做的就是取mid =（l+r）/2，在那里放一个人，然后把（l，mid-1）和（mid+1，r）推到队列中。
重复此过程，直到所需的小便池已装满。

下面是同样的C++代码！

# include <iostream>

# include<bits/stdc++.h>

using namespace std;

int main() {
    int n;
    cin>>n;
    string s="";
    for(int i=0; i<n; i++){
        s+="_";
    }

    priority_queue<pair<int, int>> pq;
    pq.push({n,0});
    for( int i=0; i<n; i++){
        pair<int, int> front= pq.top();
        pq.pop();
        int indx= (front.first-1)/2+ front.second;
        s[indx]= 'X';
        cout<<s<<endl;
        pq.push({indx- front.second, front.second});
        pq.push({front.first/2, indx+1});
    }
    return 0;

}