#953084 (Rust) No.2644 Iro Iro-Iro

提出ソース

結果

問題	No.2644 Iro Iro-Iro
ユーザー	Moss_Local
提出日時	2024-02-19 23:18:42
言語	Rust (1.77.0)
結果	RE
実行時間	-
コード長	13,434 bytes
コンパイル時間	1,388 ms
コンパイル使用メモリ	209,292 KB
実行使用メモリ	32,588 KB
最終ジャッジ日時	2024-02-19 23:18:50
合計ジャッジ時間	7,577 ms
ジャッジサーバーID （参考情報）	judge11 / judge13

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	0 ms 6,676 KB
testcase_01	AC	0 ms 6,676 KB
testcase_02	AC	0 ms 6,676 KB
testcase_03	AC	374 ms 11,264 KB
testcase_04	RE	-
testcase_05	AC	430 ms 11,392 KB
testcase_06	AC	15 ms 10,496 KB
testcase_07	RE	-
testcase_08	AC	159 ms 11,008 KB
testcase_09	AC	123 ms 6,676 KB
testcase_10	AC	150 ms 6,676 KB
testcase_11	AC	16 ms 10,624 KB
testcase_12	AC	43 ms 6,676 KB
testcase_13	RE	-
testcase_14	RE	-
testcase_15	RE	-
testcase_16	RE	-
testcase_17	RE	-
testcase_18	AC	573 ms 32,572 KB
testcase_19	AC	870 ms 32,588 KB
testcase_20	AC	757 ms 32,580 KB
testcase_21	AC	414 ms 32,560 KB
testcase_22	AC	360 ms 32,112 KB
testcase_23	RE	-
testcase_24	RE	-
testcase_25	RE	-
testcase_26	RE	-
testcase_27	RE	-
testcase_28	AC	1 ms 6,676 KB
testcase_29	RE	-
testcase_30	RE	-
testcase_31	RE	-
testcase_32	RE	-

権限があれば一括ダウンロードができます

コンパイルメッセージ

warning: unnecessary parentheses around match arm expression
   --> Main.rs:415:46
    |
415 |             std::ops::Bound::Included(&x) => (x + 1),
    |                                              ^     ^
    |
    = note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
    |
415 -             std::ops::Bound::Included(&x) => (x + 1),
415 +             std::ops::Bound::Included(&x) => x + 1,
    |

warning: variable does not need to be mutable
   --> Main.rs:122:9
    |
122 |     let mut vec: Vec<i64> = read_vec();
    |         ----^^^
    |         |
    |         help: remove this `mut`
    |
    = note: `#[warn(unused_mut)]` on by default

warning: variable does not need to be mutable
   --> Main.rs:128:9
    |
128 |     let mut vec: Vec<i64> = read_vec();
    |         ----^^^
    |         |
    |         help: remove this `mut`

warning: variable does not need to be mutable
   --> Main.rs:133:9
    |
133 |     let mut vec: Vec<usize> = read_vec();
    |         ----^^^
    |         |
    |         help: remove this `mut`

warning: variable does not need to be mutable
   --> Main.rs:139:9
    |
139 |     let mut vec: Vec<f64> = read_vec();
    |         ----^^^
    |         |
    |         help: remove this `mut`

warning: variable does not need to be mutable
   --> Main.rs:144:9
    |
144 |     let mut vec: Vec<char> = read_vec();
    |         ----^^^
    |         |
    |         help: remove this `mut`

warning: variable does not need to be mutable
   --> Main.rs:149:9
    |
149 |     let mut vec: Vec<usize> = read_vec();
    |         ----^^^
    |         |
    |         help: remove this `mut`

warning: variable does not need to be mutable
   --> Main.rs:154:9
    |
154 |     let mut vec: Vec<i64> = read_vec();
    |         ----^^^
    |         |
    |         help: remove this `mut`

warning: variable does not need to be mutable
   --> Main.rs:160:9
    |
160 |     let mut vec: Vec<usize> = read_vec();
    |         ----^^^

ソースコード

raw source code

// -*- coding:utf-8-unix -*-
// #![feature(map_first_last)]
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_macros)]
// use core::num;
use std::cmp::*;
use std::fmt::*;
use std::hash::*;
use std::iter::FromIterator;
use std::*;
use std::{cmp, collections, fmt, io, iter, ops, str};
const INF: i64 = 1223372036854775807;
const UINF: usize = INF as usize;
const LINF: i64 = 2147483647;
const INF128: i128 = 1223372036854775807000000000000;
const MOD1: i64 = 1000000007;
const MOD9: i64 = 998244353;
const MOD: i64 = MOD9;
// const MOD: i64 = MOD2;
const UMOD: usize = MOD as usize;
const M_PI: f64 = 3.14159265358979323846;

// use proconio::input;
// const MOD: i64 = INF;

use cmp::Ordering::*;
use std::collections::*;

use std::io::stdin;
use std::io::stdout;
use std::io::Write;

macro_rules! p {
    ($x:expr) => {
        //if expr
        println!("{}", $x);
    };
}

macro_rules! vp {
    // vector print separate with space
    ($x:expr) => {
        println!(
            "{}",
            $x.iter()
                .map(|x| x.to_string())
                .collect::<Vec<_>>()
                .join(" ")
        );
    };
}

macro_rules! d {
    ($x:expr) => {
        eprintln!("{:?}", $x);
    };
}
macro_rules! yn {
    ($val:expr) => {
        if $val {
            println!("Yes");
        } else {
            println!("No");
        }
    };
}

macro_rules! map{
    // declear btreemap
    ($($key:expr => $val:expr),*) => {
        {
            let mut map = ::std::collections::BTreeMap::new();
            $(
                map.insert($key, $val);
            )*
            map
        }
    };
}

macro_rules! set{
    // declear btreemap
    ($($key:expr),*) => {
        {
            let mut set = ::std::collections::BTreeSet::new();
            $(
                set.insert($key);
            )*
            set
        }
    };
}

fn main() {
    solve();
}

// use str::Chars;
#[allow(dead_code)]
fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

#[allow(dead_code)]
fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

#[allow(dead_code)]
fn read_mat<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

#[allow(dead_code)]
fn readii() -> (i64, i64) {
    let mut vec: Vec<i64> = read_vec();
    (vec[0], vec[1])
}

#[allow(dead_code)]
fn readiii() -> (i64, i64, i64) {
    let mut vec: Vec<i64> = read_vec();
    (vec[0], vec[1], vec[2])
}
#[allow(dead_code)]
fn readuu() -> (usize, usize) {
    let mut vec: Vec<usize> = read_vec();
    (vec[0], vec[1])
}

#[allow(dead_code)]
fn readff() -> (f64, f64) {
    let mut vec: Vec<f64> = read_vec();
    (vec[0], vec[1])
}

fn readcc() -> (char, char) {
    let mut vec: Vec<char> = read_vec();
    (vec[0], vec[1])
}

fn readuuu() -> (usize, usize, usize) {
    let mut vec: Vec<usize> = read_vec();
    (vec[0], vec[1], vec[2])
}
#[allow(dead_code)]
fn readiiii() -> (i64, i64, i64, i64) {
    let mut vec: Vec<i64> = read_vec();
    (vec[0], vec[1], vec[2], vec[3])
}

#[allow(dead_code)]
fn readuuuu() -> (usize, usize, usize, usize) {
    let mut vec: Vec<usize> = read_vec();
    (vec[0], vec[1], vec[2], vec[3])
}

fn read_imat(h: usize) -> Vec<Vec<i64>> {
    (0..h).map(|_| read_vec()).collect()
}
fn read_cmat(h: usize) -> Vec<Vec<char>> {
    (0..h).map(|_| read::<String>().chars().collect()).collect()
}

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>>>()
    }
}

//https://atcoder.jp/contests/abc294/submissions/39892374
// https://ei1333.github.io/luzhiled/snippets/tree/heavy-light-decomposition.html
// Verified by: NUPC2017 H
// https://atcoder.jp/contests/njpc2017/submissions/23535017
struct HLDecomp {
    euler: Vec<usize>,
    head: Vec<usize>,
    rev: Vec<usize>,
    par: Vec<usize>,
}

impl HLDecomp {
    fn dfs_sz(v: usize, p: usize, g: &mut [Vec<usize>], sz: &mut [usize], par: &mut [usize]) {
        par[v] = p;
        sz[v] = 1;
        if g[v].get(0) == Some(&p) {
            let last = g[v].len() - 1;
            g[v].swap(0, last);
        }
        for i in 0..g[v].len() {
            let to = g[v][i];
            if to == p {
                continue;
            }
            Self::dfs_sz(to, v, g, sz, par);
            sz[v] += sz[to];
            if sz[g[v][0]] < sz[to] {
                g[v].swap(0, i);
            }
        }
    }
    fn dfs_euler(
        v: usize,
        par: usize,
        g: &[Vec<usize>],
        euler: &mut [usize],
        count: &mut usize,
        head: &mut [usize],
        rev: &mut [usize],
    ) {
        euler[v] = *count;
        *count += 1;
        rev[euler[v]] = v;
        for &to in &g[v] {
            if to == par {
                continue;
            }
            head[to] = if g[v][0] == to { head[v] } else { to };
            Self::dfs_euler(to, v, g, euler, count, head, rev);
        }
    }
    pub fn new(g: &[Vec<usize>]) -> Self {
        let mut g = g.to_vec();
        let n = g.len();
        let mut sz = vec![0; n];
        let mut par = vec![0; n];
        Self::dfs_sz(0, n, &mut g, &mut sz, &mut par);
        let mut euler = vec![0; n];
        let mut count = 0;
        let mut head = vec![0; n];
        let mut rev = vec![0; n];
        Self::dfs_euler(0, n, &g, &mut euler, &mut count, &mut head, &mut rev);
        HLDecomp {
            euler: euler,
            head: head,
            rev: rev,
            par: par,
        }
    }
    #[allow(unused)]
    pub fn get_id(&self, v: usize) -> usize {
        self.euler[v]
    }
    #[allow(unused)]
    pub fn from_id(&self, id: usize) -> usize {
        self.rev[id]
    }
    // M: commutative
    // M must not panic.
    #[allow(unused)]
    pub fn query<T, F: FnMut(usize, usize) -> T, M: Fn(T, T) -> T>(
        &self,
        mut u: usize,
        mut v: usize,
        mut f: F,
        mut m: M,
        e: T,
        edge: bool,
    ) -> T {
        let mut ans = e;
        self.divide(
            u,
            v,
            |l, r| {
                let ptr: *mut T = &mut ans;
                unsafe {
                    let val = f(l, r);
                    let ans = std::ptr::read(ptr);
                    std::ptr::write(ptr, m(ans, val))
                }
            },
            edge,
        );
        ans
    }
    pub fn divide<F: FnMut(usize, usize)>(&self, mut u: usize, mut v: usize, mut f: F, edge: bool) {
        let euler = &self.euler;
        let head = &self.head;
        loop {
            if euler[u] > euler[v] {
                std::mem::swap(&mut u, &mut v);
            }
            if head[u] == head[v] {
                break;
            }
            f(euler[head[v]], euler[v] + 1);
            v = self.par[head[v]];
        }
        f(euler[u] + if edge { 1 } else { 0 }, euler[v] + 1);
    }
}

pub struct SEG<M: Monoid> {
    n: usize,
    buf: Vec<M::T>,
}

impl<M: Monoid> SEG<M> {
    #[allow(dead_code)]
    pub fn new(n: usize) -> SEG<M> {
        SEG {
            n,
            buf: vec![M::id(); 2 * n],
        }
    }

    #[allow(dead_code)]
    pub fn update(&mut self, k: usize, a: M::T) {
        let mut k = k + self.n;
        self.buf[k] = a;

        while k > 0 {
            k >>= 1;
            self.buf[k] = M::op(&self.buf[k << 1], &self.buf[(k << 1) | 1]);
        }
    }

    #[allow(dead_code)]
    pub fn add(&mut self, k: usize, a: &M::T) {
        let mut k = k + self.n;
        self.buf[k] = M::op(&self.buf[k], a);

        while k > 0 {
            k >>= 1;
            self.buf[k] = M::op(&self.buf[k << 1], &self.buf[(k << 1) | 1]);
        }
    }

    #[allow(dead_code)]
    pub fn get(&self, i: usize) -> M::T {
        self.query(i, i + 1)
    }

    #[allow(dead_code)]
    pub fn query_range<R: std::ops::RangeBounds<usize>>(&self, range: R) -> M::T {
        let l = match range.start_bound() {
            std::ops::Bound::Excluded(&x) => {
                assert!(x > 0);
                x - 1
            }
            std::ops::Bound::Included(&x) => x,
            std::ops::Bound::Unbounded => 0,
        };
        let r = match range.end_bound() {
            std::ops::Bound::Excluded(&x) => x,
            std::ops::Bound::Included(&x) => (x + 1),
            std::ops::Bound::Unbounded => self.n,
        };

        self.query(l, r)
    }

    #[allow(dead_code)]
    pub fn query(&self, l: usize, r: usize) -> M::T {
        let mut vl = M::id();
        let mut vr = M::id();

        let mut l = l + self.n;
        let mut r = r + self.n;

        while l < r {
            if l & 1 == 1 {
                vl = M::op(&vl, &self.buf[l]);
                l += 1;
            }
            if r & 1 == 1 {
                r -= 1;
                vr = M::op(&self.buf[r], &vr);
            }

            l >>= 1;
            r >>= 1;
        }
        M::op(&vl, &vr)
    }
}
pub trait Monoid {
    type T: Clone;
    fn id() -> Self::T;
    fn op(a: &Self::T, b: &Self::T) -> Self::T;
}

pub enum MON {}
impl Monoid for MON {
    type T = usize;
    fn id() -> Self::T {
        0
    }
    fn op(a: &Self::T, b: &Self::T) -> Self::T {
        max(*a, *b)
    }
}
fn solve() {
    let (n, m) = readuu();
    let mut ma_a = 0;
    let mut ma_b = 0;
    let mut ma_c = 0;
    let mut mi_a = UINF;
    let mut mi_b = UINF;
    let mut mi_c = UINF;
    let mut indata = vec![];
    for i in 0..n {
        let (a, b, c) = readuuu();
        ma_a = max(ma_a, a);
        ma_b = max(ma_b, b);
        ma_c = max(ma_c, c);
        mi_a = min(mi_a, a);
        mi_b = min(mi_b, b);
        mi_c = min(mi_c, c);
        indata.push((a, b, c));
    }
    let mut block_size = (ma_a - mi_a) * (ma_b - mi_b) * (ma_c - mi_c);
    let mut dir_cand = vec![];
    for i in 0..m {
        let (x, y, z) = readiii();
        dir_cand.push((x, y, z));
    }
    if n <= 5000 {
        let mut res = 0;
        let mut cancel_dir = HashMap::new();
        for i in 0..n {
            for j in 0..n {
                let dx = indata[i].0 as i64 - indata[j].0 as i64;
                let dy = indata[i].1 as i64 - indata[j].1 as i64;
                let dz = indata[i].2 as i64 - indata[j].2 as i64;
                *cancel_dir.entry((dx, dy, dz)).or_insert(0) += 1;
            }
        }
        for (x, y, z) in dir_cand {
            let cancel_num = cancel_dir.get(&(x, y, z)).unwrap_or(&0);
            res = max(res, 2 * n - cancel_num);
        }
        p!(res);
    } else if m <= 5000 {
        let mut exist = vec![vec![vec![0; 101]; 101]; 101];
        for (a, b, c) in indata.clone() {
            exist[a][b][c] = 1;
        }
        let mut res = 0;
        for (x, y, z) in dir_cand {
            let mut cnt = 0;
            for i in 0..n {
                let (a, b, c) = indata[i];
                if (a as i64 + x) >= 0
                    && (a as i64 + x) <= 100
                    && (b as i64 + y) >= 0
                    && (b as i64 + y) <= 100
                    && (c as i64 + z) >= 0
                    && (c as i64 + z) <= 100
                {
                    cnt += exist[(a as i64 + x) as usize][(b as i64 + y) as usize]
                        [(c as i64 + z) as usize];
                }
            }
            res = max(res, 2 * n - cnt);
        }
        p!(res);
    } else {
        assert!(false);
    }
    return;
}

yukicoder

結果

テストケース

コンパイルメッセージ

ソースコード