Browse Source

Remove an unused optimalization

master
Jirka Sejkora 3 years ago
parent
commit
e095eabb7d
  1. 155
      src/optimization.rs

155
src/optimization.rs

@ -319,158 +319,3 @@ pub fn improve_merge_pairwise(layout: &mut HouseLayout, print_progress: bool) ->
improved
}
pub fn improve_move_houses_pairwise(layout: &mut HouseLayout) -> bool {
// TODO: Implement layout move house to avoid changing indices
for i in 0..layout.houses().len() {
for j in i + 1..layout.houses().len() {
let house1 = layout.houses()[i];
let house2 = layout.houses()[j];
let x_dist = (house1.x as i32 - house2.x as i32).abs() as usize;
let y_dist = (house1.y as i32 - house2.y as i32).abs() as usize;
if x_dist > 2 * HOUSE_RANGE + 1 || y_dist > 2 * HOUSE_RANGE + 1 {
// Not close enough to overlap or touch areas (can move on its own)
continue;
}
if let Some(distances) = get_dual_move_distances(&layout, i, j) {
eprintln!("Houses {} {} move distances: L{} R{} T{} B{}", i, j, distances.left, distances.right, distances.up, distances.down);
let mut best_move = None;
let old_price = layout.city.get_price(house1) + layout.city.get_price(house2);
let left_deltas = (1..distances.left).map(|x| (-(x as i32), 0));
let right_deltas = (1..distances.right).map(|x| (x as i32, 0));
let up_deltas = (1..distances.up).map(|x| (0, -(x as i32)));
let down_deltas = (1..distances.down).map(|x| (0, x as i32));
let move_deltas = left_deltas.chain(right_deltas).chain(up_deltas).chain(down_deltas);
for (x_delta, y_delta) in move_deltas {
let new_house1 = House::new(
(house1.x as i32 + x_delta) as usize,
(house1.y as i32 + y_delta) as usize,
);
let new_house2 = House::new(
(house2.x as i32 + x_delta) as usize,
(house2.y as i32 + y_delta) as usize,
);
if !layout.city.is_house(new_house1) || !layout.city.is_house(new_house2) {
continue;
}
let new_price = layout.city.get_price(new_house1) + layout.city.get_price(new_house2);
eprintln!("Move x{} y{}, diff {} (price {}->{})", x_delta, y_delta, new_price as i32 - old_price as i32, old_price, new_price);
if new_price < old_price {
match best_move {
None => best_move = Some((x_delta, y_delta, new_price)),
Some((_, _, best_price)) if new_price < best_price => {
best_move = Some((x_delta, y_delta, new_price));
}
_ => {}
}
}
}
if let Some((x_delta, y_delta, best_price)) = best_move {
eprintln!("Best move x{} y{}, diff {} (price {}->{})", x_delta, y_delta, best_price as i32 - old_price as i32, old_price, best_price);
// TODO: IMPLEMENT MOVE
} else {
eprintln!("No move worth it.");
}
}
}
}
unimplemented!()
}
struct MoveDistances {
left: usize,
right: usize,
up: usize,
down: usize,
}
fn get_dual_move_distances(layout: &HouseLayout, house1_index: usize, house2_index: usize) -> Option<MoveDistances> {
let house1 = layout.houses()[house1_index];
let house2 = layout.houses()[house2_index];
let rect1 = house1.range_rectangle(layout.city);
let rect2 = house2.range_rectangle(layout.city);
let top1 = rect1.top.min(rect2.top);
let top2 = rect1.top.max(rect2.top);
let bottom1 = rect1.bottom.min(rect2.bottom);
let bottom2 = rect1.bottom.max(rect2.bottom);
let left1 = rect1.left.min(rect2.left);
let left2 = rect1.left.max(rect2.left);
let right1 = rect1.right.min(rect2.right);
let right2 = rect1.right.max(rect2.right);
let left_rect = if house1.x <= house2.x { rect1 } else { rect2 };
let right_rect = if house1.x <= house2.x { rect2 } else { rect1 };
let top_rect = if house1.y <= house2.y { rect1 } else { rect2 };
let bottom_rect = if house1.y <= house2.y { rect2 } else { rect1 };
let margin_left = left1..left2;
let shared_x = left2..=right1;
let margin_right = right1 + 1..=right2;
let margin_top = top1..top2;
let shared_y = top2..=bottom1;
let margin_bottom = bottom1 + 1..=bottom2;
let mut top_distance = usize::MAX;
let mut bottom_distance = usize::MAX;
let mut right_distance = usize::MAX;
let mut left_distance = usize::MAX;
// We check the same tile twice if it's in both rectangles (and both shared_x and shared_y),
// this could be made more efficient by dividing the rectangles into 5 zones.
let rect1 = iproduct!(rect1.top..=rect1.bottom, rect1.left..=rect1.right);
let rect2 = iproduct!(rect2.top..=rect2.bottom, rect2.left..=rect2.right);
for (y, x) in rect1.chain(rect2) {
let shared_both = shared_x.contains(&x) && shared_y.contains(&y);
let min_cover_count = if shared_both { 2 } else { 1 };
if !layout.city.is_house_xy(x, y) && layout.cover_count_xy(x, y) != min_cover_count {
continue;
}
if margin_left.contains(&x) {
top_distance = top_distance.min(y - left_rect.top);
bottom_distance = bottom_distance.min(left_rect.bottom - y);
} else if shared_x.contains(&x) {
top_distance = top_distance.min(y - left_rect.top.min(right_rect.top));
bottom_distance = bottom_distance.min(left_rect.bottom.max(right_rect.bottom) - y);
} else if margin_right.contains(&x) {
top_distance = top_distance.min(y - right_rect.top);
bottom_distance = bottom_distance.min(right_rect.bottom - y);
} else {
unreachable!();
}
if margin_top.contains(&y) {
left_distance = left_distance.min(x - top_rect.left);
right_distance = right_distance.min(top_rect.right - x);
} else if shared_y.contains(&y) {
left_distance = left_distance.min(x - bottom_rect.left.min(top_rect.left));
right_distance = right_distance.min(bottom_rect.right.max(top_rect.right) - x);
} else if margin_bottom.contains(&y) {
left_distance = left_distance.min(x - bottom_rect.left);
right_distance = right_distance.min(bottom_rect.right - x);
} else {
unreachable!()
}
}
// TODO: Handle properly
assert_ne!(top_distance, usize::MAX);
Some(MoveDistances {
left: left_distance,
right: right_distance,
up: top_distance,
down: bottom_distance,
})
}
Loading…
Cancel
Save