Submission #41691054

Source Code Expand

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
use dsu::Dsu;
use proconio::{input, marker::Usize1};
fn main() {
    input! {
        n: usize,
        m: usize,
        xyc: [(i64, i64, Usize1); n],
        capital_xyc: [(i64, i64, Usize1); m],
    }
    let mut ans = std::f64::MAX;
    for bits in 0_usize..1 << m {
        let n = n + bits.count_ones() as usize;
        let vertices = xyc
            .iter()
            .copied()
            .chain(
                (0..m)
                    .filter(|i| ((bits >> i) & 1) == 1)
                    .map(|i| capital_xyc[i]),
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

use dsu::Dsu;
use proconio::{input, marker::Usize1};

fn main() {
    input! {
        n: usize,
        m: usize,
        xyc: [(i64, i64, Usize1); n],
        capital_xyc: [(i64, i64, Usize1); m],
    }

    let mut ans = std::f64::MAX;
    for bits in 0_usize..1 << m {
        let n = n + bits.count_ones() as usize;
        let vertices = xyc
            .iter()
            .copied()
            .chain(
                (0..m)
                    .filter(|i| ((bits >> i) & 1) == 1)
                    .map(|i| capital_xyc[i]),
            )
            .collect::<Vec<(i64, i64, usize)>>();

        let mut edges = vec![];
        for (i, (x_i, y_i, c_i)) in vertices.iter().copied().enumerate() {
            for (j, (x_j, y_j, c_j)) in vertices.iter().copied().enumerate() {
                if i == j {
                    continue;
                }
                let cost = (((x_i - x_j).pow(2) + (y_i - y_j).pow(2)) as f64).sqrt();
                edges.push((i, j, cost * if c_i == c_j { 1_f64 } else { 10_f64 }));
            }
        }

        edges.sort_by(|(_, _, a), (_, _, b)| a.partial_cmp(b).unwrap());

        let mut sum = 0_f64;
        let mut dsu = Dsu::new(n);
        for (u, v, c) in edges {
            if dsu.same(u, v) {
                continue;
            }
            dsu.merge(u, v);
            sum += c;
        }

        ans = ans.min(sum);
    }
    println!("{}", ans);
}

//https://github.com/rust-lang-ja/ac-library-rs

pub mod dsu {
    /// Implement (union by size) + (path compression)
    /// Reference:
    /// Zvi Galil and Giuseppe F. Italiano,
    /// Data structures and algorithms for disjoint set union problems
    pub struct Dsu {
        n: usize,
        // root node: -1 * component size
        // otherwise: parent
        parent_or_size: Vec<i32>,
    }

    impl Dsu {
        // 0 <= size <= 10^8 is constrained.
        pub fn new(size: usize) -> Self {
            Self {
                n: size,
                parent_or_size: vec![-1; size],
            }
        }
        pub fn merge(&mut self, a: usize, b: usize) -> usize {
            assert!(a < self.n);
            assert!(b < self.n);
            let (mut x, mut y) = (self.leader(a), self.leader(b));
            if x == y {
                return x;
            }
            if -self.parent_or_size[x] < -self.parent_or_size[y] {
                std::mem::swap(&mut x, &mut y);
            }
            self.parent_or_size[x] += self.parent_or_size[y];
            self.parent_or_size[y] = x as i32;
            x
        }

        pub fn same(&mut self, a: usize, b: usize) -> bool {
            assert!(a < self.n);
            assert!(b < self.n);
            self.leader(a) == self.leader(b)
        }
        pub fn leader(&mut self, a: usize) -> usize {
            assert!(a < self.n);
            if self.parent_or_size[a] < 0 {
                return a;
            }
            self.parent_or_size[a] = self.leader(self.parent_or_size[a] as usize) as i32;
            self.parent_or_size[a] as usize
        }
        pub fn size(&mut self, a: usize) -> usize {
            assert!(a < self.n);
            let x = self.leader(a);
            -self.parent_or_size[x] as usize
        }
        pub fn groups(&mut self) -> Vec<Vec<usize>> {
            let mut leader_buf = vec![0; self.n];
            let mut group_size = vec![0; self.n];
            for i in 0..self.n {
                leader_buf[i] = self.leader(i);
                group_size[leader_buf[i]] += 1;
            }
            let mut result = vec![Vec::new(); self.n];
            for i in 0..self.n {
                result[i].reserve(group_size[i]);
            }
            for i in 0..self.n {
                result[leader_buf[i]].push(i);
            }
            result
                .into_iter()
                .filter(|x| !x.is_empty())
                .collect::<Vec<Vec<usize>>>()
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn dsu_works() {
            let mut d = Dsu::new(4);
            d.merge(0, 1);
            assert_eq!(d.same(0, 1), true);
            d.merge(1, 2);
            assert_eq!(d.same(0, 2), true);
            assert_eq!(d.size(0), 3);
            assert_eq!(d.same(0, 3), false);
            assert_eq!(d.groups(), vec![vec![0, 1, 2], vec![3]]);
        }
    }
}

Submission Info

Judge Result