327 lines
9.9 KiB
Rust
327 lines
9.9 KiB
Rust
#![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
|
|
use bit_vec::BitVec;
|
|
use std::{
|
|
fmt::{Display, Error, Formatter},
|
|
ops::Coroutine,
|
|
};
|
|
|
|
type Person = usize;
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
enum Side {
|
|
Top,
|
|
Bot,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct Seating {
|
|
amount: usize,
|
|
people_top: Vec<Option<Person>>,
|
|
people_bot: Vec<Option<Person>>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct Adjacencies {
|
|
amap: Vec<BitVec>,
|
|
}
|
|
|
|
impl Adjacencies {
|
|
pub fn for_table(seats: &Seating) -> Self {
|
|
let mut adj = Self::new(seats.amount);
|
|
seats.get_adjacent(&mut adj);
|
|
adj
|
|
}
|
|
|
|
pub fn new(size: usize) -> Self {
|
|
Adjacencies {
|
|
amap: (0..size).map(|_| BitVec::from_elem(size, false)).collect(),
|
|
}
|
|
}
|
|
|
|
pub fn reset(&mut self) {
|
|
self.amap.iter_mut().for_each(|bitvec| {
|
|
if bitvec.any() {
|
|
bitvec.clear();
|
|
}
|
|
})
|
|
}
|
|
|
|
fn is_disjoint(&mut self, other: &Adjacencies) -> bool {
|
|
self.amap.iter_mut().enumerate().all(|(key, bitvec)| {
|
|
bitvec.and(&other.amap[key]);
|
|
bitvec.none()
|
|
})
|
|
}
|
|
|
|
pub fn intersect(&self, other: &Adjacencies) -> Adjacencies {
|
|
Adjacencies {
|
|
amap: self
|
|
.amap
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(key, bitset)| {
|
|
let mut bc = bitset.clone();
|
|
bc.and(&other.amap[key]);
|
|
bc
|
|
})
|
|
.collect(),
|
|
}
|
|
}
|
|
|
|
pub fn union(&self, other: &Adjacencies) -> Adjacencies {
|
|
Adjacencies {
|
|
amap: self
|
|
.amap
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(key, bitset)| {
|
|
let mut bc = bitset.clone();
|
|
bc.or(&other.amap[key]);
|
|
bc
|
|
})
|
|
.collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for Adjacencies {
|
|
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
|
|
for (key, val) in self.amap.iter().enumerate() {
|
|
write!(fmt, "{}:", key)?;
|
|
for other in val {
|
|
write!(fmt, " {},", other)?;
|
|
}
|
|
write!(fmt, "\n")?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Display for Seating {
|
|
fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
|
|
let width = if self.amount == 0 {
|
|
1
|
|
} else {
|
|
(self.amount.ilog10() + 2) as usize
|
|
};
|
|
for peep in self.people_top.iter() {
|
|
if let Some(perp) = peep {
|
|
write!(fmt, "{:width$}", perp)?;
|
|
} else {
|
|
write!(fmt, "{:>1$}", "X", width)?;
|
|
}
|
|
}
|
|
write!(fmt, "\n")?;
|
|
for peep in self.people_bot.iter() {
|
|
if let Some(perp) = peep {
|
|
write!(fmt, "{:width$}", perp)?;
|
|
} else {
|
|
write!(fmt, "{:>1$}", "X", width)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Seating {
|
|
pub fn calc_alternatives(
|
|
size: usize,
|
|
old_adjacencies: &Adjacencies,
|
|
) -> impl Coroutine<Yield = Seating, Return = usize> {
|
|
let old_adjacencies = old_adjacencies.clone();
|
|
#[coroutine]
|
|
move || {
|
|
let mut checked_locations = 0;
|
|
let mut new_adjacencies = Adjacencies::new(size);
|
|
let mut tree = vec![((0..size).collect::<Vec<_>>(), Seating::make_empty(size))];
|
|
while let Some((to_place, start)) = tree.pop() {
|
|
checked_locations += 1;
|
|
if to_place.len() == 0 {
|
|
yield start
|
|
} else {
|
|
for pos in start.empty_table_coords() {
|
|
let mut dup = start.clone();
|
|
dup.seat_person(to_place[0], pos);
|
|
new_adjacencies.reset();
|
|
dup.get_adjacent(&mut new_adjacencies);
|
|
if new_adjacencies.is_disjoint(&old_adjacencies) {
|
|
tree.push((to_place[1..].to_vec(), dup));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
checked_locations
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Seating {
|
|
pub fn make_seating(size: usize) -> Self {
|
|
let top_amt = size / 2;
|
|
let bot_amt = size - top_amt;
|
|
Seating {
|
|
amount: size,
|
|
people_top: (0..top_amt).map(|i| Some(i * 2 + 1)).collect(),
|
|
people_bot: (0..bot_amt).map(|i| Some(i * 2)).collect(),
|
|
}
|
|
}
|
|
|
|
pub fn make_empty(size: usize) -> Self {
|
|
let top_amt = size / 2;
|
|
Seating {
|
|
amount: size,
|
|
people_top: (0..top_amt).map(|_| None).collect(),
|
|
people_bot: (top_amt..size).map(|_| None).collect(),
|
|
}
|
|
}
|
|
|
|
fn empty_table_coords(&self) -> Vec<(usize, Side)> {
|
|
self.people_top
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(coord, val)| {
|
|
if val.is_none() {
|
|
Some((coord, Side::Top))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.chain(
|
|
self.people_bot
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(coord, val)| {
|
|
if val.is_none() {
|
|
Some((coord, Side::Bot))
|
|
} else {
|
|
None
|
|
}
|
|
}),
|
|
)
|
|
.collect()
|
|
}
|
|
|
|
fn seat_person(&mut self, person: usize, position: (usize, Side)) {
|
|
let (x, y) = position;
|
|
assert!(
|
|
self.index(x, y) == None,
|
|
"Can't seat person {} where {} is already sitting",
|
|
person,
|
|
self.index(x, y).expect("there was someone sitting there")
|
|
);
|
|
let side = match y {
|
|
Side::Top => &mut self.people_top,
|
|
Side::Bot => &mut self.people_bot,
|
|
};
|
|
side[x] = Some(person);
|
|
}
|
|
|
|
pub fn get_adjacent(&self, prev_adj: &mut Adjacencies) {
|
|
for (i, person) in self.people_top.iter().enumerate() {
|
|
if let &Some(person) = person {
|
|
assert!(
|
|
prev_adj.amap.len() > person,
|
|
"adjacencies must contain all possible people"
|
|
);
|
|
|
|
if i > 0 {
|
|
// to their right:
|
|
if let Some(adjacent) = self.index(i - 1, Side::Top) {
|
|
prev_adj.amap[person].set(adjacent, true);
|
|
}
|
|
// across right:
|
|
if let Some(adjacent) = self.index(i - 1, Side::Bot) {
|
|
prev_adj.amap[person].set(adjacent, true)
|
|
}
|
|
}
|
|
// to their left:
|
|
if let Some(adjacent) = self.index(i + 1, Side::Top) {
|
|
prev_adj.amap[person].set(adjacent, true);
|
|
}
|
|
// across:
|
|
if let Some(adjacent) = self.index(i, Side::Bot) {
|
|
prev_adj.amap[person].set(adjacent, true);
|
|
}
|
|
// across left:
|
|
if let Some(adjacent) = self.index(i + 1, Side::Bot) {
|
|
prev_adj.amap[person].set(adjacent, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i, person) in self.people_bot.iter().enumerate() {
|
|
if let &Some(person) = person {
|
|
assert!(
|
|
prev_adj.amap.len() > person,
|
|
"adjacencies must contain all possible people"
|
|
);
|
|
|
|
// Layout I think I want to use?
|
|
// [0, 1, 2, 3, 4, 5]
|
|
// [6, 7, 8, 9,10,11]
|
|
|
|
if i > 0 {
|
|
// to their left:
|
|
if let Some(adjacent) = self.index(i - 1, Side::Bot) {
|
|
prev_adj
|
|
.amap
|
|
.get_mut(person)
|
|
.expect("bitset was created above")
|
|
.set(adjacent, true);
|
|
}
|
|
// across left:
|
|
if let Some(adjacent) = self.index(i - 1, Side::Top) {
|
|
prev_adj
|
|
.amap
|
|
.get_mut(person)
|
|
.expect("bitset was created above")
|
|
.set(adjacent, true);
|
|
}
|
|
}
|
|
// to their right:
|
|
if let Some(adjacent) = self.index(i + 1, Side::Bot) {
|
|
prev_adj
|
|
.amap
|
|
.get_mut(person)
|
|
.expect("bitset was created above")
|
|
.set(adjacent, true);
|
|
}
|
|
// across:
|
|
if let Some(adjacent) = self.index(i, Side::Top) {
|
|
prev_adj
|
|
.amap
|
|
.get_mut(person)
|
|
.expect("bitset was created above")
|
|
.set(adjacent, true);
|
|
}
|
|
// across right:
|
|
if let Some(adjacent) = self.index(i + 1, Side::Top) {
|
|
prev_adj
|
|
.amap
|
|
.get_mut(person)
|
|
.expect("bitset was created above")
|
|
.set(adjacent, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn index(&self, x: usize, y: Side) -> Option<Person> {
|
|
match y {
|
|
Side::Top => {
|
|
if x >= self.people_top.len() {
|
|
None
|
|
} else {
|
|
Some(self.people_top[x]?)
|
|
}
|
|
}
|
|
Side::Bot => {
|
|
if x >= self.people_bot.len() {
|
|
None
|
|
} else {
|
|
Some(self.people_bot[x]?)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|