Sejsel
/
33-3-4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Remove an unused optimalization

master
Jirka Sejkora 4 years ago
parent
7c3893834e
commit
e095eabb7d
1 changed files with 0 additions and 155 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 155
      src/optimization.rs

155
src/optimization.rs
View File

@ -319,158 +319,3 @@ pub fn improve_merge_pairwise(layout: &mut HouseLayout, print_progress: bool) ->
improved 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,
})
}
Write Preview
Loading…
Cancel
Save