Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Findmax random test #15

Merged
merged 2 commits into from
Oct 4, 2023
Merged

Findmax random test #15

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
75b47ae
findmax random test #12
azizkayumov Oct 4, 2023
eac3641
update test
azizkayumov Oct 4, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
122 changes: 37 additions & 85 deletions src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,12 +2,9 @@
mod node;
mod path;
mod splay;

use splay::update_max;

use crate::{
node::{Node, Parent},
splay::splay,
splay::{splay, update_max},
};

pub struct LinkCutTree {
Expand All @@ -21,6 +18,10 @@ impl LinkCutTree {
Self { forest: nodes }
}

pub fn set_weight(&mut self, v: usize, weight: f64) {
self.forest[v].weight = weight;
}

// Constructs a path from a node to the root of the tree.
pub fn access(&mut self, v: usize) {
splay(&mut self.forest, v);
Expand Down Expand Up @@ -88,7 +89,6 @@ impl LinkCutTree {
#[cfg(test)]
mod tests {
use crate::node::Parent;
use rand::{seq::SliceRandom, Rng, SeedableRng};

#[test]
pub fn access_base_case() {
Expand Down Expand Up @@ -396,96 +396,48 @@ mod tests {

#[test]
pub fn findmax() {
let mut lctree = super::LinkCutTree::new(7);
lctree.forest[0].weight = 5.0;
let mut lctree = super::LinkCutTree::new(10);
lctree.forest[0].weight = 4.0;
lctree.forest[1].weight = 2.0;
lctree.forest[2].weight = 6.0;
lctree.forest[3].weight = 3.0;
lctree.forest[4].weight = 4.0;
lctree.forest[5].weight = 0.0;
lctree.forest[6].weight = 1.0;
lctree.forest[4].weight = 9.0;
lctree.forest[5].weight = 5.0;
lctree.forest[6].weight = 0.0;
lctree.forest[7].weight = 7.0;
lctree.forest[8].weight = 1.0;
lctree.forest[9].weight = 8.0;

// we form the following structure:
// 0(5)
// /
// 1(2)
// /
// 2(6)
// /
// 3(3)
// / \
// 4(4) 6(1)
// /
// 5(0)

// 0(4)
// / \
// 1(2) 5(5)
// / \ \
// 2(6) 3(3) 6(0)
// / \
// 4(9) 7(7)
// / \
// 8(1) 9(8)
lctree.link(1, 0);
lctree.link(2, 1);
lctree.link(3, 2);
lctree.link(4, 3);
lctree.link(5, 4);
lctree.link(6, 3);
lctree.link(3, 1);
lctree.link(4, 2);
lctree.link(5, 0);
lctree.link(6, 5);
lctree.link(7, 6);
lctree.link(8, 7);
lctree.link(9, 7);

assert_eq!(lctree.findmax(2), 2);
assert_eq!(lctree.findmax(6), 2);
// we check the node index with max weight in the path from each node to the root:
assert_eq!(lctree.findmax(0), 0);
assert_eq!(lctree.findmax(5), 2);
assert_eq!(lctree.findmax(3), 2);
assert_eq!(lctree.findmax(5), 5);
assert_eq!(lctree.findmax(1), 0);
assert_eq!(lctree.findmax(4), 2);

// we cut node 3 from its parent 2:
lctree.cut(3);
assert_eq!(lctree.findmax(5), 4);
assert_eq!(lctree.findmax(6), 3);
assert_eq!(lctree.findmax(4), 4);
assert_eq!(lctree.findmax(3), 3);
assert_eq!(lctree.findmax(8), 7);
assert_eq!(lctree.findmax(2), 2);
assert_eq!(lctree.findmax(1), 0);
assert_eq!(lctree.findmax(0), 0);
}

fn create_random_tree(n: usize, seed: u64) -> (Vec<(usize, usize)>, Vec<f64>, Vec<usize>) {
let mut rng = rand::rngs::StdRng::seed_from_u64(seed);

let mut edges = Vec::new();
let mut weights: Vec<f64> = (0..n).map(|i| i as f64).collect();
weights.shuffle(&mut rng);

let mut ground_truth = vec![0; n];
let mut in_tree = Vec::from([0]);
for i in 1..n {
let parent_idx = rng.gen_range(0..in_tree.len());
let parent = in_tree[parent_idx];
edges.push((i, parent));

ground_truth[i] = if weights[i] > weights[ground_truth[parent]] {
i
} else {
ground_truth[parent]
};
in_tree.push(i);
}

(edges, weights, ground_truth)
}

#[test]
pub fn findmax_random() {
let n = 100;
let seed = rand::thread_rng().gen();
let (edges, weights, ground_truth) = create_random_tree(n, seed);
let mut lctree = super::LinkCutTree::new(n);
for i in 0..n {
lctree.forest[i].weight = weights[i];
}

for (v, w) in edges {
lctree.link(v, w);
}

for _ in 0..n * 100 {
let v = rand::thread_rng().gen_range(0..n);
assert_eq!(lctree.findmax(v), ground_truth[v]);
}
assert_eq!(lctree.findmax(4), 4);
assert_eq!(lctree.findmax(7), 7);
assert_eq!(lctree.findmax(9), 9);
assert_eq!(lctree.findmax(3), 0);
assert_eq!(lctree.findmax(6), 5);
}
}
4 changes: 2 additions & 2 deletions src/node.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,8 +36,8 @@ impl Node {
Parent::Root => "Root".to_string(),
};
format!(
"Node {{ idx: {}, left: {:?}, right: {:?}, parent: {:?}, max_weight_idx: {} }}",
self.idx, self.left, self.right, parent, self.max_weight_idx
"Node {{ idx: {}, left: {:?}, right: {:?}, parent: {parent:?}, max_weight_idx: {} }}",
self.idx, self.left, self.right, self.max_weight_idx
)
}
}
47 changes: 47 additions & 0 deletions tests/test_findmax_random.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,47 @@
use lctree::LinkCutTree;
use rand::{seq::SliceRandom, Rng, SeedableRng};

fn create_random_tree(n: usize, seed: u64) -> (Vec<(usize, usize)>, Vec<f64>, Vec<usize>) {
let mut rng = rand::rngs::StdRng::seed_from_u64(seed);

let mut edges = Vec::new();
let mut weights: Vec<f64> = (0..n).map(|i| i as f64).collect();
weights.shuffle(&mut rng);

let mut max_to_root = vec![0; n];
let mut in_tree = Vec::from([0]);
for i in 1..n {
let parent_idx = rng.gen_range(0..in_tree.len());
let parent = in_tree[parent_idx];
edges.push((i, parent));

max_to_root[i] = if weights[i] > weights[max_to_root[parent]] {
i
} else {
max_to_root[parent]
};
in_tree.push(i);
}

(edges, weights, max_to_root)
}

#[test]
pub fn findmax_random() {
let n = 100;
let seed = rand::thread_rng().gen();
let (edges, weights, max_to_root) = create_random_tree(n, seed);
let mut lctree = LinkCutTree::new(n);
for i in 0..n {
lctree.set_weight(i, weights[i]);
}

for (v, w) in edges {
lctree.link(v, w);
}

for _ in 0..n * 100 {
let v = rand::thread_rng().gen_range(0..n);
assert_eq!(lctree.findmax(v), max_to_root[v]);
}
}