結果

問題 No.1300 Sum of Inversions
ユーザー nebocco
提出日時 2020-11-28 20:42:52
言語 Rust
(1.83.0 + proconio)
結果
AC  
実行時間 104 ms / 2,000 ms
コード長 16,909 bytes
コンパイル時間 14,345 ms
コンパイル使用メモリ 400,696 KB
実行使用メモリ 13,204 KB
最終ジャッジ日時 2024-09-13 01:37:30
合計ジャッジ時間 18,600 ms
ジャッジサーバーID
(参考情報)
judge2 / judge5
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 3
other AC * 34
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

fn main() {
type Fp = F998244353;
let mut io = IO::new();
let n = io.scan();
let a: Vec<i64> = io.scan_vec(n);
let (m, _, _, res) = compress(&a);
let mut bitfv = FenwickTree::<Fp>::new(m);
let mut bitbv = FenwickTree::<Fp>::new(m);
let mut bitf = FenwickTree::<i64>::new(m);
let mut bitb = FenwickTree::<i64>::new(m);
let a = a.into_iter().map(Fp::new).collect::<Vec<Fp>>();
for (&x, &y) in res.iter().zip(a.iter()) {
bitb.add(x, 1);
bitbv.add(x, y);
}
let mut ans = Fp::zero();
for i in 0..n {
bitb.add(res[i], -1);
bitbv.add(res[i], -a[i]);
let bkc = Fp::new(bitb.sum(..res[i]));
let frc = Fp::new(bitf.sum(res[i]+1..));
let bkv = bitbv.sum(..res[i]);
let frv = bitfv.sum(res[i]+1..);
ans += a[i] * bkc * frc + bkc * frv + frc * bkv;
bitf.add(res[i], 1);
bitfv.add(res[i], a[i]);
}
io.println(ans);
}
// ------------ traits start ------------
impl<T: Mod> Scan for Fp<T> {
fn scan(s: &mut IO) -> Self {
Self::new(i64::scan(s))
}
}
impl<T: Mod> Print for Fp<T> {
fn print(w: &mut IO, x: Self) {
w.print(x.into_inner());
}
}
// ------------ traits end ------------
// ------------ libraries start ------------
use std::collections::HashMap;
pub fn compress<T: Clone + Ord + Hash>(l: &[T])-> (usize, HashMap<T, usize>, Vec<T>, Vec<usize>) {
let mut f = l.to_owned();
f.sort();
f.dedup();
let dict: HashMap<T, usize> = f.iter().cloned().zip(0..f.len()).collect();
let res: Vec<usize> = l.iter().map(|x| *dict.get(x).unwrap()).collect();
(f.len(), dict, f, res)
}
// ------------ FenwickTree with generics start ------------
#[derive(Clone, Debug)]
pub struct FenwickTree<T>(Vec<T>);
impl<T: Monoid> FenwickTree<T> {
#[inline]
fn lsb(x: usize) -> usize {
x & x.wrapping_neg()
}
pub fn new(n: usize) -> Self {
Self(vec![T::zero(); n+1])
}
pub fn prefix_sum(&self, i: usize) -> T {
std::iter::successors(Some(i), |&i| Some(i - Self::lsb(i)))
.take_while(|&i| i != 0)
.map(|i| self.0[i].clone())
.fold(T::zero(), |sum, x| sum + x)
}
pub fn add(&mut self, i: usize, x: T) {
let n = self.0.len();
std::iter::successors(Some(i + 1), |&i| Some(i + Self::lsb(i)))
.take_while(|&i| i < n)
.for_each(|i| self.0[i] = self.0[i].clone() + x.clone());
}
pub fn partition(&self, pred: impl Fn(usize, &T) -> bool) -> (usize, T) {
assert!(pred(0, &self.0[0]), "need to be pred(0, 0)");
let mut j = 0;
let mut current = self.0[0].clone();
let n = self.0.len();
for d in std::iter::successors(Some(n.next_power_of_two() >> 1), |&d| { Some(d >> 1)})
.take_while(|&d| d != 0)
{
if j + d < n {
let next = current.clone() + self.0[j + d].clone();
if pred(j + d, &next) {
current = next;
j += d;
}
}
}
(j, current)
}
}
impl<T: Monoid> From<Vec<T>> for FenwickTree<T> {
fn from(src: Vec<T>) -> Self {
let mut table = std::iter::once(T::zero())
.chain(src.into_iter())
.collect::<Vec<T>>();
let n = table.len();
(1..n)
.map(|i| (i, i + Self::lsb(i)))
.filter(|&(_, j)| j < n)
.for_each(|(i, j)| {
table[j] = table[j].clone() + table[i].clone();
});
Self(table)
}
}
impl<T: Group> FenwickTree<T> {
pub fn sum<R: RangeBounds<usize>>(&self, rng: R) -> T {
let Range { start, end } = bounds_within(rng, self.0.len() - 1);
self.prefix_sum(end) + -self.prefix_sum(start)
}
}
use std::ops::Bound::{Excluded, Included, Unbounded};
use std::ops::{Range, RangeBounds};
///
///
/// `r` `0..len`
///
/// # Examples
/// ```
/// use bibliotheca::utils::bounds::bounds_within;
///
/// assert_eq!(bounds_within(.., 7), 0..7);
/// assert_eq!(bounds_within(..=4, 7), 0..5);
/// ```
pub fn bounds_within<R: RangeBounds<usize>>(r: R, len: usize) -> Range<usize> {
let e_ex = match r.end_bound() {
Included(&e) => e + 1,
Excluded(&e) => e,
Unbounded => len,
}
.min(len);
let s_in = match r.start_bound() {
Included(&s) => s,
Excluded(&s) => s + 1,
Unbounded => 0,
}
.min(e_ex);
s_in..e_ex
}
// ------------ FenwickTree with generics end ------------
// ------------ libraries end ------------
// ------------ traits start ------------
use std::{
fmt::{Debug, Display},
hash::Hash,
iter,
marker::PhantomData,
ops,
};
crate::define_fp!(pub F998244353, Mod998244353, 998244353);
crate::define_fp!(pub F1000000007, Mod1000000007, 1000000007);
#[derive(Clone, PartialEq, Copy, Eq, Hash)]
pub struct Fp<T>(i64, PhantomData<T>);
pub trait Mod: Debug + Clone + PartialEq + Copy + Eq + Hash {
const MOD: i64;
}
impl<T: Mod> Fp<T> {
pub fn new(mut x: i64) -> Self {
x %= T::MOD;
Self::unchecked(if x < 0 { x + T::MOD } else { x })
}
pub fn into_inner(self) -> i64 {
self.0
}
pub fn r#mod() -> i64 {
T::MOD
}
pub fn inv(self) -> Self {
assert_ne!(self.0, 0, "Zero division");
let (sign, x) = if self.0 * 2 < T::MOD {
(1, self.0)
} else {
(-1, T::MOD - self.0)
};
let (g, _a, b) = ext_gcd(T::MOD, x);
let ans = sign * b;
assert_eq!(g, 1);
Self::unchecked(if ans < 0 { ans + T::MOD } else { ans })
}
pub fn frac(x: i64, y: i64) -> Self {
Fp::new(x) / Fp::new(y)
}
pub fn pow(mut self, mut p: u64) -> Self {
let mut ans = Fp::new(1);
while p != 0 {
if p & 1 == 1 {
ans *= self;
}
self *= self;
p >>= 1;
}
ans
}
fn unchecked(x: i64) -> Self {
Self(x, PhantomData)
}
}
impl<T: Mod> iter::Sum<Fp<T>> for Fp<T> {
fn sum<I>(iter: I) -> Self
where
I: iter::Iterator<Item = Fp<T>>,
{
iter.fold(Fp::new(0), ops::Add::add)
}
}
impl<'a, T: 'a + Mod> iter::Sum<&'a Fp<T>> for Fp<T> {
fn sum<I>(iter: I) -> Self
where
I: iter::Iterator<Item = &'a Fp<T>>,
{
iter.fold(Fp::new(0), ops::Add::add)
}
}
impl<T: Mod> iter::Product<Fp<T>> for Fp<T> {
fn product<I>(iter: I) -> Self
where
I: iter::Iterator<Item = Fp<T>>,
{
iter.fold(Self::new(1), ops::Mul::mul)
}
}
impl<'a, T: 'a + Mod> iter::Product<&'a Fp<T>> for Fp<T> {
fn product<I>(iter: I) -> Self
where
I: iter::Iterator<Item = &'a Fp<T>>,
{
iter.fold(Self::new(1), ops::Mul::mul)
}
}
impl<T: Mod> Debug for Fp<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
write!(f, "{}", self.0)
}
}
impl<T: Mod> Display for Fp<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
write!(f, "{}", self.0)
}
}
// ax + by = gcd(x, y) (a, b) (g, a, b)
//
// | 0 -x | | y -x | | x 0 |
// | 1 b | = | a b | | y 1 |
fn ext_gcd(x: i64, y: i64) -> (i64, i64, i64) {
let (b, g) = {
let mut x = x;
let mut y = y;
let mut u = 0;
let mut v = 1;
while x != 0 {
let q = y / x;
y -= q * x;
v -= q * u;
std::mem::swap(&mut x, &mut y);
std::mem::swap(&mut u, &mut v);
}
(v, y)
};
assert_eq!((g - b * y) % x, 0);
let a = (g - b * y) / x;
(g, a, b)
}
#[macro_export]
macro_rules! define_fp {
($vis:vis $fp:ident, $t:ident, $mod:expr) => {
#[derive(Debug, Clone, PartialEq, Copy, Eq, Hash)]
$vis struct $t;
// NOTE: `$crate::`
impl Mod for $t {
const MOD: i64 = $mod;
}
// NOTE: `$crate::`
$vis type $fp = Fp<$t>;
}
}
use std::ops::*;
impl<T: Mod> Associative for Fp<T> {}
impl<T: Mod> Zero for Fp<T> {
fn zero() -> Self { Self::unchecked(0) }
fn is_zero(&self) -> bool { self.0 == 0 }
}
impl<T: Mod> One for Fp<T> {
fn one() -> Self { Self::unchecked(1) }
fn is_one(&self) -> bool { self.0 == 1 }
}
impl<T: Mod> Add for Fp<T> {
type Output = Self;
fn add(self, rhs: Self) -> Self {
let res = self.0 + rhs.0;
Self::unchecked(if T::MOD <= res { res - T::MOD } else { res })
}
}
impl<T: Mod> Sub for Fp<T> {
type Output = Self;
fn sub(self, rhs: Self) -> Self {
let res = self.0 - rhs.0;
Self::unchecked(if res < 0 { res + T::MOD } else { res })
}
}
impl<T: Mod> Mul for Fp<T> {
type Output = Self;
fn mul(self, rhs: Self) -> Self {
Self::new(self.0 * rhs.0)
}
}
#[allow(clippy::suspicious_arithmetic_impl)]
impl<T: Mod> Div for Fp<T> {
type Output = Self;
fn div(self, rhs: Self) -> Self {
self * rhs.inv()
}
}
impl<M: Mod> Neg for Fp<M> {
type Output = Self;
fn neg(self) -> Self {
if self.0 == 0 {
Self::unchecked(0)
} else {
Self::unchecked(M::MOD - self.0)
}
}
}
impl<M: Mod> Neg for &Fp<M> {
type Output = Fp<M>;
fn neg(self) -> Self::Output {
if self.0 == 0 {
Fp::unchecked(0)
} else {
Fp::unchecked(M::MOD - self.0)
}
}
}
macro_rules! forward_assign_biop {
($(impl $trait:ident, $fn_assign:ident, $fn:ident)*) => {
$(
impl<M: Mod> $trait for Fp<M> {
fn $fn_assign(&mut self, rhs: Self) {
*self = self.$fn(rhs);
}
}
)*
};
}
forward_assign_biop! {
impl AddAssign, add_assign, add
impl SubAssign, sub_assign, sub
impl MulAssign, mul_assign, mul
impl DivAssign, div_assign, div
}
macro_rules! forward_ref_binop {
($(impl $imp:ident, $method:ident)*) => {
$(
impl<'a, T: Mod> $imp<Fp<T>> for &'a Fp<T> {
type Output = Fp<T>;
fn $method(self, other: Fp<T>) -> Self::Output {
$imp::$method(*self, other)
}
}
impl<'a, T: Mod> $imp<&'a Fp<T>> for Fp<T> {
type Output = Fp<T>;
fn $method(self, other: &Fp<T>) -> Self::Output {
$imp::$method(self, *other)
}
}
impl<'a, T: Mod> $imp<&'a Fp<T>> for &'a Fp<T> {
type Output = Fp<T>;
fn $method(self, other: &Fp<T>) -> Self::Output {
$imp::$method(*self, *other)
}
}
)*
};
}
forward_ref_binop! {
impl Add, add
impl Sub, sub
impl Mul, mul
impl Div, div
}
use std::marker::Sized;
///
pub trait Element: Sized + Clone + PartialEq {}
impl<T: Sized + Clone + PartialEq> Element for T {}
///
pub trait Associative: Magma {}
///
pub trait Magma: Element + Add<Output=Self> {}
impl<T: Element + Add<Output=Self>> Magma for T {}
///
pub trait SemiGroup: Magma + Associative {}
impl<T: Magma + Associative> SemiGroup for T {}
///
pub trait Monoid: SemiGroup + Zero {}
impl<T: SemiGroup + Zero> Monoid for T {}
pub trait ComMonoid: Monoid + AddAssign {}
impl<T: Monoid + AddAssign> ComMonoid for T {}
///
pub trait Group: Monoid + Neg<Output=Self> {}
impl<T: Monoid + Neg<Output=Self>> Group for T {}
pub trait ComGroup: Group + ComMonoid {}
impl<T: Group + ComMonoid> ComGroup for T {}
///
pub trait SemiRing: ComMonoid + Mul<Output=Self> + One {}
impl<T: ComMonoid + Mul<Output=Self> + One> SemiRing for T {}
///
pub trait Ring: ComGroup + SemiRing {}
impl<T: ComGroup + SemiRing> Ring for T {}
pub trait ComRing: Ring + MulAssign {}
impl<T: Ring + MulAssign> ComRing for T {}
///
pub trait Field: ComRing + Div<Output=Self> + DivAssign {}
impl<T: ComRing + Div<Output=Self> + DivAssign> Field for T {}
///
pub trait Zero: Element {
fn zero() -> Self;
fn is_zero(&self) -> bool;
}
///
pub trait One: Element {
fn one() -> Self;
fn is_one(&self) -> bool;
}
macro_rules! impl_integer {
($($T:ty,)*) => {
$(
impl Associative for $T {}
impl Zero for $T {
fn zero() -> Self { 0 }
fn is_zero(&self) -> bool { *self == 0 }
}
impl<'a> Zero for &'a $T {
fn zero() -> Self { &0 }
fn is_zero(&self) -> bool { *self == &0 }
}
impl One for $T {
fn one() -> Self { 1 }
fn is_one(&self) -> bool { *self == 1 }
}
impl<'a> One for &'a $T {
fn one() -> Self { &1 }
fn is_one(&self) -> bool { *self == &1 }
}
)*
};
}
impl_integer! {
i8, i16, i32, i64, i128, isize,
u8, u16, u32, u64, u128, usize,
}
// ------------ traits end ------------
// ------------ io module start ------------
use std::io::{stdout, BufWriter, Read, StdoutLock, Write};
pub struct IO {
iter: std::str::SplitAsciiWhitespace<'static>,
buf: BufWriter<StdoutLock<'static>>,
}
impl IO {
pub fn new() -> Self {
let mut input = String::new();
std::io::stdin().read_to_string(&mut input).unwrap();
let input = Box::leak(input.into_boxed_str());
let out = Box::new(stdout());
IO {
iter: input.split_ascii_whitespace(),
buf: BufWriter::new(Box::leak(out).lock()),
}
}
fn scan_str(&mut self) -> &'static str {
self.iter.next().unwrap()
}
fn scan_raw(&mut self) -> &'static [u8] {
self.scan_str().as_bytes()
}
pub fn scan<T: Scan>(&mut self) -> T {
T::scan(self)
}
pub fn scan_vec<T: Scan>(&mut self, n: usize) -> Vec<T> {
(0..n).map(|_| self.scan()).collect()
}
}
impl IO {
pub fn print<T: Print>(&mut self, x: T) {
T::print(self, x);
}
pub fn println<T: Print>(&mut self, x: T) {
self.print(x);
self.print("\n");
}
pub fn iterln<T: Print, I: Iterator<Item = T>>(&mut self, mut iter: I, delim: &str) {
if let Some(v) = iter.next() {
self.print(v);
for v in iter {
self.print(delim);
self.print(v);
}
}
self.print("\n");
}
pub fn flush(&mut self) {
self.buf.flush().unwrap();
}
}
impl Default for IO {
fn default() -> Self {
Self::new()
}
}
pub trait Scan {
fn scan(io: &mut IO) -> Self;
}
macro_rules! impl_parse_int {
($($t:tt),*) => {
$(
impl Scan for $t {
fn scan(s: &mut IO) -> Self {
let mut res = 0;
let mut neg = false;
for d in s.scan_raw() {
if *d == b'-' {
neg = true;
} else {
res *= 10;
res += (*d - b'0') as $t;
}
}
if neg { res = res.wrapping_neg(); }
res
}
}
)*
};
}
impl_parse_int!(i16, i32, i64, isize, u16, u32, u64, usize);
impl<T: Scan, U: Scan> Scan for (T, U) {
fn scan(s: &mut IO) -> Self {
(T::scan(s), U::scan(s))
}
}
impl<T: Scan, U: Scan, V: Scan> Scan for (T, U, V) {
fn scan(s: &mut IO) -> Self {
(T::scan(s), U::scan(s), V::scan(s))
}
}
impl<T: Scan, U: Scan, V: Scan, W: Scan> Scan for (T, U, V, W) {
fn scan(s: &mut IO) -> Self {
(T::scan(s), U::scan(s), V::scan(s), W::scan(s))
}
}
pub trait Print {
fn print(w: &mut IO, x: Self);
}
macro_rules! impl_print_int {
($($t:ty),*) => {
$(
impl Print for $t {
fn print(w: &mut IO, x: Self) {
w.buf.write_all(x.to_string().as_bytes()).unwrap();
}
}
)*
};
}
impl_print_int!(i16, i32, i64, isize, u16, u32, u64, usize);
impl Print for u8 {
fn print(w: &mut IO, x: Self) {
w.buf.write_all(&[x]).unwrap();
}
}
impl Print for &[u8] {
fn print(w: &mut IO, x: Self) {
w.buf.write_all(x).unwrap();
}
}
impl Print for &str {
fn print(w: &mut IO, x: Self) {
w.print(x.as_bytes());
}
}
impl<T: Print, U: Print> Print for (T, U) {
fn print(w: &mut IO, (x, y): Self) {
w.print(x);
w.print(" ");
w.print(y);
}
}
impl<T: Print, U: Print, V: Print> Print for (T, U, V) {
fn print(w: &mut IO, (x, y, z): Self) {
w.print(x);
w.print(" ");
w.print(y);
w.print(" ");
w.print(z);
}
}
impl<T: Print, U: Print, V: Print, W: Print> Print for (T, U, V, W) {
fn print(w: &mut IO, (x, y, z, a): Self) {
w.print(x);
w.print(" ");
w.print(y);
w.print(" ");
w.print(z);
w.print(" ");
w.print(a);
}
}
// ------------ io module end ------------
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0