Struct EdgeListGraphScanner 

pub struct EdgeListGraphScanner<U: Scan<Output = usize>, T: Scan> {
    vsize: usize,
    esize: usize,
    _marker: PhantomData<fn() -> (U, T)>,
}

Fields

vsize: usize

esize: usize

_marker: PhantomData<fn() -> (U, T)>

Implementations

impl<U: Scan<Output = usize>, T: Scan> EdgeListGraphScanner<U, T>

pub fn new(vsize: usize, esize: usize) -> Self

Examples found in repository

crates/aizu_online_judge/src/grl/grl_2_b.rs (line 7)

pub fn grl_2_b(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(vs, es, root, (graph, w): @EdgeListGraphScanner::<usize, i64>::new(vs, es));
    let res = graph.minimum_spanning_arborescence::<AdditiveOperation<_>, _>(root, |u| w[u]);
    pp!(res.unwrap().0);
}

crates/library_checker/src/graph/directedmst.rs (line 7)

pub fn directedmst(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(n, m, s, (graph, w): @EdgeListGraphScanner::<usize, i64>::new(n, m));
    let res = graph
        .minimum_spanning_arborescence::<AdditiveOperation<_>, _>(s, |u| w[u])
        .unwrap();
    pp!(res.0; @it res.1);
}

crates/aizu_online_judge/src/grl/grl_2_a.rs (line 7)

pub fn grl_2_a(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(vs, es, (graph, w): @EdgeListGraphScanner::<usize, u32>::new(vs, es));
    let span = graph.minimum_spanning_tree(|&eid| w[eid]);
    let ans = (0..es)
        .map(|eid| u64::from(w[eid]) * span[eid] as u64)
        .sum::<u64>();
    pp!(ans);
}

crates/library_checker/src/graph/minimum_spanning_tree.rs (line 7)

pub fn minimum_spanning_tree(reader: impl Read, writer: impl Write) {
    prepare_io!(reader, writer);
    sc!(n, m, (graph, w): @EdgeListGraphScanner::<usize, u32>::new(n, m));
    let mut edges: Vec<_> = (0..m).map(|eid| (w[eid], eid as u32)).collect();
    edges.radix_sort_by_key(|&(weight, _)| weight);
    let span = graph
        .minimum_spanning_tree_from_sorted_edges(edges.into_iter().map(|(_, eid)| eid as usize));
    let ans = (0..m).filter(|&eid| span[eid]);
    let total: u64 = ans.clone().map(|eid| u64::from(w[eid])).sum();
    pp!(total; @it ans);
}

Trait Implementations

impl<U: Scan<Output = usize>, T: Scan> MarkedScan for EdgeListGraphScanner<U, T>

type Output = (EdgeListGraph, Vec<<T as Scan>::Output>)

fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output>