第10章 - construct模板-构造与优化

export const constructScriptSchema = z.discriminatedUnion('mode', [
  paymentScriptSchema,
  placementScriptSchema,
  distributionScriptSchema,
  networkScriptSchema,
  scheduleScriptSchema,
  frontierScriptSchema,
]);

function modeOf(detail: LevelDetail): 'payment' | 'distribution' | 'network' | 'schedule' | 'frontier' {
  const script = detail.levelScript as { mode?: string } | null;
  if (script?.mode === 'distribution') return 'distribution';
  if (script?.mode === 'network') return 'network';
  if (script?.mode === 'schedule') return 'schedule';
  if (script?.mode === 'frontier') return 'frontier';
  return 'payment';
}

export function createConstructRuntime(detail: LevelDetail, opts: RuntimeOptions): LevelRuntime {
  const mode = modeOf(detail);
  if (mode === 'distribution') return distribution.createDistributionRuntime(detail, opts);
  if (mode === 'network') return createNetworkRuntime(detail, opts);
  if (mode === 'schedule') return createScheduleRuntime(detail, opts);
  if (mode === 'frontier') return createFrontierRuntime(detail, opts);
  return createPaymentRuntime(detail, opts);
}

/** 贪心：每次拿不超过余额的最大面额。付不清返回 null。 */
export function greedyCoins(denominations: readonly number[], target: number): CoinPlan | null
/** 最优：完全背包，dp[value] = 凑出 value 的最少枚数；不可达返回 null。 */
export function optimalCoins(denominations: readonly number[], target: number): CoinPlan | null

export function evaluateCounterexample(instance: CounterInstance, mainTarget?: number): CounterEvaluation {
  const greedy = greedyCoins(instance.denominations, instance.target);
  const optimal = optimalCoins(instance.denominations, instance.target);
  const greedyCount = greedy ? greedy.count : null;
  const optimalCount = optimal ? optimal.count : null;
  const surplus = greedyCount !== null && optimalCount !== null ? greedyCount - optimalCount : 0;
  return {
    // ...
    surplus,
    isCounterexample: surplus > 0,
    targetGap: mainTarget === undefined ? null : Math.abs(instance.target - mainTarget),
  };
}

/**
 * 失效前提判定：反例推翻的命题固定是"贪心总是最优"。
 * no-1-coin / target-residue 是给反例面板的干扰项，M1 不接受它们作为解释。
 */
export function premiseIsCorrect(premiseId: string, evaluation: CounterEvaluation): boolean {
  return evaluation.isCounterexample && premiseId === 'greedy-optimal';
}

/**
 * 顺序有意义：
 * 1) 没填反例 → counter-not-tested（还没开始做反例）；
 * 2) 复用了主任务参数 → counter-reused-main（即使贪心确实更差，也不接受）；
 * 3) 目标离主任务太近（< minTargetGap）→ 同样按"和主任务太像"拒绝；
 * 4) 贪心并不差 / 数字对不上 → counter-invalid；
 * 5) 前提不对 → counter-wrong-premise。
 */

/** 编辑即自动测：玩家不用再点一次"测试贪心"。 */
async function autoTest(): Promise<void> {
  const result = await props.runtime.dispatch({ type: 'counter/test', payload: {} });
  if (!result.ok) error.value = result.message ? props.t.t(result.message) : null;
}

async function commitEdit(): Promise<boolean> {
  if (!(await dispatchEdit())) return false;
  await autoTest();
  return true;
}

async function choosePremise(id: string): Promise<void> {
  if (busy.value || !lastTest.value?.passed) return;
  premise.value = id;
  // ...
  const result = await props.runtime.dispatch({ type: 'counter/annotate', payload: { premiseId: id } });
  // ...
}

// 指出失效前提就是最终作答：不需要再点提交反例（编辑即自动测，选前提即提交）。
const next: CounterDraft = { ...draft, premiseId, committed: true };

// 产物只留可重算的判定输入：测没测过、提没提交由运行时状态负责，
// 不再写进 artifact（编辑即自动测，选择前提即最终作答）。
counterexample: counter ? {
  target: counter.target,
  denominations: [...counter.denominations],
  greedyCoins: evaluation?.greedy ? evaluation.greedy.count : undefined,
  optimalCoins: evaluation?.optimalCount ?? undefined,
  isCounterexample: evaluation?.isCounterexample ?? false,
  failedPremise: counter.premiseId,
} : null,

export const distributionArtifactSchema = z.object({
  distribution: z.object({
    containers: z.array(z.object({
      id: z.string(),
      counts: z.record(z.string(), z.number().int().min(0)),
      total: z.number().int().min(0),
    })),
    totals: z.record(z.string(), z.number().int().min(0)),
  }),
});

// 容器里的件数按"本关登记的物品"重新数，不信任产物自报的 total：
// 否则多写一个未登记物品就能把 minKinds 凑够，或把 total 写小绕过容量上限。

/**
 * 其余容器照第一个容器分：UI 侧循环 dispatch（不改 runtime/schema）。
 * 先把其余容器清空，再按第一容器的搭配逐件放进去，保证不会触发"这种物品已经分完了"。
 */
async function copyFirstToRest(): Promise<void> {
  if (busy.value) return;
  if (copyBlockedReason.value) {
    error.value = copyBlockedReason.value;
    return;
  }
  busy.value = true;
  // 先清空其余容器，再按第一容器逐件复制
  // ...
}

export function connectedComponents(script: NetworkScript, ids: string[]): string[][] {
  const parent = new Map<string, string>();
  for (const node of script.nodes) parent.set(node.id, node.id);
  // find / union ...
  const groups = new Map<string, string[]>();
  for (const node of script.nodes) {
    const rootId = find(node.id);
    const list = groups.get(rootId) ?? [];
    list.push(node.id);
    groups.set(rootId, list);
  }
  return [...groups.values()];
}

/**
 * minKeyEdges 的口径是「至少有几条候选边的一端是关键站点」（与工具文案一致）：
 * 同一条边即使两端都是关键站点也只算 1 条。旧实现按端点累加，会把一条
 * 两端都关键的边算成 2，和"边数"的说法对不上。
 */
export function selectedEdges(script: NetworkScript, artifact: unknown): NetworkSelection {
  // ...
  if (aKey || bKey) keyEdges += 1;
  // ...
}

const a = lessons.get(ids[i] as string);
const b = lessons.get(ids[j] as string);
if (!a || !b) continue;
if (a.teacher === b.teacher) conflicts.push({ kind: 'teacher', slot, a: a.id, b: b.id });
if (a.className === b.className) conflicts.push({ kind: 'class', slot, a: a.id, b: b.id });
if (a.room === b.room) conflicts.push({ kind: 'room', slot, a: a.id, b: b.id });

/** 贪心：每到一站选当前最便宜的出边，不回头。 */
export function greedyWalk(script: FrontierScript, costs: Record<string, number>): FrontierResult['greedy']
/** 最优：固定小图，枚举所有简单路径取最小。 */
export function optimalWalk(script: FrontierScript, costs: Record<string, number>): FrontierResult['optimal']

export function evaluateFrontier(script: FrontierScript, costs: Record<string, number>): FrontierResult {
  const greedy = greedyWalk(script, costs);
  const optimal = optimalWalk(script, costs);
  return {
    greedy,
    optimal,
    counterexample: greedy.reached && Number.isFinite(optimal.cost) && greedy.cost > optimal.cost,
  };
}

// packages/toolkit-ui/src/NetworkTool.vue
/** 实时约束灯：连通块 / 成本 / 关键站点 / 边数。 */
const stats = computed(() => {
  // ... 并查集 / 成本累加 / 关键边计数
  const components = new Set(ids.map((id) => find(id))).size;
  const totalKeyStations = nodes.value.filter((node) => node.key).length;
  return { components, cost, keyEdges, keyStations: keyStations.size, totalKeyStations, count: selected.value.size };
});

/** 贪心：每到一站选当前最便宜的出边（与运行时 frontier.ts 同口径）。 */
const greedy = computed(() => { /* ... */ });

/** 最优：固定小图，枚举全部简单路径取最小（与运行时同口径）。 */
const optimal = computed(() => { /* ... */ });