Submission #2197132

---

Source Code Expand

/**
 *  _           _                 __                            _   _ _   _                                 _                    _                  _
 * | |         | |               / /                           | | (_) | (_)                               | |                  (_)                | |
 * | |__   __ _| |_ ___   ___   / /__ ___  _ __ ___  _ __   ___| |_ _| |_ ___   _____ ______ _ __ _   _ ___| |_ ______ ___ _ __  _ _ __  _ __   ___| |_ ___
 * | '_ \ / _` | __/ _ \ / _ \ / / __/ _ \| '_ ` _ \| '_ \ / _ \ __| | __| \ \ / / _ \______| '__| | | / __| __|______/ __| '_ \| | '_ \| '_ \ / _ \ __/ __|
 * | | | | (_| | || (_) | (_) / / (_| (_) | | | | | | |_) |  __/ |_| | |_| |\ V /  __/      | |  | |_| \__ \ |_       \__ \ | | | | |_) | |_) |  __/ |_\__ \
 * |_| |_|\__,_|\__\___/ \___/_/ \___\___/|_| |_| |_| .__/ \___|\__|_|\__|_| \_/ \___|      |_|   \__,_|___/\__|      |___/_| |_|_| .__/| .__/ \___|\__|___/
 *                                                  | |                                                                           | |   | |
 *                                                  |_|                                                                           |_|   |_|
 *
 * https://github.com/hatoo/competitive-rust-snippets
 */
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::iter::FromIterator;
#[allow(unused_imports)]
use std::io::{stdin, stdout, BufWriter, Write};
mod util {
    use std::io::{stdin, stdout, BufWriter, StdoutLock};
    use std::str::FromStr;
    use std::fmt::Debug;
    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }
    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }
    #[allow(dead_code)]
    pub fn with_bufwriter<F: FnOnce(BufWriter<StdoutLock>) -> ()>(f: F) {
        let out = stdout();
        let writer = BufWriter::new(out.lock());
        f(writer)
    }
}
#[allow(unused_macros)]
macro_rules ! get { ( $ t : ty ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; line . trim ( ) . parse ::<$ t > ( ) . unwrap ( ) } } ; ( $ ( $ t : ty ) ,* ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; let mut iter = line . split_whitespace ( ) ; ( $ ( iter . next ( ) . unwrap ( ) . parse ::<$ t > ( ) . unwrap ( ) , ) * ) } } ; ( $ t : ty ; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ ( $ t : ty ) ,*; $ n : expr ) => { ( 0 ..$ n ) . map ( | _ | get ! ( $ ( $ t ) ,* ) ) . collect ::< Vec < _ >> ( ) } ; ( $ t : ty ;; ) => { { let mut line : String = String :: new ( ) ; stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; line . split_whitespace ( ) . map ( | t | t . parse ::<$ t > ( ) . unwrap ( ) ) . collect ::< Vec < _ >> ( ) } } ; }
#[allow(unused_macros)]
macro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { println ! ( concat ! ( $ ( stringify ! ( $ a ) , " = {:?}, " ) ,* ) , $ ( $ a ) ,* ) ; } }

#[allow(dead_code)]
/// Segment Tree
pub struct SEG {
    n: usize,
    buf: Vec<usize>,
}
impl SEG {
    #[allow(dead_code)]
    pub fn new(init: &[usize]) -> SEG {
        let n = init.len();
        // let mut buf = vec![1_000_000; 2 * n];
        let mut buf = Vec::with_capacity(2 * n);
        unsafe {
            buf.set_len(2 * n);
        }

        buf[n..].copy_from_slice(init);

        for i in (0..n).rev() {
            buf[i] = min(buf[i << 1], buf[(i << 1) | 1]);
        }

        SEG { n: n, buf: buf }
    }
    #[allow(dead_code)]
    pub fn update(&mut self, k: usize, a: usize) {
        let mut k = k + self.n;
        self.buf[k] = a;
        while k > 0 {
            k >>= 1;
            self.buf[k] = min(self.buf[k << 1], self.buf[(k << 1) | 1]);
        }
    }
    #[allow(dead_code)]
    pub fn add(&mut self, k: usize, a: usize) {
        let mut k = k + self.n;
        self.buf[k] = min(self.buf[k], a);
        while k > 0 {
            k >>= 1;
            self.buf[k] = min(self.buf[k << 1], self.buf[(k << 1) | 1]);
        }
    }
    #[allow(dead_code)]
    fn query(&self, l: usize, r: usize) -> usize {
        // let mut vl = 1_000_000;
        // let mut vr = 1_000_000;
        let mut res = 1_000_000;
        let mut l = l + self.n;
        let mut r = r + self.n;
        while l < r {
            if l & 1 == 1 {
                res = min(res, self.buf[l]);
                l += 1;
            }
            if r & 1 == 1 {
                r -= 1;
                res = min(res, self.buf[r]);
            }
            l >>= 1;
            r >>= 1;
        }
        res
    }
}

fn dfs(i: usize, p: usize, d: usize, g: &[Vec<usize>], ids: &mut [usize], depth: &mut Vec<usize>) {
    ids[i] = depth.len();
    depth.push(d);

    for &to in &g[i] {
        if to != p {
            dfs(to, i, d + 1, g, ids, depth);
            depth.push(d);
        }
    }
}

#[allow(dead_code)]
fn main() {
    let mut line = String::new();
    let n = {
        stdin().read_line(&mut line).unwrap();
        line.trim_right().parse::<usize>().unwrap()
    };
    // let xy = get!(usize, usize; n - 1);
    let xy: Vec<(usize, usize)> = (0..n - 1)
        .map(|_| {
            line.clear();
            stdin().read_line(&mut line).unwrap();
            let mut split = line.split_whitespace();
            (
                split.next().unwrap().parse().unwrap(),
                split.next().unwrap().parse().unwrap(),
            )
        })
        .collect();
    // let q = get!(usize);
    let q: usize = {
        line.clear();
        stdin().read_line(&mut line).unwrap();
        line.trim_right().parse::<usize>().unwrap()
    };

    // let ab = get!(usize, usize; q);
    /*
    let ab: Vec<(usize, usize)> = (0..q)
        .map(|_| {
            line.clear();
            stdin().read_line(&mut line).unwrap();
            let mut split = line.split_whitespace();
            (
                split.next().unwrap().parse().unwrap(),
                split.next().unwrap().parse().unwrap(),
            )
        })
        .collect();
        */

    let mut g = vec![Vec::new(); n];
    let mut ids = vec![0; n];
    let mut depth = Vec::new();

    for &(x, y) in &xy {
        g[x - 1].push(y - 1);
        g[y - 1].push(x - 1);
    }

    dfs(0, 0, 0, &g, &mut ids, &mut depth);

    // let mut seg = SEG::new(depth.len(), &0, |&a, &b| min(a, b));
    let mut seg = SEG::new(&depth);

    for (i, &d) in depth.iter().enumerate() {
        seg.update(i, d);
    }

    // util::with_bufwriter(|mut out| {
    for _ in 0..q {
        let (a, b): (usize, usize) = {
            line.clear();
            stdin().read_line(&mut line).unwrap();
            let mut split = line.split_whitespace();
            (
                split.next().unwrap().parse().unwrap(),
                split.next().unwrap().parse().unwrap(),
            )
        };
        let aa = ids[a - 1];
        let bb = ids[b - 1];

        let l = min(aa, bb);
        let r = max(aa, bb);

        let lca = seg.query(l, r + 1);

        println!("{}", depth[aa] + depth[bb] + 1 - 2 * lca);
    }
    // });
}

Submission Info

Judge Result