Skip to content

refactor(tree): cleanup segment tree #63

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

Merged
himkt merged 1 commit into from
Dec 14, 2025
Merged

refactor(tree): cleanup segment tree #63

Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
75 changes: 20 additions & 55 deletions src/tree.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,7 +53,7 @@ impl SegmentTree {
if let Mode::RangeUpdate(op) = &self.mode {
let operator = match op {
Op::Add => |ret: &mut i64, v: i64| *ret += v,
_ => panic!(),
_ => panic!("Operator {:?} is not supported.", op),
};

operator(&mut ret, self.data[index]);
Expand All @@ -62,7 +62,7 @@ impl SegmentTree {
operator(&mut ret, self.data[index]);
}
} else {
panic!("Unsupported");
panic!("Mode {:?} is not supported.", &self.mode);
}

ret
Expand All @@ -80,84 +80,49 @@ impl SegmentTree {
if qr <= sl || sr <= ql {
return SegmentTree::default(op);
}

if ql <= sl && sr <= qr {
return self.data[pos];
}

fn add(l: i64, r: i64) -> i64 {
l + r
}
fn max(l: i64, r: i64) -> i64 {
l.max(r)
}
fn min(l: i64, r: i64) -> i64 {
l.min(r)
}

let sm = (sl + sr) / 2;
let lv = self.range_query_recursive(op, ql, qr, sl, sm, pos * 2);
let rv = self.range_query_recursive(op, ql, qr, sm, sr, pos * 2 + 1);
let operate = match op {
Op::Add => add,
Op::Max => max,
Op::Min => min,
};
operate(lv, rv)
match op {
Op::Add => lv + rv,
Op::Max => lv.max(rv),
Op::Min => lv.min(rv),
}
}

/// Run a range query.
pub fn get_range(&self, l: usize, r: usize) -> i64 {
if let Mode::RangeGet(op) = &self.mode {
self.range_query_recursive(op, l, r, 0, SegmentTree::SEQ_LEN, 1)
} else {
panic!("Unsupported");
panic!("Mode {:?} is not supported.", &self.mode);
}
}

/// Update an i-th element to `value`.
pub fn update_one(&mut self, mut index: usize, value: i64) {
index += SegmentTree::SEQ_LEN;

fn add_assign_one(ret: &mut i64, v: i64) {
*ret += v;
}
fn max_assign_one(ret: &mut i64, v: i64) {
*ret = v;
}
fn min_assign_one(ret: &mut i64, v: i64) {
*ret = v;
}
fn add_assign(ret: &mut i64, l: i64, r: i64) {
*ret = l + r;
}
fn max_assign(ret: &mut i64, l: i64, r: i64) {
*ret = l.max(r);
}
fn min_assign(ret: &mut i64, l: i64, r: i64) {
*ret = l.min(r);
}

if let Mode::RangeGet(op) = &self.mode {
let operate_and_assign_one = match op {
Op::Add => add_assign_one,
Op::Max => max_assign_one,
Op::Min => min_assign_one,
};
operate_and_assign_one(&mut self.data[index], value);

let operate_and_assign = match op {
Op::Add => add_assign,
Op::Max => max_assign,
Op::Min => min_assign,
};

match op {
Op::Add => self.data[index] += value,
_ => self.data[index] = value,
}
while index > 0 {
index /= 2;
let lv = self.data[index * 2];
let rv = self.data[index * 2 + 1];
operate_and_assign(&mut self.data[index], lv, rv);
match op {
Op::Add => self.data[index] = lv + rv,
Op::Max => self.data[index] = lv.max(rv),
Op::Min => self.data[index] = lv.min(rv),
};
Copy link

Copilot AI Dec 14, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Unnecessary semicolon after the closing brace of a match expression. In Rust, match expressions are expressions themselves and don't require a trailing semicolon when used as the last statement in a block or when their result is used directly.

Copilot uses AI. Check for mistakes.
}
} else {
panic!("Mode {:?} is not supported.", &self.mode);
}
}

Expand Down Expand Up @@ -186,7 +151,7 @@ impl SegmentTree {
r /= 2;
}
} else {
panic!("Unsupported");
panic!("Mode {:?} is not supported.", &self.mode);
}
}
}
Expand Down