結果
問題 | No.2225 Treasure Searching Rod (Easy) |
ユーザー |
|
提出日時 | 2023-02-24 21:35:58 |
言語 | Rust (1.83.0 + proconio) |
結果 |
AC
|
実行時間 | 14 ms / 2,000 ms |
コード長 | 10,844 bytes |
コンパイル時間 | 14,058 ms |
コンパイル使用メモリ | 387,872 KB |
実行使用メモリ | 6,944 KB |
最終ジャッジ日時 | 2024-09-13 05:10:42 |
合計ジャッジ時間 | 13,369 ms |
ジャッジサーバーID (参考情報) |
judge1 / judge5 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 3 |
other | AC * 23 |
コンパイルメッセージ
warning: unnecessary trailing semicolon --> src/main.rs:357:28 | 357 | trs[y][x] = v % md;; | ^ help: remove this semicolon | = note: `#[warn(redundant_semicolons)]` on by default
ソースコード
#![allow(unused_macros, unused_imports, dead_code)]use std::any::TypeId;use std::cmp::{max, min, Reverse};use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};use std::mem::swap;use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, Sub, SubAssign};mod my_string {use std::ops::{Index, IndexMut};use std::slice::SliceIndex;#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]pub struct Str {vc: Vec<char>,}impl Str {pub fn new() -> Self {Self { vc: vec![] }}pub fn from(s: &str) -> Self {Self {vc: s.to_string().chars().collect::<Vec<char>>(),}}pub fn len(&self) -> usize {self.vc.len()}pub fn clear(&mut self) {self.vc.clear()}pub fn is_empty(&self) -> bool {self.vc.is_empty()}pub fn first(&self) -> Option<&char> {self.vc.first()}pub fn last(&self) -> Option<&char> {self.vc.last()}pub fn push(&mut self, c: char) {self.vc.push(c);}pub fn push_str(&mut self, s: &str) {for c in s.to_string().chars().collect::<Vec<char>>().into_iter() {self.push(c);}}pub fn pop(&mut self) -> Option<char> {self.vc.pop()}pub fn into_iter(self) -> std::vec::IntoIter<char> {self.vc.into_iter()}pub fn iter(&self) -> std::slice::Iter<char> {self.vc.iter()}pub fn iter_mut(&mut self) -> std::slice::IterMut<char> {self.vc.iter_mut()}pub fn swap(&mut self, a: usize, b: usize) {self.vc.swap(a, b);}pub fn reverse(&mut self) {self.vc.reverse();}pub fn find(&self, p: &Str) -> Option<usize> {let s: String = self.vc.iter().collect::<String>();let p: String = p.vc.iter().collect::<String>();s.find(&p)}pub fn rfind(&self, p: &Str) -> Option<usize> {let s: String = self.vc.iter().collect::<String>();let p: String = p.vc.iter().collect::<String>();s.rfind(&p)}pub fn into_values(self, base: char) -> Vec<usize> {self.vc.into_iter().map(|c| (c as u8 - base as u8) as usize).collect::<Vec<usize>>()}pub fn sort(&mut self) {self.vc.sort();}pub fn remove(&mut self, index: usize) -> char {self.vc.remove(index)}}impl std::str::FromStr for Str {type Err = ();fn from_str(s: &str) -> Result<Self, Self::Err> {Ok(Str {vc: s.to_string().chars().collect::<Vec<char>>(),})}}impl<Idx: SliceIndex<[char]>> Index<Idx> for Str {type Output = Idx::Output;fn index(&self, i: Idx) -> &Self::Output {&self.vc[i]}}impl<Idx: SliceIndex<[char]>> IndexMut<Idx> for Str {fn index_mut(&mut self, index: Idx) -> &mut Self::Output {&mut self.vc[index]}}impl std::ops::Add<Str> for Str {type Output = Str;fn add(self, rhs: Self) -> Self::Output {let mut ret = self;for c in rhs.into_iter() {ret.vc.push(c);}ret}}impl std::ops::AddAssign<Str> for Str {fn add_assign(&mut self, rhs: Self) {for c in rhs.into_iter() {self.vc.push(c);}}}impl std::ops::Add<char> for Str {type Output = Str;fn add(self, rhs: char) -> Self::Output {let mut ret = self;ret.vc.push(rhs);ret}}impl std::ops::AddAssign<char> for Str {fn add_assign(&mut self, rhs: char) {self.vc.push(rhs);}}impl std::fmt::Display for Str {fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {write!(f, "{}", self.vc.iter().collect::<String>())}}impl std::fmt::Debug for Str {fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {write!(f, "{}", self.vc.iter().collect::<String>())}}}use my_string::Str;mod procon_reader {use std::fmt::Debug;use std::io::Read;use std::str::FromStr;pub fn read<T: FromStr>() -> Twhere<T as FromStr>::Err: Debug,{let stdin = std::io::stdin();let mut stdin_lock = stdin.lock();let mut u8b: [u8; 1] = [0];loop {let mut buf: Vec<u8> = Vec::with_capacity(16);loop {let res = stdin_lock.read(&mut u8b);if res.unwrap_or(0) == 0 || u8b[0] <= b' ' {break;} else {buf.push(u8b[0]);}}if !buf.is_empty() {let ret = String::from_utf8(buf).unwrap();return ret.parse().unwrap();}}}pub fn read_vec<T: std::str::FromStr>(n: usize) -> Vec<T>where<T as FromStr>::Err: Debug,{(0..n).into_iter().map(|_| read::<T>()).collect::<Vec<T>>()}pub fn read_vec_sub1(n: usize) -> Vec<usize> {(0..n).into_iter().map(|_| read::<usize>() - 1).collect::<Vec<usize>>()}pub fn read_mat<T: std::str::FromStr>(h: usize, w: usize) -> Vec<Vec<T>>where<T as FromStr>::Err: Debug,{(0..h).into_iter().map(|_| read_vec::<T>(w)).collect::<Vec<Vec<T>>>()}}use procon_reader::*;fn exit_by<T: std::fmt::Display>(msg: T) {println!("{}", msg);std::process::exit(0);}mod gcd {use std::cmp::{PartialEq, PartialOrd};use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign};pub fn gcd<T: Copy + Sub<Output = T> + Rem<Output = T> + PartialEq>(a: T, b: T) -> T {#[allow(clippy::eq_op)]let zero = a - a;if b == zero {a} else {gcd(b, a % b)}}// returns (p, q) s. t. ap + bq = gcd(a, b)pub fn ext_gcd<T: Eq+ Copy+ Sub<Output = T>+ SubAssign+ Mul<Output = T>+ Div<Output = T>+ Rem<Output = T>,>(a: T,b: T,) -> (T, T) {#[allow(clippy::eq_op)]let zero = b - b;#[allow(clippy::eq_op)]let one = b / b;if a == zero {return (zero, one);}// (b % a) * x + a * y = gcd(a, b)// b % a = b - (b / a) * a// ->// (b - (b / a) * a) * x + a * y = gcd(a, b)// a * (y - (b / a) * x) + b * x = gcd(a, b)let (x, y) = ext_gcd(b % a, a);(y - b / a * x, x)}// Chinese Remainder Theorem// when exists, returns (lcm(m1, m2), x) s.t. x = r1 (mod m1) and x = r2 (mod m2)fn chinese_rem_elem2<T: Eq+ Copy+ Neg<Output = T>+ PartialOrd+ Add<Output = T>+ AddAssign+ Sub<Output = T>+ SubAssign+ Mul<Output = T>+ Div<Output = T>+ Rem<Output = T>+ RemAssign,>(m1: T,r1: T,m2: T,r2: T,) -> Option<(T, T)> {#[allow(clippy::eq_op)]let zero = m1 - m1;#[allow(clippy::eq_op)]let one = m1 / m1;let (p, _q) = ext_gcd(m1, m2);let g = gcd(m1, m2);if (r2 - r1) % g != zero {None} else {let lcm = m1 * (m2 / g);let mut r = r1 + m1 * ((r2 - r1) / g) * p;if r < zero {let dv = (-r + lcm - one) / lcm;r += dv * lcm;}r %= lcm;Some((lcm, r))}}// Chinese Remainder Theorem// when exists, returns (lcm(mods), x) s.t. x = r_i (mod m_i) for all i.pub fn chinese_rem<T: Eq+ Copy+ Neg<Output = T>+ PartialOrd+ Add<Output = T>+ AddAssign+ Sub<Output = T>+ SubAssign+ Mul<Output = T>+ Div<Output = T>+ Rem<Output = T>+ RemAssign,>(mods: &[T],rems: &[T],) -> Option<(T, T)> {debug_assert!(mods.len() == rems.len());#[allow(clippy::eq_op)]let zero = mods[0] - mods[0];#[allow(clippy::eq_op)]let one = mods[0] / mods[0];let mut lcm = one;let mut rem = zero;for (m, r) in mods.iter().copied().zip(rems.iter().copied()) {if let Some((nlcm, nrem)) = chinese_rem_elem2(lcm, rem, m, r) {lcm = nlcm;rem = nrem;} else {return None;}}Some((lcm, rem))}}use gcd::*;mod power_with_identity {use std::ops::Mul;pub fn power_with_identity<T: Copy + Mul<Output = T>>(identity: T, base: T, mut p: usize) -> T {#[allow(clippy::eq_op)]let mut ret = identity;let mut mul = base;while p > 0 {if p & 1 != 0 {ret = ret * mul;}p >>= 1;mul = mul * mul;}ret}}use power_with_identity::power_with_identity;/**************************************************************************************************************************************************************************/fn main() {let md = 998244353;let h = read::<usize>();let w = read::<usize>();let k = read::<usize>();let mut trs = vec![vec![0; w]; h];for _ in 0..k {let y = read::<usize>() - 1;let x = read::<usize>() - 1;let v = read::<i64>();trs[y][x] = v % md;;}let trs = trs;let mut ans = 0;for y in 0..h {for x in 0..w {for i in 0..h {for j in 0..w {if y + x >= i + j {if y as i64 - x as i64 >= i as i64 - j as i64 {ans += trs[y][x];ans %= md;}}}}}}println!("{}", ans);}