255 lines
9.3 KiB
Python
255 lines
9.3 KiB
Python
"""图论/动态规划工具箱：开放路径排序、下界与路由度量（S1/S5）。
|
||
|
||
设计原则（docs/第三四问图论与动态规划优化方案.md §1、§3.2、§3.4）：
|
||
|
||
- **开放路径**（起点固定为原点、终点自由）是本题的真实图问题：一次作业回合
|
||
= 依次停靠若干作业点，代价 = Σ 移动时间 + Σ 动作耗时；
|
||
- 小规模（n ≤ ``EXACT_LIMIT``）直接用 Held-Karp 精确 DP，规模更大时用
|
||
最近邻打底 + 2-opt / Or-opt 改进，并始终给出 **MST 下界**用于在线后悔值审计；
|
||
- 所有函数只做"排序与度量"，不承担任何安全责任，也不改变覆盖/清除语义。
|
||
|
||
约定：边权为**欧氏距离**（米）；时间折算由调用方按 ``speed_mps`` 处理。
|
||
2-opt / Or-opt 用 O(1) 增量代价评估，使 n ≈ 10² 量级仍可在毫秒内完成。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import math
|
||
|
||
from .config import Vec2
|
||
|
||
EXACT_LIMIT = 13 # Held-Karp 状态数 2^n·n：n=13 → 106 496，纯 Python 可接受
|
||
OR_OPT_LIMIT = 60 # 作业点数超过此值时跳过高阶 Or-opt（见 improve_open_path）
|
||
|
||
|
||
def path_length(order: list[Vec2], start: Vec2 = (0.0, 0.0)) -> float:
|
||
"""开放路径长度（起点 start，终点自由）。"""
|
||
total = 0.0
|
||
position = start
|
||
for point in order:
|
||
total += math.dist(position, point)
|
||
position = point
|
||
return total
|
||
|
||
|
||
def nearest_neighbor_order(points: list[Vec2],
|
||
start: Vec2 = (0.0, 0.0)) -> list[Vec2]:
|
||
"""最近邻开放路径（O(n²)，启发式上界）。"""
|
||
remaining = list(points)
|
||
order: list[Vec2] = []
|
||
position = start
|
||
while remaining:
|
||
nxt = min(remaining, key=lambda q: math.dist(position, q))
|
||
remaining.remove(nxt)
|
||
order.append(nxt)
|
||
position = nxt
|
||
return order
|
||
|
||
|
||
def two_opt_open(order: list[Vec2], start: Vec2 = (0.0, 0.0),
|
||
max_passes: int = 8) -> list[Vec2]:
|
||
"""开放路径 2-opt（终点自由：只反转内部片段，不做首尾相接）。
|
||
|
||
增量代价 O(1)：反转 [i..j] 只影响 (prev, i) 与 (j, next) 两条边。
|
||
"""
|
||
best = list(order)
|
||
n = len(best)
|
||
if n < 3:
|
||
return best
|
||
for _ in range(max_passes):
|
||
improved = False
|
||
for i in range(n - 1):
|
||
prev = best[i - 1] if i > 0 else start
|
||
pi = best[i]
|
||
d_prev_i = math.dist(prev, pi)
|
||
for j in range(i + 1, n):
|
||
pj = best[j]
|
||
nxt = best[j + 1] if j + 1 < n else None
|
||
d_prev_j = math.dist(prev, pj)
|
||
removed = d_prev_i
|
||
added = d_prev_j
|
||
if nxt is not None:
|
||
removed += math.dist(pj, nxt)
|
||
added += math.dist(pi, nxt)
|
||
if added < removed - 1e-9:
|
||
best[i:j + 1] = best[i:j + 1][::-1]
|
||
improved = True
|
||
pi = best[i]
|
||
d_prev_i = math.dist(prev, pi)
|
||
if not improved:
|
||
break
|
||
return best
|
||
|
||
|
||
def or_opt_open(order: list[Vec2], start: Vec2 = (0.0, 0.0),
|
||
max_passes: int = 4, max_segment: int = 3) -> list[Vec2]:
|
||
"""Or-opt：把长度 ≤ max_segment 的片段搬家（开放路径，增量代价 O(1)）。"""
|
||
best = list(order)
|
||
n = len(best)
|
||
if n < 4:
|
||
return best
|
||
for _ in range(max_passes):
|
||
improved = False
|
||
for length in range(1, min(max_segment, n - 1) + 1):
|
||
for i in range(0, n - length + 1):
|
||
segment = best[i:i + length]
|
||
rest = best[:i] + best[i + length:]
|
||
for j in range(len(rest) + 1):
|
||
if j == i:
|
||
continue
|
||
candidate = rest[:j] + segment + rest[j:]
|
||
if _segment_move_gain(best, i, length, j, start) > 1e-9:
|
||
best = candidate
|
||
improved = True
|
||
break
|
||
if improved:
|
||
break
|
||
if improved:
|
||
break
|
||
if not improved:
|
||
break
|
||
return best
|
||
|
||
|
||
def _segment_move_gain(order: list[Vec2], i: int, length: int, j: int,
|
||
start: Vec2) -> float:
|
||
"""把 order[i:i+length] 插到去掉该段后的第 j 位所省下的长度（正=更省）。"""
|
||
rest = order[:i] + order[i + length:]
|
||
segment = order[i:i + length]
|
||
|
||
def length_of(seq: list[Vec2]) -> float:
|
||
return path_length(seq, start)
|
||
|
||
return length_of(order) - length_of(rest[:j] + segment + rest[j:])
|
||
|
||
|
||
def improve_open_path(points: list[Vec2], start: Vec2 = (0.0, 0.0),
|
||
max_passes: int = 8) -> list[Vec2]:
|
||
"""最近邻 + 2-opt + Or-opt 的开放路径改进（大规模兜底）。
|
||
|
||
Or-opt 的搬移评估是 O(n³)，作业点数超过 :data:`OR_OPT_LIMIT` 时只做
|
||
O(n²) 的 2-opt（度量口径下 Or-opt 的相对收益远小于其墙钟代价）。
|
||
"""
|
||
order = nearest_neighbor_order(points, start)
|
||
order = two_opt_open(order, start, max_passes)
|
||
if len(order) > OR_OPT_LIMIT:
|
||
return order
|
||
return or_opt_open(order, start, max_passes)
|
||
|
||
|
||
def held_karp_open(points: list[Vec2], start: Vec2 = (0.0, 0.0)) -> list[Vec2]:
|
||
"""Held-Karp 精确开放路径（起点固定、终点自由）。
|
||
|
||
状态 ``dp[mask][j]`` = 访问集合 mask、当前停在 j 的最小长度；
|
||
规模 2^n·n，仅用于 n ≤ :data:`EXACT_LIMIT`。返回最优访问顺序。
|
||
"""
|
||
n = len(points)
|
||
if n == 0:
|
||
return []
|
||
if n == 1:
|
||
return list(points)
|
||
dist = [[math.dist(points[i], points[j]) for j in range(n)] for i in range(n)]
|
||
from_start = [math.dist(start, points[j]) for j in range(n)]
|
||
full = (1 << n) - 1
|
||
inf = float("inf")
|
||
dp: list[list[float]] = [[inf] * n for _ in range(1 << n)]
|
||
parent: list[list[int]] = [[-1] * n for _ in range(1 << n)]
|
||
for j in range(n):
|
||
dp[1 << j][j] = from_start[j]
|
||
for mask in range(1 << n):
|
||
row = dp[mask]
|
||
for j in range(n):
|
||
current = row[j]
|
||
if current == inf or not (mask >> j) & 1:
|
||
continue
|
||
rest = full ^ mask
|
||
while rest:
|
||
bit = rest & -rest
|
||
k = bit.bit_length() - 1
|
||
rest ^= bit
|
||
candidate = current + dist[j][k]
|
||
nxt = mask | bit
|
||
if candidate < dp[nxt][k]:
|
||
dp[nxt][k] = candidate
|
||
parent[nxt][k] = j
|
||
best_end = min(range(n), key=lambda j: dp[full][j])
|
||
order: list[Vec2] = []
|
||
mask, j = full, best_end
|
||
while j != -1:
|
||
order.append(points[j])
|
||
previous = parent[mask][j]
|
||
mask ^= 1 << j
|
||
j = previous
|
||
order.reverse()
|
||
return order
|
||
|
||
|
||
def optimal_open_path(points: list[Vec2], start: Vec2 = (0.0, 0.0),
|
||
exact_limit: int = EXACT_LIMIT) -> list[Vec2]:
|
||
"""离线最优（或近优）开放路径：小规模精确，大规模 2-opt + Or-opt。"""
|
||
unique = _dedupe(points)
|
||
if len(unique) <= exact_limit:
|
||
return held_karp_open(unique, start)
|
||
return improve_open_path(unique, start)
|
||
|
||
|
||
def mst_weight(points: list[Vec2], start: Vec2 | None = (0.0, 0.0)) -> float:
|
||
"""最小生成树权重（Prim，O(n²)）；含 start 时给出开放路径最优值的下界。
|
||
|
||
开放路径删除其最后一条边即得一条生成树，故 MST 权重 ≤ 最优路径长度。
|
||
"""
|
||
nodes = ([start] if start is not None else []) + list(points)
|
||
n = len(nodes)
|
||
if n <= 1:
|
||
return 0.0
|
||
in_tree = [False] * n
|
||
best = [float("inf")] * n
|
||
best[0] = 0.0
|
||
total = 0.0
|
||
for _ in range(n):
|
||
u, u_cost = -1, float("inf")
|
||
for i in range(n):
|
||
if not in_tree[i] and best[i] < u_cost:
|
||
u, u_cost = i, best[i]
|
||
if u < 0:
|
||
break
|
||
in_tree[u] = True
|
||
total += u_cost
|
||
ux, uy = nodes[u]
|
||
for v in range(n):
|
||
if in_tree[v]:
|
||
continue
|
||
distance = math.hypot(nodes[v][0] - ux, nodes[v][1] - uy)
|
||
if distance < best[v]:
|
||
best[v] = distance
|
||
return total
|
||
|
||
|
||
def _dedupe(points, cell_m: float = 0.5) -> list[Vec2]:
|
||
"""按 ``cell_m`` 网格去重（同一物理点只算一次作业）。"""
|
||
seen: set[tuple[int, int]] = set()
|
||
unique: list[Vec2] = []
|
||
for point in points:
|
||
key = (int(round(point[0] / cell_m)), int(round(point[1] / cell_m)))
|
||
if key in seen:
|
||
continue
|
||
seen.add(key)
|
||
unique.append((float(point[0]), float(point[1])))
|
||
return unique
|
||
|
||
|
||
def route_metrics(service_points, actual_move_m: float,
|
||
speed_mps: float = 5.0) -> dict:
|
||
"""路由度量：离线最优开放回路、MST 下界与相对 gap（S1 必报列）。"""
|
||
unique = _dedupe(service_points)
|
||
offline = path_length(optimal_open_path(unique)) if unique else 0.0
|
||
lower = mst_weight(unique)
|
||
gap = ((actual_move_m - offline) / actual_move_m) if actual_move_m > 0 else 0.0
|
||
return {
|
||
"distinct_service_points": len(unique),
|
||
"offline_opt_open_path_m": round(offline, 1),
|
||
"offline_opt_open_path_s": round(offline / speed_mps, 1),
|
||
"route_lower_bound_s": round(lower / speed_mps, 1),
|
||
"route_gap_vs_offline": round(gap, 4),
|
||
}
|