結果

問題 No.5017 Tool-assisted Shooting
ユーザー tamura-up
提出日時 2023-07-21 09:56:37
言語 Rust
(1.83.0 + proconio)
結果
AC  
実行時間 42 ms / 2,000 ms
コード長 3,730 bytes
コンパイル時間 2,853 ms
コンパイル使用メモリ 162,048 KB
実行使用メモリ 24,348 KB
スコア 74,830
平均クエリ数 89.64
最終ジャッジ日時 2023-07-21 09:56:50
合計ジャッジ時間 11,525 ms
ジャッジサーバーID
（参考情報） 		judge13 / judge15
純コード判定しない問題か言語
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
other AC * 100
権限があれば一括ダウンロードができます
コンパイルメッセージ
warning: variable does not need to be mutable
   --> Main.rs:117:9
    |
117 |     let mut x = 12;
    |         ----^
    |         |
    |         help: remove this `mut`
    |
    = note: `#[warn(unused_mut)]` on by default

warning: 1 warning emitted

ソースコード

diff # 

#![allow(unused_imports)]
#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(non_snake_case)]

use std::collections::VecDeque;
use std::fs::read;
use std::io::Write;
use std::time::Instant;

const Y: usize = 60;
const X: usize = 25;

// src: https://yukicoder.me/submissions/892593
//
// let x = get!(i32); // 1行の i32 の入力を受け取る
// let x = get!(i32;2); // 2行の i32 の入力を受け取る
//
// tuple
// let x = get!(i32,i32,i32); // (i32, i32, i32 )のタプルを受け取る
// let x = get!(i32,i32,i32;2); // 2行 (i32, i32, i32 )のタプルを受け取る
macro_rules! get {
      ($t:ty) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              line.trim().parse::<$t>().unwrap()
          }
      };
      ($($t:ty),*) => {
          {
              let mut line: String = String::new();
              std::io::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();
              std::io::stdin().read_line(&mut line).unwrap();
              line.split_whitespace()
                  .map(|t| t.parse::<$t>().unwrap())
                  .collect::<Vec<_>>()
          }
      };
      ($t:ty ;; $n:expr) => {
          (0..$n).map(|_| get!($t ;;)).collect::<Vec<_>>()
      };
}


fn read_input() -> Option<Vec<(u32, u32, usize)>> {
    let n = get!(i32);
    if n < 0 {
        return None;
    }
    let mut enemies = vec![];
    for _ in 0..n {
        enemies.push(get!(u32,u32,usize));
    }

    Some(enemies)
}

#[derive (Clone, Copy, Debug)]
struct Enemy {
    hp: u32,
    pw: u32,
    y: usize,
}

struct EnemyPool {
    pool: Vec<VecDeque<Enemy>>,
}

impl EnemyPool {
    fn new() -> EnemyPool {
        EnemyPool { pool: vec![VecDeque::new(); X] }
    }

    fn add(&mut self, enemy: &(u32, u32, usize)) {
        self.pool[enemy.2].push_back(Enemy { hp: enemy.0, pw: enemy.1, y: Y - 1 });
    }

    fn step(&mut self) {
        for i in 0..self.pool.len() {
            if let Some(f) = self.pool[i].front() {
                if f.y == 0 { self.pool[i].pop_front(); }
            }
            for j in 0..self.pool[i].len() {
                self.pool[i][j].y -= 1;
            }
        }
    }
    fn get_first(&self, x: usize) -> Option<&Enemy> {
        return self.pool[x].front();
    }
}


fn main() {
    let mut iter = 0;
    let mut pool = EnemyPool::new();
    let mut x = 12;

    while let Some(enemies) = read_input() {
        pool.step();
        for e in enemies {
            pool.add(&e);
        }
        if let Some(e) = pool.get_first(x) {
            if e.y == 0 {
                break;
            }
        }
        // 移動
        println!("S");

        // 攻撃

        iter += 1;
        std::io::stdout().flush().unwrap();
        if iter >= 1000 { break; }
    }
}

pub trait SetMinMax {
    fn setmin(&mut self, v: Self) -> bool;
    fn setmax(&mut self, v: Self) -> bool;
}

impl<T> SetMinMax for T where T: PartialOrd {
    fn setmin(&mut self, v: T) -> bool {
        *self > v && {
            *self = v;
            true
        }
    }
    fn setmax(&mut self, v: T) -> bool {
        *self < v && {
            *self = v;
            true
        }
    }
}
0