結果
| 問題 | No.3677 Global Checksum |
| コンテスト | |
| ユーザー |
 akakimidori
|
| 提出日時 | 2026-09-05 01:57:55 |
| 言語 | Rust (1.97.1 + proconio + num + itertools) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 12,009 bytes |
| 記録 | |
| コンパイル時間 | 4,881 ms |
| コンパイル使用メモリ | 190,464 KB |
| 実行使用メモリ | 52,736 KB |
| 最終ジャッジ日時 | 2026-09-05 01:58:04 |
| 合計ジャッジ時間 | 6,470 ms |
|
ジャッジサーバーID （参考情報） |
judge3_0 / judge1_0 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 12 TLE * 1 -- * 7 |
コンパイルメッセージ
warning: trait `Join` is never used
--> src/main.rs:281:15
|
281 | pub trait Join {
| ^^^^
|
= note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
ソースコード
fn main() {
let mut input = Input::stdin();
let mut output = Output::<_>::stdout();
let h: usize = input.val();
let w: usize = input.val();
let mut a = vec![0u32; h * w];
for a in a.iter_mut() {
*a = input.val();
}
let c = a.chunks_exact(w).map(|a| a.iter().sum::<u32>()).collect::<Vec<_>>();
let t = c.iter().sum::<u32>();
for c in c {
output.val((c + t) as u64);
}
output.flush().unwrap();
}
// https://judge.yosupo.jp/submission/362621
use crate::urectanc::fast_io::{Input, Output};
pub mod urectanc {
pub mod fast_io {
mod input {
use std::{io::Read, os::fd::FromRawFd};
mod mman {
use std::ffi::{c_int, c_void};
pub const PROT_READ: c_int = 1;
pub const MAP_PRIVATE: c_int = 2;
#[link(name = "c")]
unsafe extern "C" {
pub fn mmap(
addr: *mut c_void,
len: usize,
prot: c_int,
flags: c_int,
fd: c_int,
offset: isize,
) -> *mut c_void;
}
}
pub struct Input {
ptr: *const u8,
end: *const u8,
}
impl Input {
pub fn new(ptr: *const u8, len: usize) -> Self {
let end = unsafe { ptr.add(len) };
Self { ptr, end }
}
pub fn stdin() -> Self {
use mman::*;
let mut stdin = unsafe { std::fs::File::from_raw_fd(0) };
let (ptr, len) = if let Ok(metadata) = stdin.metadata() {
let len = metadata.len() as usize;
unsafe {
(
mmap(std::ptr::null_mut(), len, PROT_READ, MAP_PRIVATE, 0, 0) as _,
len,
)
}
} else {
let mut buf = Vec::new();
stdin.read_to_end(&mut buf).unwrap();
let len = buf.len();
(Box::leak(buf.into_boxed_slice()).as_ptr(), len)
};
Self::new(ptr, len)
}
fn peek<T>(&self) -> T {
let ptr = self.ptr as *const T;
unsafe { std::ptr::read_unaligned(ptr) }
}
fn next<T>(&mut self) -> T {
let val = self.peek();
self.ptr = unsafe { self.ptr.add(1) };
val
}
fn skip_whitespace(&mut self) {
while self.peek::<u8>().is_ascii_whitespace() {
self.ptr = unsafe { self.ptr.add(1) };
}
}
fn parse_neg(&mut self) -> bool {
let neg = self.peek::<u8>() == b'-';
self.ptr = unsafe { self.ptr.add(neg as usize) };
neg
}
fn parse_digits(&mut self, mut val: u64) -> u64 {
loop {
let c = self.next::<u8>();
if c.is_ascii_whitespace() {
break;
}
val = val * 10 + (c - b'0') as u64;
}
val
}
fn parse_digits_8byte(&mut self) -> Option<u64> {
if unsafe { self.ptr.add(8) > self.end } {
return None;
}
let mut val = self.peek::<u64>() ^ 0x3030303030303030;
if val & 0xf0f0f0f0f0f0f0f0 != 0 {
return None;
}
self.ptr = unsafe { self.ptr.add(8) };
val = val.wrapping_mul((10 << 8) + 1) >> 8 & 0x00ff00ff00ff00ff;
val = val.wrapping_mul((100 << 16) + 1) >> 16 & 0x0000ffff0000ffff;
val = val.wrapping_mul((10000 << 32) + 1) >> 32;
Some(val)
}
pub fn val<T: Readable>(&mut self) -> T {
self.skip_whitespace();
T::read(self)
}
pub fn vec<T: Readable>(&mut self, len: usize) -> Vec<T> {
(0..len).map(|_| self.val()).collect()
}
}
pub trait Readable {
fn read(input: &mut Input) -> Self;
}
impl Readable for u32 {
fn read(input: &mut Input) -> Self {
let val = input.parse_digits_8byte().unwrap_or(0);
input.parse_digits(val) as _
}
}
impl Readable for u64 {
fn read(input: &mut Input) -> Self {
let val = input.parse_digits_8byte().map_or(0, |x| {
input
.parse_digits_8byte()
.map_or(x, |y| x * 100_000_000 + y)
});
input.parse_digits(val)
}
}
impl Readable for usize {
fn read(input: &mut Input) -> Self {
u64::read(input) as _
}
}
impl Readable for i32 {
fn read(input: &mut Input) -> Self {
let neg = input.parse_neg();
let val = u32::read(input) as Self;
if neg {
-val
} else {
val
}
}
}
impl Readable for i64 {
fn read(input: &mut Input) -> Self {
let neg = input.parse_neg();
let val = u64::read(input) as Self;
if neg {
-val
} else {
val
}
}
}
impl Readable for isize {
fn read(input: &mut Input) -> Self {
i64::read(input) as _
}
}
}
mod output {
use std::io::Write;
const DEFAULT_BUF_SIZE: usize = 1 << 18;
pub struct Output<W: Write, const N: usize = DEFAULT_BUF_SIZE> {
buf: [u8; N],
pos: usize,
inner: W,
}
impl<const N: usize> Output<std::io::StdoutLock<'static>, N> {
pub fn stdout() -> Self {
Self::new(std::io::stdout().lock())
}
}
impl<W: Write, const N: usize> Output<W, N> {
pub fn new(inner: W) -> Self {
Self {
buf: [0; N],
pos: 0,
inner,
}
}
pub fn flush(&mut self) -> std::io::Result<()> {
self.inner.write_all(&self.buf[..self.pos])?;
self.pos = 0;
Ok(())
}
fn reserve(&mut self, size: usize) {
if self.pos + size > self.buf.len() {
self.flush().unwrap();
}
}
fn write_bytes(&mut self, src: &[u8]) {
let src_len = src.len();
unsafe {
let src = src.as_ptr();
let dst = self.buf.as_mut_ptr().add(self.pos);
std::ptr::copy_nonoverlapping(src, dst, src_len);
}
self.pos += src.len();
}
fn write_digits<const LZ: bool>(&mut self, n: usize) {
static TABLE: [u8; 40_000] = {
let mut table = [b'0'; 40_000];
let mut i = 0;
while i < 10_000 {
table[4 * i + 0] += (i / 1000) as u8;
table[4 * i + 1] += (i / 100 % 10) as u8;
table[4 * i + 2] += (i / 10 % 10) as u8;
table[4 * i + 3] += (i % 10) as u8;
i += 1;
}
table
};
let offset = if LZ {
0
} else {
(n < 10) as usize + (n < 100) as usize + (n < 1000) as usize
};
unsafe {
let src = TABLE.as_ptr().add(4 * n + offset) as *const u32;
let dst = self.buf.as_mut_ptr().add(self.pos) as *mut u32;
std::ptr::write_unaligned(dst, std::ptr::read_unaligned(src));
}
self.pos += 4 - offset;
}
pub fn val<T: Writable<W, N>>(&mut self, val: T) {
T::write(self, val);
self.write_bytes(&[b'\n']);
}
}
pub trait Writable<W: Write, const N: usize> {
fn write(output: &mut Output<W, N>, val: Self);
}
impl<W: Write, const N: usize> Writable<W, N> for u64 {
fn write(output: &mut Output<W, N>, val: Self) {
output.reserve(20);
if val >= 1_0000_0000_0000_0000 {
output
.write_digits::<false>((val / 10000 / 10000 / 10000 / 10000) as usize);
output.write_digits::<true>((val / 10000 / 10000 / 10000 % 10000) as usize);
output.write_digits::<true>((val / 10000 / 10000 % 10000) as usize);
output.write_digits::<true>((val / 10000 % 10000) as usize);
output.write_digits::<true>((val % 10000) as usize);
} else if val >= 1_0000_0000_0000 {
output.write_digits::<false>((val / 10000 / 10000 / 10000) as usize);
output.write_digits::<true>((val / 10000 / 10000 % 10000) as usize);
output.write_digits::<true>((val / 10000 % 10000) as usize);
output.write_digits::<true>((val % 10000) as usize);
} else if val >= 1_0000_0000 {
output.write_digits::<false>((val / 10000 / 10000) as usize);
output.write_digits::<true>((val / 10000 % 10000) as usize);
output.write_digits::<true>((val % 10000) as usize);
} else if val >= 1_0000 {
output.write_digits::<false>((val / 10000) as usize);
output.write_digits::<true>((val % 10000) as usize);
} else {
output.write_digits::<false>(val as usize);
}
}
}
}
#[cfg(unix)]
pub use input::Input;
#[cfg(unix)]
pub use output::Output;
}
}
mod util {
pub trait Join {
fn join(self, sep: &str) -> String;
}
impl<T, I> Join for I
where
I: Iterator<Item = T>,
T: std::fmt::Display,
{
fn join(self, sep: &str) -> String {
let mut s = String::new();
use std::fmt::*;
for (i, v) in self.enumerate() {
if i > 0 {
write!(&mut s, "{}", sep).ok();
}
write!(&mut s, "{}", v).ok();
}
s
}
}
}