結果

問題 No.1687 What the Heck?
ユーザー emakemak
提出日時 2021-09-24 22:13:53
言語 Rust
(1.77.0 + proconio)
結果
AC  
実行時間 37 ms / 2,000 ms
コード長 2,650 bytes
コンパイル時間 17,731 ms
コンパイル使用メモリ 401,852 KB
実行使用メモリ 6,948 KB
最終ジャッジ日時 2024-07-05 10:45:04
合計ジャッジ時間 12,129 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
6,816 KB
testcase_01 AC 1 ms
6,940 KB
testcase_02 AC 1 ms
6,948 KB
testcase_03 AC 1 ms
6,940 KB
testcase_04 AC 0 ms
6,944 KB
testcase_05 AC 1 ms
6,940 KB
testcase_06 AC 1 ms
6,944 KB
testcase_07 AC 10 ms
6,940 KB
testcase_08 AC 15 ms
6,940 KB
testcase_09 AC 10 ms
6,940 KB
testcase_10 AC 7 ms
6,940 KB
testcase_11 AC 7 ms
6,940 KB
testcase_12 AC 36 ms
6,940 KB
testcase_13 AC 37 ms
6,940 KB
testcase_14 AC 36 ms
6,940 KB
testcase_15 AC 36 ms
6,944 KB
testcase_16 AC 36 ms
6,944 KB
testcase_17 AC 3 ms
6,944 KB
testcase_18 AC 36 ms
6,944 KB
testcase_19 AC 1 ms
6,940 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
warning: unused variable: `i`
  --> src/main.rs:30:10
   |
30 |     for (i, k) in idx.into_iter().enumerate() {
   |          ^ help: if this is intentional, prefix it with an underscore: `_i`
   |
   = note: `#[warn(unused_variables)]` on by default

ソースコード

diff # 

#![allow(unused_macros, unused_imports)]

use std::collections::BTreeSet;
macro_rules! dbg {
    ($($xs:expr),+) => {
        if cfg!(debug_assertions) {
            std::dbg!($($xs),+)
        } else {
            ($($xs),+)
        }
    }
}

fn main() {
    input!{
        n: usize,
        p: [Usize1; n],
    }
    if n == 1 {
        println!("0");
        return;
    }

    let mut ans = 0;

    let mut idx = (0..n).collect::<Vec<_>>();
    idx.sort_by_key(|i| p[*i]);

    let mut t = 0;
    for (i, k) in idx.into_iter().enumerate() {
        t += k + 1;
        let u = 2 * (k+1);
        ans = ans.max(t as i64 - u as i64);
    }

    println!("{}", ans);
}

pub mod proconio {
    #[macro_export]
    macro_rules! input{
        (sc=$sc:expr,$($r:tt)*)=>{
            input_inner!{$sc,$($r)*}
        };
        ($($r:tt)*)=>{
            let mut sc=proconio::Scanner::new(std::io::stdin().lock());
            input_inner!{sc,$($r)*}
        };
    }

    #[macro_export]
    macro_rules! input_inner{
        ($sc:expr)=>{};
        ($sc:expr,)=>{};
        ($sc:expr,$var:ident:$t:tt$($r:tt)*)=>{
            let $var=read_value!($sc,$t);
            input_inner!{$sc $($r)*}
        };
    }

    #[macro_export]
    macro_rules! read_value{
        ($sc:expr,($($t:tt),*))=>{
            ($(read_value!($sc,$t)),*)
        };
        ($sc:expr,[$t:tt;$len:expr])=>{
            (0..$len).map(|_|read_value!($sc,$t)).collect::<Vec<_>>()
        };
        ($sc:expr,Chars)=>{read_value!($sc,String).chars().collect::<Vec<char>>()};
        ($sc:expr,Usize1)=>{read_value!($sc,usize)-1};
        ($sc:expr,$t:ty)=>{$sc.next::<$t>()};
    }
    pub struct Scanner {
        s: Box<str>,
        input: std::iter::Peekable<std::str::SplitAsciiWhitespace<'static>>,
    }
    impl Scanner {
        pub fn new<R: std::io::Read>(mut reader: R) -> Self {
            let s = {
                let mut s = String::new();
                reader.read_to_string(&mut s).unwrap();
                s.into_boxed_str()
            };
            let mut sc = Scanner {
                s,
                input: "".split_ascii_whitespace().peekable(),
            };
            use std::mem;
            let s: &'static str = unsafe { mem::transmute(&*sc.s) };
            sc.input = s.split_ascii_whitespace().peekable();
            sc
        }
        #[inline]
        pub fn next<T: std::str::FromStr>(&mut self) -> T
        where
            T::Err: std::fmt::Debug,
        {
            self.input
                .next()
                .unwrap()
                .parse::<T>()
                .expect("Parse error")
        }
    }
}
0