Struct AdjacencyListGraph 

pub struct AdjacencyListGraph {
    pub vsize: usize,
    pub esize: usize,
    pub graph: Vec<Vec<Neighbor<usize, usize>>>,
}

Fields

vsize: usize

esize: usize

graph: Vec<Vec<Neighbor<usize, usize>>>

Implementations

impl AdjacencyListGraph

pub fn new(vsize: usize) -> AdjacencyListGraph

Examples found in repository

crates/competitive/src/graph/adjacency_list.rs (line 123)

    fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
        let mut graph = AdjacencyListGraph::new(self.vsize);
        let mut rest = Vec::with_capacity(self.esize);
        for _ in 0..self.esize {
            let (from, to) = (U::scan(iter)?, U::scan(iter)?);
            if self.directed {
                graph.add_edge(from, to);
            } else {
                graph.add_undirected_edge(from, to);
            }
            rest.push(T::scan(iter)?);
        }
        Some((graph, rest))
    }

pub fn add_edge(&mut self, from: usize, to: usize)

Examples found in repository

crates/competitive/src/graph/adjacency_list.rs (line 128)

    fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
        let mut graph = AdjacencyListGraph::new(self.vsize);
        let mut rest = Vec::with_capacity(self.esize);
        for _ in 0..self.esize {
            let (from, to) = (U::scan(iter)?, U::scan(iter)?);
            if self.directed {
                graph.add_edge(from, to);
            } else {
                graph.add_undirected_edge(from, to);
            }
            rest.push(T::scan(iter)?);
        }
        Some((graph, rest))
    }

pub fn add_undirected_edge(&mut self, u: usize, v: usize)

Examples found in repository

crates/competitive/src/graph/adjacency_list.rs (line 130)

    fn mscan<I: ScanSource>(self, iter: &mut I) -> Option<Self::Output> {
        let mut graph = AdjacencyListGraph::new(self.vsize);
        let mut rest = Vec::with_capacity(self.esize);
        for _ in 0..self.esize {
            let (from, to) = (U::scan(iter)?, U::scan(iter)?);
            if self.directed {
                graph.add_edge(from, to);
            } else {
                graph.add_undirected_edge(from, to);
            }
            rest.push(T::scan(iter)?);
        }
        Some((graph, rest))
    }

pub fn vertices(&self) -> Range<usize>

Trait Implementations

impl Clone for AdjacencyListGraph

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AdjacencyListGraph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AdjacencyListGraph

fn default() -> Self

Returns the “default value” for a type.

impl<T> EdgeMap<T> for AdjacencyListGraph

type Emap = Vec<T>

fn construct_emap<F>(&self, f: F) -> Self::Emap

where F: FnMut() -> T,

fn emap_get<'a>(&self, map: &'a Self::Emap, eid: Self::Label) -> &'a T

fn emap_get_mut<'a>( &self, map: &'a mut Self::Emap, eid: Self::Label, ) -> &'a mut T

fn emap_set(&self, map: &mut Self::Emap, eid: Self::Label, value: T)

impl Graph for AdjacencyListGraph

type Vertex = usize

type Label = usize

type Vertices<'g> = Range<usize>

type Neighbors<'g> = Copied<Iter<'g, Neighbor<usize, usize>>>

fn vsize(&self) -> usize

fn vertices(&self) -> Self::Vertices<'_>

fn neighbors(&self, vertex: Self::Vertex) -> Self::Neighbors<'_>

impl<T> VertexMap<T> for AdjacencyListGraph

type Vmap = Vec<T>

fn construct_vmap<F>(&self, f: F) -> Self::Vmap

where F: FnMut() -> T,

fn vmap_get<'a>(&self, map: &'a Self::Vmap, vertex: Self::Vertex) -> &'a T

fn vmap_get_mut<'a>( &self, map: &'a mut Self::Vmap, vertex: Self::Vertex, ) -> &'a mut T

fn vmap_set(&self, map: &mut Self::Vmap, vertex: Self::Vertex, value: T)