結果
| 問題 |
No.2261 Coffee
|
| コンテスト | |
| ユーザー |
 matamatajupiter
|
| 提出日時 | 2025-06-27 23:02:46 |
| 言語 | Rust (1.83.0 + proconio) |
| 結果 |
AC
|
| 実行時間 | 246 ms / 2,000 ms |
| コード長 | 6,420 bytes |
| コンパイル時間 | 13,443 ms |
| コンパイル使用メモリ | 402,592 KB |
| 実行使用メモリ | 16,828 KB |
| 最終ジャッジ日時 | 2025-06-27 23:03:21 |
| 合計ジャッジ時間 | 21,775 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge5 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 42 |
ソースコード
#![allow(dead_code)]
#![allow(unused_macros)]
#![allow(unused_imports)]
#[macro_use]
pub mod cp_lib {
macro_rules! chmin {
($a:expr, $b:expr) => {
if $b < $a {
$a = $b;
true
}
else {
false
}
};
}
macro_rules! chmax {
($a:expr, $b:expr) => {
if $b > $a {
$a = $b;
true
}
else {
false
}
};
}
macro_rules! graph {
($n:expr, $es:expr, directed, weighted) => {{
let mut g = vec![vec![]; $n.uz()];
for &(u, v, w) in $es {
g[u.uz()].push((v.uz(), w));
}
g
}};
($n:expr, $es:expr, directed, unweighted) => {{
let mut g = vec![vec![]; $n.uz()];
for &(u, v) in $es {
g[u.uz()].push(v.uz());
}
g
}};
($n:expr, $es:expr, undirected, weighted) => {{
let mut g = vec![vec![]; $n.uz()];
for &(u, v, w) in $es {
g[u.uz()].push((v.uz(), w));
g[v.uz()].push((u.uz(), w));
}
g
}};
($n:expr, $es:expr, undirected, unweighted) => {{
let mut g = vec![vec![]; $n.uz()];
for &(u, v) in $es {
g[u.uz()].push(v.uz());
g[v.uz()].push(u.uz());
}
g
}};
}
macro_rules! swap {
(a:expr, b:expr) => {{
let tmp = std::mem::replace(a, Default::default());
let tmp = std::mem::replace(b, tmp);
*(a) = tmp;
}};
(a:expr, b:expr, sentinel:expr) => {{
let tmp = std::mem::replace(a, sentinel);
let tmp = std::mem::replace(b, tmp);
*(a) = tmp;
}};
}
use std::collections::hash_map::{Entry as HEntry, HashMap};
use std::collections::btree_map::{Entry as BEntry, BTreeMap};
use std::hash::Hash;
pub trait MapExt<K, V> {
fn get_or<'a>(&'a self, key: &K, default: &'a V) -> &'a V;
fn modify<F>(&mut self, key: K, default: &V, func: F)
where
F: FnOnce(&V) -> V;
fn modify_ref<F>(&mut self, key: K, default: V, func: F)
where
F: FnOnce(&mut V);
}
impl<K, V> MapExt<K, V> for HashMap<K, V>
where
K: Eq + Hash,
{
fn get_or<'a>(&'a self, key: &K, default: &'a V) -> &'a V {
self.get(key).unwrap_or(default)
}
fn modify<F>(&mut self, key: K, default: &V, func: F)
where
F: FnOnce(&V) -> V,
{
match self.entry(key) {
HEntry::Occupied(mut entry) => {
let new_val = func(entry.get());
entry.insert(new_val);
}
HEntry::Vacant(entry) => {
let new_val = func(default);
entry.insert(new_val);
}
}
}
fn modify_ref<F>(&mut self, key: K, default: V, func: F)
where
F: FnOnce(&mut V),
{
match self.entry(key) {
HEntry::Occupied(mut entry) => {
func(entry.get_mut());
}
HEntry::Vacant(entry) => {
let mut val = default;
func(&mut val);
entry.insert(val);
}
}
}
}
impl<K, V> MapExt<K, V> for BTreeMap<K, V>
where
K: Ord
{
fn get_or<'a>(&'a self, key: &K, default: &'a V) -> &'a V {
self.get(key).unwrap_or(default)
}
fn modify<F>(&mut self, key: K, default: &V, func: F)
where
F: FnOnce(&V) -> V,
{
match self.entry(key) {
BEntry::Occupied(mut entry) => {
let new_val = func(entry.get());
entry.insert(new_val);
}
BEntry::Vacant(entry) => {
let new_val = func(default);
entry.insert(new_val);
}
}
}
fn modify_ref<F>(&mut self, key: K, default: V, func: F)
where
F: FnOnce(&mut V),
{
match self.entry(key) {
BEntry::Occupied(mut entry) => {
func(entry.get_mut());
}
BEntry::Vacant(entry) => {
let mut val = default;
func(&mut val);
entry.insert(val);
}
}
}
}
pub trait AsUsize {
fn uz(self) -> usize;
}
macro_rules! impl_to_usize {
($($t:ty),*) => {
$(
impl AsUsize for $t {
#[allow(unused_comparisons)]
fn uz(self) -> usize {
if self < 0 {
panic!("negative index: {}", self);
}
self as usize
}
}
)*
};
}
impl_to_usize!(u8, u16, u32, u64, usize, i8, i16, i32, i64, isize);
pub type WeightedGraph<T> = Vec<Vec<(usize, T)>>;
pub type UnweightedGraph = Vec<Vec<usize>>;
}
use std::cmp::{max, min, Reverse};
use std::collections::{HashSet, HashMap, VecDeque, BinaryHeap};
use std::mem::{swap, replace};
use proconio::input;
use proconio::marker::*;
use cp_lib::*;
fn main() {
input! {
n: usize,
xs: [[i64; 5]; n],
};
let x2u = |x: &Vec<i64>| -> Vec<i64> {
let mut u = vec![0; 1 << 5];
for sgn in 0..1 << 5 {
for i in 0..5 {
if sgn & 1 << i == 0 {
u[sgn] += x[i];
}
else {
u[sgn] -= x[i];
}
}
}
u
};
let mut u_max = vec![i64::MIN; 1 << 5];
for x in &xs {
let u = x2u(x);
for i in 0..1 << 5 {
chmax!(u_max[i], u[i]);
}
}
for x in &xs {
let u = x2u(x);
let mut dist = i64::MIN;
for i in 0..1 << 5 {
chmax!(dist, u_max[i] - u[i]);
}
println!("{}", dist);
}
}