Solve 075 and 076 in typical90

Author: k-yomo

atcoder/rust/typical90/src/bin/050.rs

@@ -12,8 +12,30 @@ use proconio::*;
 use proconio::marker::*;
 use superslice::*;
 
+const Mod: usize = 1000000007;
+
 fn main() {
     input! {
+        n: usize,
+        l: usize,
+    }
+
+    let mut fact = vec![1; 1000000];
+    let mut fact_inv = vec![1; 1000000];
+    let mut inv = vec![1; 1000000];
+    for i in 2..100000 {
+        fact[i] = fact[i - 1] * i % Mod;
+        inv[i] = Mod - inv[Mod % i] * (Mod / i) % Mod;
+        fact_inv[i] = fact_inv[i - 1] * inv[i] % Mod;
+    }
 
+    let mut ans = 0;
+    let max_l_num = n / l;
+    for i in 0..=max_l_num {
+        let n = (n - i * l) + i;
+        ans = (ans + fact[n] * (fact_inv[i] * fact_inv[n - i] % Mod)) % Mod;
     }
+
+    println!("{}", ans)
 }
+

atcoder/rust/typical90/src/bin/052.rs

@@ -12,8 +12,28 @@ use proconio::*;
 use proconio::marker::*;
 use superslice::*;
 
+const Mod: usize = 1000000007;
+
 fn main() {
     input! {
+        n: usize,
+        a: [[usize; 6]; n],
+    }
+
+    //
 
+    let dice_sums: Vec<usize> = a.iter().map(|dice|  dice.iter().sum()).collect();
+    if dice_sums.len() == 1 {
+        return println!("{}", dice_sums[0]);
     }
+
+    let mut total = 0;
+    for (i, dice) in a.iter().enumerate() {
+        let s = dice_sums.iter().enumerate().filter(|(k, dice)| *k != i).map(|(k, dice_sum)| dice_sum).product::<usize>() % Mod;
+        for j in dice {
+            total = (total + j * s % Mod) % Mod;
+        }
+    }
+
+    println!("{}", total);
 }

atcoder/rust/typical90/src/bin/064.rs

@@ -2,7 +2,6 @@
 
 use std::cmp::*;
 use std::collections::*;
-use std::io::Write;
 use std::ops::Bound::*;
 
 use itertools::*;
@@ -14,6 +13,29 @@ use superslice::*;
 
 fn main() {
     input! {
+        n: usize, q: usize,
+        mut a: [i128; n],
+        lrv: [(usize, usize, i128); q],
+    }
+
+    let mut total = 0;
+    let mut diffs = vec![];
+    for i in 1..a.len() {
+        total += (a[i-1] - a[i]).abs();
+        diffs[i] = (a[i-1] - a[i]).abs();
+    }
 
+    for (l, r, v) in lrv {
+        let mut diff: i128 = 0;
+        if l > 1 {
+            diff += (diffs[l-2] + v).abs() - diffs[l-2];
+            diffs[l-2] += v;
+        }
+        if r < n {
+            diff += (diffs[r-1] - v).abs() - diffs[r-1];
+            diffs[r-1] += v;
+        }
+        total += diff;
+        seg_tree.apply_range(l-1, r-1, v);
     }
 }

atcoder/rust/typical90/src/bin/075.rs

@@ -5,15 +5,71 @@ use std::collections::*;
 use std::io::Write;
 use std::ops::Bound::*;
 
-use itertools::*;
 use itertools::__std_iter::once;
+use itertools::*;
 use itertools_num::ItertoolsNum;
-use proconio::*;
 use proconio::marker::*;
+use proconio::*;
 use superslice::*;
 
 fn main() {
     input! {
+        n: usize,
+    }
+    let prime_num = prime_factors(n).values().sum::<usize>();
+    println!("{}", (prime_num as f64).log2().ceil())
+}
+
+fn prime_factors(mut n: usize) -> HashMap<usize, usize> {
+    let mut primes = sieve_of_eratosthenes(f64::sqrt(n as f64) as usize);
+    let mut hm_primes = HashMap::new();
+
+    for prime in primes {
+        while n % prime == 0 {
+            n /= prime;
+            if hm_primes.contains_key(&prime) {
+                let mut x = hm_primes.get_mut(&prime).unwrap();
+                *x += 1;
+            } else {
+                hm_primes.insert(prime, 1);
+            }
+        }
+    }
+
+    if n > 1 {
+        if hm_primes.contains_key(&n) {
+            let mut x = hm_primes.get_mut(&n).unwrap();
+            *x += 1;
+        } else {
+            hm_primes.insert(n, 1);
+        }
+    }
+    hm_primes
+}
+
+fn sieve_of_eratosthenes(n: usize) -> Vec<usize> {
+    let mut spf = vec![None; n + 1];
+    let mut is_prime = vec![true; n + 1];
+    let mut primes = Vec::new();
+
+    is_prime[0] = false;
+    is_prime[1] = false;
+
+    for i in 2..n + 1 {
+        if is_prime[i] {
+            primes.push(i);
+            spf[i] = Some(i);
+        }
+
+        for prime in &primes {
+            if i * prime >= n + 1 || prime > &spf[i].unwrap() {
+                break;
+            }
+
+            is_prime[i * prime] = false;
 
+            spf[i * prime] = Some(*prime);
+        }
     }
+    primes
 }

atcoder/rust/typical90/src/bin/076.rs

@@ -5,15 +5,34 @@ use std::collections::*;
 use std::io::Write;
 use std::ops::Bound::*;
 
-use itertools::*;
 use itertools::__std_iter::once;
+use itertools::*;
 use itertools_num::ItertoolsNum;
-use proconio::*;
 use proconio::marker::*;
+use proconio::*;
 use superslice::*;
 
 fn main() {
     input! {
+        n: usize,
+        a: [usize; n],
+    }
 
+    let total_size = a.iter().sum::<usize>();
+    let mut cur_size = 0;
+    let (mut l, mut r) = (0, 0);
+    let a2 = a.iter().chain(a.iter()).map(|&i| i).collect::<Vec<usize>>();
+    for (i, size) in a2.iter().enumerate() {
+        cur_size += size;
+        r = i;
+        while cur_size > total_size / 10 {
+            cur_size -= a2[l];
+            l += 1;
+        }
+        if l <= r && cur_size == total_size / 10 {
+            return println!("Yes");
+        }
     }
+
+    println!("No")
 }