QOJ.ac
QOJ
| ID | Problem | Submitter | Result | Time | Memory | Language | File size | Submit time | Judge time |
|---|---|---|---|---|---|---|---|---|---|
| #222959 | #7608. Cliques | ucup-team296# | WA | 0ms | 2220kb | Rust | 43.1kb | 2023-10-21 20:07:16 | 2023-10-21 20:07:17 |
Judging History
answer
pub mod solution {
//{"name":"c","group":"Manual","url":"","interactive":false,"timeLimit":2000,"tests":[{"input":"","output":""}],"testType":"single","input":{"type":"stdin","fileName":null,"pattern":null},"output":{"type":"stdout","fileName":null,"pattern":null},"languages":{"java":{"taskClass":"c"}}}
use crate::algo_lib::io::output::output;
use crate::algo_lib::io::task_io_settings::TaskIoType;
use crate::algo_lib::io::task_runner::run_task;
use crate::algo_lib::io::input::Input;
use crate::algo_lib::io::task_io_settings::TaskIoSettings;
use crate::algo_lib::math::modulo::Mod7;
use crate::algo_lib::seg_trees::hld::Hld;
use crate::algo_lib::seg_trees::lazy_seg_tree::SegTree;
use crate::algo_lib::seg_trees::seg_tree_trait::SegTreeNode;
#[allow(unused)]
use crate::dbg;
use crate::out;
use crate::out_line;
type Mod = Mod7;
#[derive(Clone, Copy, Default)]
struct Node {
sum: Mod,
}
impl SegTreeNode for Node {
fn join_nodes(l: &Self, r: &Self, context: &Self::Context) -> Self {
Self { sum: l.sum + r.sum }
}
fn apply_update(node: &mut Self, update: &Self::Update) {
node.sum *= *update;
}
fn join_updates(current: &mut Self::Update, add: &Self::Update) {
*current *= *add;
}
type Update = Mod;
type Context = ();
}
fn solve(input: &mut Input, _test_case: usize) {
let n = input.usize();
let mut g = vec![vec![]; n];
for _ in 0..n - 1 {
let fr = input.usize() - 1;
let to = input.usize() - 1;
g[fr].push(to);
g[to].push(fr);
}
let hld = Hld::new(g, 0);
let qq = input.usize();
// let mut vertices = vec![Mod::ONE; n];
// let mut edges = vec![Mod::ONE; n];
let mut vertices_st = SegTree::new(n, |_| Node { sum: Mod::ONE });
let mut edges_st = SegTree::new(n, |_| Node { sum: Mod::ONE });
let two = Mod::new(2);
let inv_two = Mod::ONE / two;
let mut res = Mod::ZERO;
for _ in 0..qq {
let q_type = input.string();
let add = q_type[0] == b'+';
let v = input.usize() - 1;
let u = input.usize() - 1;
for range in hld.find_path_segs(u, v) {
if add {
// for pos in range {
// res += vertices[pos];
// res -= edges[pos];
// vertices[pos] *= two;
// edges[pos] *= two;
// }
res += vertices_st.get(range.clone()).sum;
res -= edges_st.get(range.clone()).sum;
vertices_st.update(range.clone(), two);
edges_st.update(range.clone(), two);
} else {
// for pos in range {
// vertices[pos] *= inv_two;
// edges[pos] *= inv_two;
// res -= vertices[pos];
// res += edges[pos];
// }
vertices_st.update(range.clone(), inv_two);
edges_st.update(range.clone(), inv_two);
res -= vertices_st.get(range.clone()).sum;
res += edges_st.get(range.clone()).sum;
}
}
let lca = hld.lca(u, v);
if add {
// edges[lca] *= inv_two;
// res += edges[lca];
edges_st.update(lca..lca + 1, inv_two);
res += edges_st.get(lca..lca + 1).sum;
} else {
// res -= edges[lca];
// edges[lca] *= two;
res -= edges_st.get(lca..lca + 1).sum;
edges_st.update(lca..lca + 1, two);
}
out_line!(res);
}
}
pub(crate) fn run(mut input: Input) -> bool {
solve(&mut input, 1);
output().flush();
true
}
#[allow(unused)]
pub fn submit() -> bool {
let io = TaskIoSettings {
is_interactive: false,
input: TaskIoType::Std,
output: TaskIoType::Std,
};
run_task(io, run)
}
}
pub mod algo_lib {
pub mod collections {
pub mod last_exn {
use std::collections::BTreeSet;
pub trait LastExn<T> {
fn last_exn(&self) -> &T;
}
impl<T> LastExn<T> for &[T] {
fn last_exn(&self) -> &T {
self.last().unwrap()
}
}
impl<T> LastExn<T> for Vec<T> {
fn last_exn(&self) -> &T {
self.last().unwrap()
}
}
impl<T> LastExn<T> for BTreeSet<T> {
fn last_exn(&self) -> &T {
self.iter().next_back().unwrap()
}
}
}
}
pub mod io {
pub mod input {
use std::fmt::Debug;
use std::io::Read;
use std::marker::PhantomData;
use std::path::Path;
use std::str::FromStr;
pub struct Input {
input: Box<dyn Read>,
buf: Vec<u8>,
at: usize,
buf_read: usize,
}
macro_rules! read_integer_fun {
($t:ident) => {
#[allow(unused)]
pub fn $t(&mut self) -> $t {
self.read_integer()
}
};
}
impl Input {
const DEFAULT_BUF_SIZE: usize = 4096;
///
/// Using with stdin:
/// ```no_run
/// use algo_lib::io::input::Input;
/// let stdin = std::io::stdin();
/// let input = Input::new(Box::new(stdin));
/// ```
///
/// For read files use ``new_file`` instead.
///
///
pub fn new(input: Box<dyn Read>) -> Self {
Self {
input,
buf: vec![0; Self::DEFAULT_BUF_SIZE],
at: 0,
buf_read: 0,
}
}
pub fn new_file<P: AsRef<Path>>(path: P) -> Self {
let file = std::fs::File::open(&path)
.unwrap_or_else(|_| panic!("Can't open file: {:?}", path.as_ref().as_os_str()));
Self::new(Box::new(file))
}
pub fn new_with_size(input: Box<dyn Read>, buf_size: usize) -> Self {
Self {
input,
buf: vec![0; buf_size],
at: 0,
buf_read: 0,
}
}
pub fn new_file_with_size<P: AsRef<Path>>(path: P, buf_size: usize) -> Self {
let file = std::fs::File::open(&path)
.unwrap_or_else(|_| panic!("Can't open file: {:?}", path.as_ref().as_os_str()));
Self::new_with_size(Box::new(file), buf_size)
}
pub fn get(&mut self) -> Option<u8> {
if self.refill_buffer() {
let res = self.buf[self.at];
self.at += 1;
Some(res)
} else {
None
}
}
pub fn peek(&mut self) -> Option<u8> {
if self.refill_buffer() {
Some(self.buf[self.at])
} else {
None
}
}
pub fn skip_whitespace(&mut self) {
while let Some(b) = self.peek() {
if !char::from(b).is_whitespace() {
return;
}
self.get();
}
}
pub fn next_token(&mut self) -> Option<Vec<u8>> {
self.skip_whitespace();
let mut res = Vec::new();
while let Some(c) = self.get() {
if char::from(c).is_whitespace() {
break;
}
res.push(c);
}
if res.is_empty() {
None
} else {
Some(res)
}
}
//noinspection RsSelfConvention
pub fn is_exhausted(&mut self) -> bool {
self.peek().is_none()
}
pub fn has_more_elements(&mut self) -> bool {
!self.is_exhausted()
}
pub fn read<T: Readable>(&mut self) -> T {
T::read(self)
}
pub fn vec<T: Readable>(&mut self, size: usize) -> Vec<T> {
let mut res = Vec::with_capacity(size);
for _ in 0usize..size {
res.push(self.read());
}
res
}
pub fn string_vec(&mut self, size: usize) -> Vec<Vec<u8>> {
let mut res = Vec::with_capacity(size);
for _ in 0usize..size {
res.push(self.string());
}
res
}
pub fn read_line(&mut self) -> String {
let mut res = String::new();
while let Some(c) = self.get() {
if c == b'\n' {
break;
}
if c == b'\r' {
if self.peek() == Some(b'\n') {
self.get();
}
break;
}
res.push(c.into());
}
res
}
#[allow(clippy::should_implement_trait)]
pub fn into_iter<T: Readable>(self) -> InputIterator<T> {
InputIterator {
input: self,
phantom: Default::default(),
}
}
fn read_integer<T: FromStr>(&mut self) -> T
where
<T as FromStr>::Err: Debug,
{
let res = self.read_string();
res.parse::<T>().unwrap()
}
fn read_string(&mut self) -> String {
match self.next_token() {
None => {
panic!("Input exhausted");
}
Some(res) => unsafe { String::from_utf8_unchecked(res) },
}
}
pub fn string_as_string(&mut self) -> String {
self.read_string()
}
pub fn string(&mut self) -> Vec<u8> {
self.read_string().into_bytes()
}
fn read_char(&mut self) -> char {
self.skip_whitespace();
self.get().unwrap().into()
}
fn read_float(&mut self) -> f64 {
self.read_string().parse().unwrap()
}
pub fn f64(&mut self) -> f64 {
self.read_float()
}
fn refill_buffer(&mut self) -> bool {
if self.at == self.buf_read {
self.at = 0;
self.buf_read = self.input.read(&mut self.buf).unwrap();
self.buf_read != 0
} else {
true
}
}
read_integer_fun!(i32);
read_integer_fun!(i64);
read_integer_fun!(i128);
read_integer_fun!(u32);
read_integer_fun!(u64);
read_integer_fun!(usize);
}
pub trait Readable {
fn read(input: &mut Input) -> Self;
}
impl Readable for String {
fn read(input: &mut Input) -> Self {
input.read_string()
}
}
impl Readable for char {
fn read(input: &mut Input) -> Self {
input.read_char()
}
}
impl Readable for f64 {
fn read(input: &mut Input) -> Self {
input.read_string().parse().unwrap()
}
}
impl Readable for f32 {
fn read(input: &mut Input) -> Self {
input.read_string().parse().unwrap()
}
}
impl<T: Readable> Readable for Vec<T> {
fn read(input: &mut Input) -> Self {
let size = input.read();
input.vec(size)
}
}
pub struct InputIterator<T: Readable> {
input: Input,
phantom: PhantomData<T>,
}
impl<T: Readable> Iterator for InputIterator<T> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.input.skip_whitespace();
self.input.peek().map(|_| self.input.read())
}
}
macro_rules! read_integer {
($t:ident) => {
impl Readable for $t {
fn read(input: &mut Input) -> Self {
input.read_integer()
}
}
};
}
read_integer!(i8);
read_integer!(i16);
read_integer!(i32);
read_integer!(i64);
read_integer!(i128);
read_integer!(isize);
read_integer!(u8);
read_integer!(u16);
read_integer!(u32);
read_integer!(u64);
read_integer!(u128);
read_integer!(usize);
}
pub mod output {
use std::io::Write;
pub struct Output {
output: Box<dyn Write>,
buf: Vec<u8>,
at: usize,
auto_flush: bool,
}
impl Output {
const DEFAULT_BUF_SIZE: usize = 4096;
pub fn new(output: Box<dyn Write>) -> Self {
Self {
output,
buf: vec![0; Self::DEFAULT_BUF_SIZE],
at: 0,
auto_flush: false,
}
}
pub fn new_with_auto_flush(output: Box<dyn Write>) -> Self {
Self {
output,
buf: vec![0; Self::DEFAULT_BUF_SIZE],
at: 0,
auto_flush: true,
}
}
pub fn flush(&mut self) {
if self.at != 0 {
self.output.write_all(&self.buf[..self.at]).unwrap();
self.at = 0;
self.output.flush().expect("Couldn't flush output");
}
}
pub fn print<T: Writable>(&mut self, s: &T) {
s.write(self);
}
pub fn put(&mut self, b: u8) {
self.buf[self.at] = b;
self.at += 1;
if self.at == self.buf.len() {
self.flush();
}
}
pub fn maybe_flush(&mut self) {
if self.auto_flush {
self.flush();
}
}
pub fn print_per_line<T: Writable>(&mut self, arg: &[T]) {
for i in arg {
i.write(self);
self.put(b'\n');
}
}
pub fn print_iter<T: Writable, I: Iterator<Item = T>>(&mut self, iter: I) {
let mut first = true;
for e in iter {
if first {
first = false;
} else {
self.put(b' ');
}
e.write(self);
}
}
pub fn print_iter_ref<'a, T: 'a + Writable, I: Iterator<Item = &'a T>>(&mut self, iter: I) {
let mut first = true;
for e in iter {
if first {
first = false;
} else {
self.put(b' ');
}
e.write(self);
}
}
}
impl Write for Output {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
let mut start = 0usize;
let mut rem = buf.len();
while rem > 0 {
let len = (self.buf.len() - self.at).min(rem);
self.buf[self.at..self.at + len].copy_from_slice(&buf[start..start + len]);
self.at += len;
if self.at == self.buf.len() {
self.flush();
}
start += len;
rem -= len;
}
if self.auto_flush {
self.flush();
}
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
self.flush();
Ok(())
}
}
pub trait Writable {
fn write(&self, output: &mut Output);
}
impl Writable for &str {
fn write(&self, output: &mut Output) {
output.write_all(self.as_bytes()).unwrap();
}
}
impl Writable for String {
fn write(&self, output: &mut Output) {
output.write_all(self.as_bytes()).unwrap();
}
}
impl Writable for char {
fn write(&self, output: &mut Output) {
output.put(*self as u8);
}
}
impl<T: Writable> Writable for [T] {
fn write(&self, output: &mut Output) {
output.print_iter_ref(self.iter());
}
}
impl<T: Writable> Writable for Vec<T> {
fn write(&self, output: &mut Output) {
self[..].write(output);
}
}
macro_rules! write_to_string {
($t:ident) => {
impl Writable for $t {
fn write(&self, output: &mut Output) {
self.to_string().write(output);
}
}
};
}
write_to_string!(u8);
write_to_string!(u16);
write_to_string!(u32);
write_to_string!(u64);
write_to_string!(u128);
write_to_string!(usize);
write_to_string!(i8);
write_to_string!(i16);
write_to_string!(i32);
write_to_string!(i64);
write_to_string!(i128);
write_to_string!(isize);
write_to_string!(f32);
write_to_string!(f64);
impl<T: Writable, U: Writable> Writable for (T, U) {
fn write(&self, output: &mut Output) {
self.0.write(output);
output.put(b' ');
self.1.write(output);
}
}
impl<T: Writable, U: Writable, V: Writable> Writable for (T, U, V) {
fn write(&self, output: &mut Output) {
self.0.write(output);
output.put(b' ');
self.1.write(output);
output.put(b' ');
self.2.write(output);
}
}
pub static mut OUTPUT: Option<Output> = None;
pub fn set_global_output_to_stdout() {
unsafe {
OUTPUT = Some(Output::new(Box::new(std::io::stdout())));
}
}
pub fn set_global_output_to_file(path: &str) {
unsafe {
let out_file =
std::fs::File::create(path).unwrap_or_else(|_| panic!("Can't create file {}", path));
OUTPUT = Some(Output::new(Box::new(out_file)));
}
}
pub fn set_global_output_to_none() {
unsafe {
match &mut OUTPUT {
None => {}
Some(output) => output.flush(),
}
OUTPUT = None;
}
}
pub fn output() -> &'static mut Output {
unsafe {
match &mut OUTPUT {
None => {
panic!("Global output wasn't initialized");
}
Some(output) => output,
}
}
}
#[macro_export]
macro_rules! out {
($first: expr $(,$args:expr )*) => {
output().print(&$first);
$(output().put(b' ');
output().print(&$args);
)*
output().maybe_flush();
}
}
#[macro_export]
macro_rules! out_line {
($first: expr $(, $args:expr )* ) => {
{
out!($first $(,$args)*);
output().put(b'\n');
output().maybe_flush();
}
};
() => {
{
output().put(b'\n');
output().maybe_flush();
}
};
}
}
pub mod task_io_settings {
pub enum TaskIoType {
Std,
File(String),
}
pub struct TaskIoSettings {
pub is_interactive: bool,
pub input: TaskIoType,
pub output: TaskIoType,
}
}
pub mod task_runner {
use std::io::Write;
use super::input::Input;
use super::output::Output;
use super::output::OUTPUT;
use super::task_io_settings::TaskIoSettings;
use super::task_io_settings::TaskIoType;
pub fn run_task<Res>(io: TaskIoSettings, run: impl FnOnce(Input) -> Res) -> Res {
let output: Box<dyn Write> = match io.output {
TaskIoType::Std => Box::new(std::io::stdout()),
TaskIoType::File(file) => {
let out_file = std::fs::File::create(file).unwrap();
Box::new(out_file)
}
};
unsafe {
OUTPUT = Some(Output::new(output));
}
let input = match io.input {
TaskIoType::Std => {
let sin = std::io::stdin();
Input::new(Box::new(sin))
}
TaskIoType::File(file) => Input::new_file(file),
};
run(input)
}
}
}
pub mod math {
pub mod modulo {
use crate::algo_lib::collections::last_exn::LastExn;
use crate::algo_lib::io::input::Input;
use crate::algo_lib::io::input::Readable;
use crate::algo_lib::io::output::Output;
use crate::algo_lib::io::output::Writable;
use crate::algo_lib::misc::num_traits::ConvSimple;
use crate::algo_lib::misc::num_traits::HasConstants;
use crate::algo_lib::misc::num_traits::Number;
use std::io::Write;
use std::marker::PhantomData;
pub trait Value: Clone + Copy + Eq + Default + Ord {
fn val() -> i32;
}
#[derive(Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd, Hash)]
pub struct ModWithValue<M>(i32, PhantomData<M>)
where
M: Value;
impl<M> ModWithValue<M>
where
M: Value,
{
#[allow(unused)]
pub const ZERO: Self = Self(0, PhantomData);
#[allow(unused)]
pub const ONE: Self = Self(1, PhantomData);
#[allow(unused)]
pub const TWO: Self = Self(2, PhantomData);
fn rev_rec(a: i32, m: i32) -> i32 {
if a == 1 {
return a;
}
((1 - Self::rev_rec(m % a, a) as i64 * m as i64) / a as i64 + m as i64) as i32
}
#[allow(dead_code)]
pub fn inv(self) -> Self {
ModWithValue(Self::rev_rec(self.0, M::val()), PhantomData)
}
pub fn value(&self) -> i32 {
self.0
}
#[allow(dead_code)]
pub fn new<T: Number>(x: T) -> Self {
let mut x = x.to_i32();
if x < 0 {
x += M::val();
if x < 0 {
x %= M::val();
x += M::val();
}
} else if x >= M::val() {
x -= M::val();
if x >= M::val() {
x %= M::val();
}
}
assert!(0 <= x && x < M::val());
Self(x, PhantomData)
}
pub fn pown(self, pw: usize) -> Self {
if pw == 0 {
Self::ONE
} else if pw == 1 {
self
} else {
let half = self.pown(pw / 2);
let res = half * half;
if pw % 2 == 0 {
res
} else {
res * self
}
}
}
pub fn gen_powers(base: Self, n: usize) -> Vec<Self> {
let mut res = Vec::with_capacity(n);
res.push(Self::ONE);
for _ in 1..n {
res.push(*res.last_exn() * base);
}
res
}
}
impl<M> std::fmt::Display for ModWithValue<M>
where
M: Value,
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
impl<M> std::fmt::Debug for ModWithValue<M>
where
M: Value + Copy + Eq,
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
const MAX: i32 = 100;
if self.0 <= MAX {
write!(f, "{}", self.0)
} else if self.0 >= M::val() - MAX {
write!(f, "-{}", M::val() - self.0)
} else {
for denom in 1..MAX {
let num = *self * Self(denom, PhantomData);
if num.0 <= MAX {
return write!(f, "{}/{}", num.0, denom);
} else if num.0 >= M::val() - MAX {
return write!(f, "-{}/{}", M::val() - num.0, denom);
}
}
write!(f, "(?? {} ??)", self.0)
}
}
}
impl<M> std::ops::Add for ModWithValue<M>
where
M: Value,
{
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
let res = self.0 + rhs.0;
if res >= M::val() {
ModWithValue(res - M::val(), PhantomData)
} else {
ModWithValue(res, PhantomData)
}
}
}
impl<M> std::ops::AddAssign for ModWithValue<M>
where
M: Value,
{
fn add_assign(&mut self, rhs: Self) {
self.0 += rhs.0;
if self.0 >= M::val() {
self.0 -= M::val();
}
}
}
impl<M> std::ops::Sub for ModWithValue<M>
where
M: Value,
{
type Output = Self;
fn sub(self, rhs: Self) -> Self::Output {
let res = self.0 - rhs.0;
if res < 0 {
ModWithValue(res + M::val(), PhantomData)
} else {
ModWithValue(res, PhantomData)
}
}
}
impl<M> std::ops::SubAssign for ModWithValue<M>
where
M: Value,
{
fn sub_assign(&mut self, rhs: Self) {
self.0 -= rhs.0;
if self.0 < 0 {
self.0 += M::val();
}
}
}
impl<M> std::ops::Mul for ModWithValue<M>
where
M: Value,
{
type Output = Self;
fn mul(self, rhs: Self) -> Self::Output {
let res = (self.0 as i64) * (rhs.0 as i64) % (M::val() as i64);
ModWithValue(res as i32, PhantomData)
}
}
impl<M> std::ops::MulAssign for ModWithValue<M>
where
M: Value,
{
fn mul_assign(&mut self, rhs: Self) {
self.0 = ((self.0 as i64) * (rhs.0 as i64) % (M::val() as i64)) as i32;
}
}
impl<M> std::ops::Div for ModWithValue<M>
where
M: Value,
{
type Output = Self;
#[allow(clippy::suspicious_arithmetic_impl)]
fn div(self, rhs: Self) -> Self::Output {
let rhs_inv = rhs.inv();
self * rhs_inv
}
}
impl<M> std::ops::DivAssign for ModWithValue<M>
where
M: Value,
{
#[allow(clippy::suspicious_op_assign_impl)]
fn div_assign(&mut self, rhs: Self) {
*self *= rhs.inv();
}
}
impl<M> Writable for ModWithValue<M>
where
M: Value,
{
fn write(&self, output: &mut Output) {
output.write_fmt(format_args!("{}", self.0)).unwrap();
}
}
impl<M> Readable for ModWithValue<M>
where
M: Value,
{
fn read(input: &mut Input) -> Self {
let i32 = input.i32();
Self::new(i32)
}
}
impl<M> HasConstants<ModWithValue<M>> for ModWithValue<M>
where
M: Value,
{
// This doesn't make much sense, but hope we never use
const MAX: ModWithValue<M> = ModWithValue::ZERO;
const MIN: ModWithValue<M> = ModWithValue::ZERO;
const ZERO: ModWithValue<M> = ModWithValue::ZERO;
const ONE: ModWithValue<M> = ModWithValue::ONE;
const TWO: ModWithValue<M> = ModWithValue::TWO;
}
impl<M> ConvSimple<ModWithValue<M>> for ModWithValue<M>
where
M: Value,
{
fn from_i32(val: i32) -> ModWithValue<M> {
ModWithValue::new(val)
}
fn to_i32(self) -> i32 {
self.0
}
fn to_f64(self) -> f64 {
self.0 as f64
}
}
pub trait ConstValue: Value + Copy {
const VAL: i32;
}
impl<V: ConstValue> Value for V {
fn val() -> i32 {
Self::VAL
}
}
#[derive(Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd, Hash)]
pub struct Value7();
impl ConstValue for Value7 {
const VAL: i32 = 1_000_000_007;
}
pub type Mod7 = ModWithValue<Value7>;
#[derive(Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd, Hash)]
pub struct Value9();
impl ConstValue for Value9 {
const VAL: i32 = 1_000_000_009;
}
pub type Mod9 = ModWithValue<Value9>;
#[derive(Copy, Clone, Eq, PartialEq, Default, Ord, PartialOrd, Hash)]
#[allow(non_camel_case_types)]
pub struct Value_998_244_353();
impl ConstValue for Value_998_244_353 {
const VAL: i32 = 998_244_353;
}
#[allow(non_camel_case_types)]
pub type Mod_998_244_353 = ModWithValue<Value_998_244_353>;
pub trait ModuloTrait: Number {
fn mod_value() -> i32;
fn pown(self, n: usize) -> Self;
}
impl<V: Value> ModuloTrait for ModWithValue<V> {
fn mod_value() -> i32 {
V::val()
}
fn pown(self, n: usize) -> Self {
self.pown(n)
}
}
}
}
pub mod misc {
pub mod dbg_macro {
#[macro_export]
#[allow(unused_macros)]
macro_rules! dbg {
($first_val:expr, $($val:expr),+ $(,)?) => {
eprint!("[{}:{}] {} = {:?}",
file!(), line!(), stringify!($first_val), &$first_val);
($(eprint!(", {} = {:?}", stringify!($val), &$val)),+,);
eprintln!();
};
($first_val:expr) => {
eprintln!("[{}:{}] {} = {:?}",
file!(), line!(), stringify!($first_val), &$first_val)
};
}
}
pub mod num_traits {
use std::cmp::Ordering;
use std::fmt::Debug;
use std::ops::Add;
use std::ops::AddAssign;
use std::ops::Div;
use std::ops::DivAssign;
use std::ops::Mul;
use std::ops::MulAssign;
use std::ops::Sub;
use std::ops::SubAssign;
pub trait HasConstants<T> {
const MAX: T;
const MIN: T;
const ZERO: T;
const ONE: T;
const TWO: T;
}
pub trait ConvSimple<T> {
fn from_i32(val: i32) -> T;
fn to_i32(self) -> i32;
fn to_f64(self) -> f64;
}
pub trait Signum {
fn signum(&self) -> i32;
}
pub trait Number:
Copy
+ Add<Output = Self>
+ AddAssign
+ Sub<Output = Self>
+ SubAssign
+ Mul<Output = Self>
+ MulAssign
+ Div<Output = Self>
+ DivAssign
+ PartialOrd
+ PartialEq
+ HasConstants<Self>
+ Default
+ Debug
+ Sized
+ ConvSimple<Self>
{
}
impl<
T: Copy
+ Add<Output = Self>
+ AddAssign
+ Sub<Output = Self>
+ SubAssign
+ Mul<Output = Self>
+ MulAssign
+ Div<Output = Self>
+ DivAssign
+ PartialOrd
+ PartialEq
+ HasConstants<Self>
+ Default
+ Debug
+ Sized
+ ConvSimple<Self>,
> Number for T
{
}
macro_rules! has_constants_impl {
($t: ident) => {
impl HasConstants<$t> for $t {
// TODO: remove `std` for new rust version..
const MAX: $t = std::$t::MAX;
const MIN: $t = std::$t::MIN;
const ZERO: $t = 0;
const ONE: $t = 1;
const TWO: $t = 2;
}
impl ConvSimple<$t> for $t {
fn from_i32(val: i32) -> $t {
val as $t
}
fn to_i32(self) -> i32 {
self as i32
}
fn to_f64(self) -> f64 {
self as f64
}
}
};
}
has_constants_impl!(i32);
has_constants_impl!(i64);
has_constants_impl!(i128);
has_constants_impl!(u32);
has_constants_impl!(u64);
has_constants_impl!(u128);
has_constants_impl!(usize);
has_constants_impl!(u8);
impl ConvSimple<Self> for f64 {
fn from_i32(val: i32) -> Self {
val as f64
}
fn to_i32(self) -> i32 {
self as i32
}
fn to_f64(self) -> f64 {
self
}
}
impl HasConstants<Self> for f64 {
const MAX: Self = Self::MAX;
const MIN: Self = -Self::MAX;
const ZERO: Self = 0.0;
const ONE: Self = 1.0;
const TWO: Self = 2.0;
}
impl<T: Number + Ord> Signum for T {
fn signum(&self) -> i32 {
match self.cmp(&T::ZERO) {
Ordering::Greater => 1,
Ordering::Less => -1,
Ordering::Equal => 0,
}
}
}
}
pub mod rec_function {
// Copied from https://github.com/EgorKulikov/rust_algo/blob/master/algo_lib/src/misc/recursive_function.rs
use std::marker::PhantomData;
macro_rules! recursive_function {
($name: ident, $trait: ident, ($($type: ident $arg: ident,)*)) => {
pub trait $trait<$($type, )*Output> {
fn call(&mut self, $($arg: $type,)*) -> Output;
}
pub struct $name<F, $($type, )*Output>
where
F: FnMut(&mut dyn $trait<$($type, )*Output>, $($type, )*) -> Output,
{
f: F,
$($arg: PhantomData<$type>,
)*
phantom_output: PhantomData<Output>,
}
impl<F, $($type, )*Output> $name<F, $($type, )*Output>
where
F: FnMut(&mut dyn $trait<$($type, )*Output>, $($type, )*) -> Output,
{
pub fn new(f: F) -> Self {
Self {
f,
$($arg: Default::default(),
)*
phantom_output: Default::default(),
}
}
}
impl<F, $($type, )*Output> $trait<$($type, )*Output> for $name<F, $($type, )*Output>
where
F: FnMut(&mut dyn $trait<$($type, )*Output>, $($type, )*) -> Output,
{
fn call(&mut self, $($arg: $type,)*) -> Output {
let const_ptr = &self.f as *const F;
let mut_ptr = const_ptr as *mut F;
unsafe { (&mut *mut_ptr)(self, $($arg, )*) }
}
}
}
}
recursive_function!(RecursiveFunction0, Callable0, ());
recursive_function!(RecursiveFunction, Callable, (Arg arg,));
recursive_function!(RecursiveFunction2, Callable2, (Arg1 arg1, Arg2 arg2,));
recursive_function!(RecursiveFunction3, Callable3, (Arg1 arg1, Arg2 arg2, Arg3 arg3,));
recursive_function!(RecursiveFunction4, Callable4, (Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4,));
recursive_function!(RecursiveFunction5, Callable5, (Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5,));
recursive_function!(RecursiveFunction6, Callable6, (Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6,));
recursive_function!(RecursiveFunction7, Callable7, (Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6, Arg7 arg7,));
recursive_function!(RecursiveFunction8, Callable8, (Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6, Arg7 arg7, Arg8 arg8,));
recursive_function!(RecursiveFunction9, Callable9, (Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6, Arg7 arg7, Arg8 arg8, Arg9 arg9,));
}
}
pub mod seg_trees {
pub mod hld {
use std::ops::Range;
use crate::algo_lib::misc::rec_function::Callable;
use crate::algo_lib::misc::rec_function::Callable3;
use crate::algo_lib::misc::rec_function::RecursiveFunction;
use crate::algo_lib::misc::rec_function::RecursiveFunction3;
pub struct Hld {
parent: Vec<usize>,
pub order: Vec<usize>,
block_start: Vec<usize>,
pos_in_order: Vec<usize>,
}
impl Hld {
pub fn new(mut g: Vec<Vec<usize>>, tree_root: usize) -> Self {
let n = g.len();
let mut size = vec![0; n];
let mut parent = vec![0; n];
RecursiveFunction3::new(|f, v: usize, p: usize, h: usize| {
parent[v] = p;
size[v] = 1;
for &to in g[v].iter() {
if to != p {
f.call(to, v, h + 1);
size[v] += size[to];
}
}
g[v].sort_by(|&u, &v| size[u].cmp(&size[v]).reverse());
})
.call(tree_root, tree_root, 0);
let mut order = vec![];
RecursiveFunction::new(|f, v: usize| {
order.push(v);
for &to in g[v].iter() {
if to != parent[v] {
f.call(to);
}
}
})
.call(tree_root);
let mut pos_in_order = vec![0; n];
for i in 0..n {
pos_in_order[order[i]] = i;
}
let mut block_start = vec![0; n];
for i in 1..n {
if order[i - 1] == parent[order[i]] {
block_start[i] = block_start[i - 1];
} else {
block_start[i] = i;
}
}
Self {
parent,
order,
block_start,
pos_in_order,
}
}
pub fn find_path_segs(&self, mut u: usize, mut v: usize) -> Vec<Range<usize>> {
let mut segs = vec![];
while u != v {
if self.pos_in_order[u] < self.pos_in_order[v] {
std::mem::swap(&mut u, &mut v);
}
let from = std::cmp::max(
self.block_start[self.pos_in_order[u]],
self.pos_in_order[v] + 1,
);
segs.push(from..self.pos_in_order[u] + 1);
u = self.parent[self.order[from]];
}
segs.push(self.pos_in_order[v]..self.pos_in_order[v] + 1);
segs
}
pub fn lca(&self, mut v: usize, mut u: usize) -> usize {
while v != u {
if self.pos_in_order[v] < self.pos_in_order[u] {
std::mem::swap(&mut v, &mut u);
}
if self.block_start[self.pos_in_order[v]] <= self.pos_in_order[u] {
return u;
}
v = self.parent[self.order[self.block_start[self.pos_in_order[v]]]];
}
v
}
}
}
pub mod lazy_seg_tree {
use std::ops::Range;
use crate::algo_lib::seg_trees::seg_tree_trait::SegTreeNode;
///
/// Segment Tree
///
#[allow(unused)]
#[derive(Clone)]
pub struct SegTree<T: SegTreeNode> {
n: usize,
tree: Vec<T>,
updates_to_push: Vec<Option<T::Update>>,
context: T::Context,
right_nodes: Vec<usize>,
}
#[allow(unused)]
impl<T: SegTreeNode> SegTree<T> {
fn pull(&mut self, v: usize, vr: usize) {
self.tree[v] = T::join_nodes(&self.tree[v + 1], &self.tree[vr], &self.context);
}
fn build(&mut self, v: usize, l: usize, r: usize, init_val: &T) {
if l + 1 == r {
self.tree[v] = init_val.clone();
} else {
let m = (l + r) >> 1;
let vr = v + ((m - l) << 1);
self.build(v + 1, l, m, init_val);
self.build(vr, m, r, init_val);
self.pull(v, vr);
}
}
fn push(&mut self, v: usize, l: usize, r: usize) {
let update = self.updates_to_push[v].clone();
self.updates_to_push[v] = None;
match update {
None => {}
Some(update) => {
let m = (l + r) >> 1;
self.apply_update(v + 1, &update, m - l == 1);
self.apply_update(v + ((r - l) & !1), &update, r - m == 1);
}
}
}
fn get_(&mut self, v: usize, l: usize, r: usize, ql: usize, qr: usize) -> T {
assert!(qr >= l);
assert!(ql < r);
if ql <= l && r <= qr {
return self.tree[v].clone();
}
let m = (l + r) >> 1;
let vr = v + ((m - l) << 1);
self.push(v, l, r);
let res = if ql >= m {
self.get_(vr, m, r, ql, qr)
} else if qr <= m {
self.get_(v + 1, l, m, ql, qr)
} else {
T::join_nodes(
&self.get_(v + 1, l, m, ql, qr),
&self.get_(vr, m, r, ql, qr),
&self.context,
)
};
self.pull(v, vr);
res
}
fn join_updates(current: &mut Option<T::Update>, add: &T::Update) {
match current {
None => *current = Some(add.clone()),
Some(current) => T::join_updates(current, add),
};
}
fn apply_update(&mut self, v: usize, update: &T::Update, is_leaf: bool) {
T::apply_update(&mut self.tree[v], update);
if !is_leaf {
Self::join_updates(&mut self.updates_to_push[v], update);
}
}
fn modify_(&mut self, v: usize, l: usize, r: usize, ql: usize, qr: usize, update: &T::Update) {
assert!(qr >= l);
assert!(ql < r);
if ql <= l && r <= qr {
self.apply_update(v, update, r - l == 1);
return;
}
let m = (l + r) >> 1;
let vr = v + ((m - l) << 1);
self.push(v, l, r);
if ql >= m {
self.modify_(vr, m, r, ql, qr, update);
} else if qr <= m {
self.modify_(v + 1, l, m, ql, qr, update);
} else {
self.modify_(v + 1, l, m, ql, qr, update);
self.modify_(vr, m, r, ql, qr, update);
};
self.pull(v, vr);
}
pub fn update(&mut self, range: Range<usize>, update: T::Update) {
if range.is_empty() {
return;
}
assert!(!range.is_empty());
self.modify_(0, 0, self.n, range.start, range.end, &update);
}
pub fn update_point(&mut self, pos: usize, new_node: T) {
let mut l = 0;
let mut r = self.n;
let mut v: usize = 0;
let mut to_pull = vec![];
while r - l > 1 {
let m = (l + r) >> 1;
let vr = v + ((m - l) << 1);
self.push(v, l, r);
to_pull.push((v, vr));
if pos < m {
r = m;
v = v + 1;
} else {
l = m;
v = vr;
}
}
self.tree[v] = new_node;
for (v, vr) in to_pull.into_iter().rev() {
self.pull(v, vr);
}
}
fn find_last_true_(
&mut self,
v: usize,
l: usize,
r: usize,
range: Range<usize>,
f: &impl Fn(&T) -> bool,
) -> Option<usize> {
if range.start >= r || l >= range.end {
return None;
}
let m = (l + r) >> 1;
let vr = v + ((m - l) << 1);
if range.start <= l && r <= range.end {
if !f(&self.tree[v]) {
return None;
}
if r - l == 1 {
return Some(l);
}
}
self.push(v, l, r);
if let Some(res) = self.find_last_true_(vr, m, r, range.clone(), f) {
Some(res)
} else {
self.find_last_true_(v + 1, l, m, range, f)
}
}
// returns position
pub fn find_last_true(&mut self, range: Range<usize>, f: impl Fn(&T) -> bool) -> Option<usize> {
self.find_last_true_(0, 0, self.n, range, &f)
}
pub fn get(&mut self, range: Range<usize>) -> T {
if range.is_empty() {
return T::default();
}
self.get_(0, 0, self.n, range.start, range.end)
}
pub fn new_with_context(n: usize, f: impl Fn(usize) -> T, context: T::Context) -> Self {
assert!(n > 0);
let tree = vec![T::default(); 2 * n - 1];
let updates_to_push = vec![None; 2 * n - 1];
let mut res = SegTree {
n,
tree,
updates_to_push,
context,
right_nodes: vec![],
};
res.build_f(0, 0, n, &f);
res
}
pub fn new(n: usize, f: impl Fn(usize) -> T) -> Self
where
T::Context: Default,
{
assert!(n > 0);
let tree = vec![T::default(); 2 * n - 1];
let updates_to_push = vec![None; 2 * n - 1];
let mut res = SegTree {
n,
tree,
updates_to_push,
context: T::Context::default(),
right_nodes: vec![],
};
res.build_f(0, 0, n, &f);
res
}
fn build_f(&mut self, v: usize, l: usize, r: usize, f: &impl Fn(usize) -> T) {
if l + 1 == r {
self.tree[v] = f(l);
} else {
let m = (l + r) >> 1;
let vr = v + ((m - l) << 1);
self.build_f(v + 1, l, m, f);
self.build_f(vr, m, r, f);
self.pull(v, vr);
}
}
pub fn len(&self) -> usize {
self.n
}
pub fn expert_get_node(&self, node: usize) -> &T {
&self.tree[node]
}
pub fn expert_get_left_node(&self, node: usize) -> usize {
node + 1
}
fn build_right_nodes(&mut self, v: usize, l: usize, r: usize) {
if l + 1 == r {
self.right_nodes.push(0);
} else {
let m = (l + r) >> 1;
let vr = v + ((m - l) << 1);
self.right_nodes.push(vr);
self.build_right_nodes(v + 1, l, m);
self.build_right_nodes(vr, m, r);
}
}
// TODO: shouldn't be mut
pub fn expert_get_right_node(&mut self, node: usize) -> usize {
if self.right_nodes.is_empty() {
self.build_right_nodes(0, 0, self.n);
}
self.right_nodes[node]
}
// Used for Kinetic Seg Tree
pub fn expert_rebuild_nodes(&mut self, should_rebuild: impl Fn(&T, &T::Context) -> bool) {
self.expert_rebuild_nodes_(0, 0, self.n, &should_rebuild);
}
fn expert_rebuild_nodes_(
&mut self,
v: usize,
l: usize,
r: usize,
should_rebuild: &impl Fn(&T, &T::Context) -> bool,
) {
if r - l <= 1 || !should_rebuild(&self.tree[v], &self.context) {
return;
}
let m = (l + r) >> 1;
let vr = v + ((m - l) << 1);
self.push(v, l, r);
self.expert_rebuild_nodes_(v + 1, l, m, should_rebuild);
self.expert_rebuild_nodes_(vr, m, r, should_rebuild);
self.pull(v, vr);
}
pub fn update_context(&mut self, f: impl Fn(&mut T::Context)) {
f(&mut self.context);
}
pub fn get_context(&self) -> &T::Context {
&self.context
}
}
}
pub mod seg_tree_trait {
pub trait SegTreeNode: Clone + Default {
fn join_nodes(l: &Self, r: &Self, context: &Self::Context) -> Self;
fn apply_update(node: &mut Self, update: &Self::Update);
fn join_updates(current: &mut Self::Update, add: &Self::Update);
type Update: Clone;
type Context;
}
}
}
}
fn main() {
crate::solution::submit();
}
Details
Tip: Click on the bar to expand more detailed information
Test #1:
score: 100
Accepted
time: 0ms
memory: 2080kb
input:
5 1 2 5 1 2 3 4 2 6 + 4 5 + 2 2 + 1 3 - 2 2 + 2 3 + 4 4
output:
1 3 7 3 7 9
result:
ok 6 lines
Test #2:
score: -100
Wrong Answer
time: 0ms
memory: 2220kb
input:
20 8 7 19 10 12 14 3 16 17 13 7 10 5 6 1 9 15 12 5 2 16 13 3 11 20 14 18 6 1 14 16 20 11 10 3 4 20 6 30 + 10 20 + 14 20 + 12 17 - 14 20 - 12 17 + 4 6 + 8 20 + 3 6 - 10 20 + 2 17 + 1 16 + 6 10 + 9 10 + 5 15 + 7 8 - 7 8 + 2 5 + 3 18 + 1 20 + 8 16 - 3 18 - 5 15 + 4 20 + 14 16 - 4 6 + 8 19 + 4 7 - 1 16 ...
output:
500000004 1 250000003 1 500000004 750000006 875000007 437500004 875000007 437500004 437500005 718750007 437500008 437500024 437500028 437500024 437500040 718750074 718750078 718750112 437500062 437500046 718750080 718750088 437500050 437500051 437500339 437500207 437500343 875000180
result:
wrong answer 1st lines differ - expected: '1', found: '500000004'