Struct KnapsackPloblemSmallWeight

Source

pub struct KnapsackPloblemSmallWeight {
    pub dp: Vec<i64>,
}

Fields§

§dp: Vec<i64>

Implementations§

Source §

impl KnapsackPloblemSmallWeight

Source

pub fn new(max_weight: usize) -> Self

Examples found in repository ?

crates/aizu_online_judge/src/dpl/dpl_1_c.rs (line 10)

6pub fn dpl_1_c(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vw: [(i64, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend(vw.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}

More examples

Hide additional examples

crates/aizu_online_judge/src/dpl/dpl_1_b.rs (line 10)

6pub fn dpl_1_b(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vw: [(i64, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend01(vw.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}

crates/aizu_online_judge/src/dpl/dpl_1_g.rs (line 10)

6pub fn dpl_1_g(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vwm: [(i64, usize, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend_limitation(vwm.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}

Source

pub fn max_weight(&self) -> usize

Source

pub fn insert(&mut self, value: i64, weight: usize)

Examples found in repository ?

crates/competitive/src/combinatorial_optimization/knapsack_problem.rs (line 34)

29    pub fn extend<I>(&mut self, iter: I)
30    where
31        I: IntoIterator<Item = (i64, usize)>,
32    {
33        for (value, weight) in iter.into_iter() {
34            self.insert(value, weight);
35        }
36    }

Source

pub fn extend(&mut self, iter: I)
where I: IntoIterator<Item = (i64, usize)>,

Examples found in repository ?

crates/aizu_online_judge/src/dpl/dpl_1_c.rs (line 11)

6pub fn dpl_1_c(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vw: [(i64, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend(vw.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}

Source

pub fn insert01(&mut self, value: i64, weight: usize)

Examples found in repository ?

crates/competitive/src/combinatorial_optimization/knapsack_problem.rs (line 49)

44    pub fn extend01<I>(&mut self, iter: I)
45    where
46        I: IntoIterator<Item = (i64, usize)>,
47    {
48        for (value, weight) in iter.into_iter() {
49            self.insert01(value, weight);
50        }
51    }

Source

pub fn extend01(&mut self, iter: I)
where I: IntoIterator<Item = (i64, usize)>,

Examples found in repository ?

crates/aizu_online_judge/src/dpl/dpl_1_b.rs (line 11)

6pub fn dpl_1_b(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vw: [(i64, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend01(vw.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}

Source

pub fn insert_limitation(&mut self, value: i64, weight: usize, count: usize)

Examples found in repository ?

crates/competitive/src/combinatorial_optimization/knapsack_problem.rs (line 79)

74    pub fn extend_limitation<I>(&mut self, iter: I)
75    where
76        I: IntoIterator<Item = (i64, usize, usize)>,
77    {
78        for (value, weight, count) in iter.into_iter() {
79            self.insert_limitation(value, weight, count);
80        }
81    }

Source

pub fn extend_limitation(&mut self, iter: I)
where I: IntoIterator<Item = (i64, usize, usize)>,

Examples found in repository ?

crates/aizu_online_judge/src/dpl/dpl_1_g.rs (line 11)

6pub fn dpl_1_g(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vwm: [(i64, usize, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend_limitation(vwm.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}

Source

pub fn insert_limitation2(&mut self, value: i64, weight: usize, count: usize)

Examples found in repository ?

crates/competitive/src/combinatorial_optimization/knapsack_problem.rs (line 100)

95    pub fn extend_limitation2<I>(&mut self, iter: I)
96    where
97        I: IntoIterator<Item = (i64, usize, usize)>,
98    {
99        for (value, weight, count) in iter.into_iter() {
100            self.insert_limitation2(value, weight, count);
101        }
102    }

Source

pub fn extend_limitation2(&mut self, iter: I)
where I: IntoIterator<Item = (i64, usize, usize)>,

Source

pub fn solve(&self) -> Option<i64>

Examples found in repository ?

crates/aizu_online_judge/src/dpl/dpl_1_c.rs (line 12)

6pub fn dpl_1_c(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vw: [(i64, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend(vw.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}

More examples

Hide additional examples

crates/aizu_online_judge/src/dpl/dpl_1_b.rs (line 12)

6pub fn dpl_1_b(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vw: [(i64, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend01(vw.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}

crates/aizu_online_judge/src/dpl/dpl_1_g.rs (line 12)

6pub fn dpl_1_g(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, w, vwm: [(i64, usize, usize)]);
10    let mut knapsack = KnapsackPloblemSmallWeight::new(w);
11    knapsack.extend_limitation(vwm.take(n));
12    writeln!(writer, "{}", knapsack.solve().unwrap_or_default()).ok();
13}