个性化旅游系统

struct Graph {
    adj: Vec<Vec<(usize, f64)>>,
    node_count: usize,
}

fn shortest_path(&self, start: usize, goal: usize)
    -> Option<PathResult>
{
    let mut dist = vec![f64::INFINITY; self.node_count];
    let mut prev = vec![None; self.node_count];
    let mut heap = MinHeap::new();
    dist[start] = 0.0;
    heap.push((OrderedFloat(0.0), start));

    while let Some((d, u)) = heap.pop() {
        if u == goal { return Some(reconstruct(prev, u)); }
        if d.0 > dist[u] { continue; }
        for &(v, w) in &self.adj[u] {
            let nd = dist[u] + w;
            if nd < dist[v] {
                dist[v] = nd;
                prev[v] = Some(u);
                heap.push((OrderedFloat(nd), v));
            }
        }
    }
    None
}

fn build_index(docs: &[DiaryEntry])
    -> HashMap<String, Vec<usize>>
{
    let mut idx: HashMap<String, Vec<usize>>
        = HashMap::new();
    for (id, doc) in docs.iter().enumerate() {
        let text = format!("{} {}", doc.title, doc.content);
        let chars: Vec<char> = text.chars().collect();
        for w in chars.windows(2) {
            let gram: String = w.iter().collect();
            idx.entry(gram).or_default().push(id);
        }
    }
    idx
}

// 评分：融合相关性 + 热度 + 评分
score = gram_hits * 1.5
      + if title_match { 2.0 } else { 0.0 }
      + diary.rating * 2.0
      + (diary.views as f64 + 1.0).ln();

fn build_huffman_tree(
    freq: &HashMap<char, usize>
) -> HuffmanNode {
    // 用 MinHeap 以频率为键构建优先队列
    let mut heap = MinHeap::new();
    for (&ch, &f) in freq {
        heap.push(HuffmanNode::leaf(ch, f));
    }
    // 贪心合并：每次取两个最小节点合并
    while heap.len() > 1 {
        let a = heap.pop().unwrap();
        let b = heap.pop().unwrap();
        heap.push(HuffmanNode::merge(a, b));
    }
    heap.pop().unwrap()  // 根节点即完整编码树
}