complete 1660.rs 5242.rs 8406.rs 14024.rs

storage/contest/cpp/ucpc2026-B.cpp

@@ -0,0 +1,35 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+#define let auto
+#define fn auto
+typedef size_t us;
+using namespace std;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+struct Bread {
+    us p, t, f;
+};
+
+fn main() -> int {
+    fastio();
+    us n;
+    cin >> n;
+    let breads = vector<Bread>(n);
+
+    for (us i=0;i<n;i++){
+        us p, t, f;
+        cin >> p >> t >> f;
+        breads[i].p = p; // prepare
+        breads[i].t = t; // time to bake
+        breads[i].f = f; // fresh
+    }
+    
+
+    
+}

storage/contest/cpp/ucpc2026-F.cpp

@@ -0,0 +1,50 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+#define let auto
+#define fn auto
+#define usize size_t
+using namespace std;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+fn main() -> int {
+    fastio();
+    usize n, q;
+
+    cin >> n >> q;
+    let a = vector<usize>(n);
+    let b = vector<usize>(n);
+
+    for (usize i = 0; i < n; i++) {
+        cin >> a[i];
+    }
+    for (usize i = 0; i < n; i++) {
+        cin >> b[i];
+    }
+    for (usize i = 0; i < q; i++) {
+        usize l, r, k;
+        cin >> l >> r >> k;
+        l -= 1;
+        k -= 1;
+        r -= 1;
+        let x = k - l;
+        
+        let w1 = a[x + l];
+        let w2 = b[x + l];
+        let wo1 = a[r - x];
+        let wo2 = b[r - x];
+
+        if (x == 0) {
+            cout << "(" << "\n";
+        } else if (x == r - l) {
+            cout << ")" << "\n";
+        } else {
+            if (w1 + wo2 > w2 + wo2)
+        }
+    }
+}

storage/jungol/cpp/completed/1183.cpp

@@ -0,0 +1,88 @@
+#include <algorithm>
+#include <iostream>
+#include <numeric>
+#include <queue>
+#include <vector>
+
+#define let auto
+#define fn auto
+using namespace std;
+
+typedef size_t usize;
+typedef ssize_t isize;
+typedef int32_t i32;
+typedef u_int32_t u32;
+typedef int64_t i64;
+typedef u_int64_t u64;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+struct State {
+    usize curr;
+    usize w;
+    vector<u64> pays;
+};
+
+fn main() -> int {
+    fastio();
+    const usize N = 6;
+    let coins = vector<u64>{500, 100, 50, 10, 5, 1};
+    let counts = vector<u64>(N);
+
+    usize w;
+    cin >> w;
+
+    for (let &v: counts) {
+        cin >> v;
+    }
+
+    let stack = vector<State>();
+    let maxpays = vector<u64>(N, 0);
+    let maxtotal = (u64) 0;
+    stack.push_back({N - 1, w, vector<u64>(N, 0)});
+    while (!stack.empty()) {
+        let now = stack.back();
+        stack.pop_back();
+
+        let curr = now.curr;
+        if (curr == 0) {
+            if (now.w % coins[curr] != 0) {
+                continue;
+            } else {
+                now.pays[curr] = now.w / coins[curr];
+                u64 total = accumulate(now.pays.begin(), now.pays.end(), 0);
+                if (total > maxtotal) {
+                    maxpays = now.pays;
+                    maxtotal = total;
+                }
+            }
+
+        } else {
+            let rem = now.w % coins[curr - 1] / coins[curr];
+            let delta = coins[curr - 1] / coins[curr];
+            if (counts[curr] < rem) {
+                continue;
+            }
+            let maxto = (counts[curr] - rem) / delta;
+
+            for (usize i = 0; i <= maxto; i++) {
+                let cst = (i * delta + rem) * coins[curr];
+                if (cst > now.w) {
+                    break;
+                }
+                let newpay = now.pays;
+                newpay[curr] = i * delta + rem;
+                stack.push_back({curr - 1, now.w - cst, newpay});
+            }
+        }
+    }
+
+    cout << maxtotal << endl;
+    for (let p: maxpays) {
+        cout << p << " ";
+    }
+    cout << endl;
+}

storage/jungol/cpp/completed/1190.cpp

@@ -0,0 +1,52 @@
+#include <algorithm>
+#include <iostream>
+#include <queue>
+#include <vector>
+
+#define let auto
+#define fn auto
+using namespace std;
+
+typedef size_t usize;
+typedef ssize_t isize;
+typedef int32_t i32;
+typedef u_int32_t u32;
+typedef int64_t i64;
+typedef u_int64_t u64;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+fn main() -> int {
+    fastio();
+
+    usize n;
+    cin >> n;
+    let lengths = vector<u64>(n);
+    for (let &l: lengths) {
+        cin >> l;
+    }
+
+    let gt = std::greater<u64>();
+
+    make_heap(lengths.begin(), lengths.end(), gt);
+
+    u64 cost = 0;
+    while (lengths.size() > 1) {
+        pop_heap(lengths.begin(), lengths.end(), gt);
+        let a = lengths.back();
+        lengths.pop_back();
+
+        pop_heap(lengths.begin(), lengths.end(), gt);
+        let b = lengths.back();
+        lengths.pop_back();
+
+        cost += a + b;
+        lengths.push_back(a + b);
+        push_heap(lengths.begin(), lengths.end(), gt);
+    }
+
+    cout << cost << endl;
+}

storage/jungol/cpp/completed/1929.cpp

@@ -0,0 +1,47 @@
+#include <algorithm>
+#include <iostream>
+#include <queue>
+#include <vector>
+
+#define let auto
+#define fn auto
+#define usize size_t
+using namespace std;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+fn main() -> int {
+    fastio();
+
+    
+    usize n;
+    cin >> n;
+    let lengths = vector<usize>(n);
+    for (let &l: lengths) {
+        cin >> l;
+    }
+
+    let gt = std::greater<usize>();
+
+    make_heap(lengths.begin(), lengths.end(), gt);
+    
+    usize cost = 0;
+    while (lengths.size() > 1) {
+        pop_heap(lengths.begin(), lengths.end(), gt);
+        let a = lengths.back();
+        lengths.pop_back();
+
+        pop_heap(lengths.begin(), lengths.end(), gt);
+        let b = lengths.back();
+        lengths.pop_back();
+        
+        cost += a + b;
+        lengths.push_back(a + b);
+        push_heap(lengths.begin(), lengths.end(), gt);
+    }
+
+    cout << cost << endl;
+}

storage/jungol/rs/1379.rs

@@ -0,0 +1,14 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+
+    let n = iter.next().unwrap();
+    let m = iter.next().unwrap();
+    
+}
+

storage/jungol/rs/completed/1370.rs

@@ -0,0 +1,39 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+
+    let mut arr = (0..n)
+        .map(|_| {
+            (
+                iter.next().unwrap(), // idx(no.)
+                iter.next().unwrap(), // start
+                iter.next().unwrap(), // end
+            )
+        })
+        .collect::<Vec<_>>();
+
+    arr.sort_by_key(|x| x.2);
+
+    let mut selected = vec![];
+
+    for (i, s, e) in arr {
+        if selected.len() == 0 {
+            selected.push((i, e));
+        } else {
+            if selected.last().unwrap().1 <= s {
+                selected.push((i, e));
+            }
+        }
+    }
+    println!("{}", selected.len());
+    for (i, _) in selected {
+        print!("{} ", i);
+    }
+    println!();
+}

storage/jungol/rs/completed/14024.rs

@@ -0,0 +1,55 @@
+use std::{
+    cmp::min, io::{read_to_string, stdin, stdout, Write},
+};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let (n, m, q) = (
+        iter.next().unwrap(),
+        iter.next().unwrap(),
+        iter.next().unwrap(),
+    );
+
+    let mut lock = stdout().lock();
+
+    let mut bfs = (0..m).map(|_| iter.next().unwrap()).collect::<Vec<_>>();
+    bfs.sort();
+
+    let dist = |a: usize, b: usize| -> usize {
+        let d = if a > b { a - b } else { b - a };
+        min(d, 2 * n - d)
+    };
+
+    for _ in 0..q {
+        let (mut x, mut y) = (iter.next().unwrap(), iter.next().unwrap());
+        if x > y {
+            (x, y) = (y, x);
+        }
+        let delta = y - x;
+
+        let mut r = min(delta, 2 * n - delta);
+
+        let (px, py) = (x % n, y % n);
+
+        let ix = bfs.partition_point(|&k| k < px);
+        let iy = bfs.partition_point(|&k| k < py);
+
+        let cands = [(ix + m - 1) % m, ix % m, (iy + m - 1) % m, iy % m];
+
+        for &cand in &cands {
+            let k = bfs[cand];
+            let u = k;
+            let v = k + n;
+            let d1 = dist(x, u) + dist(v, y) + 1;
+            let d2 = dist(x, v) + dist(u, y) + 1;
+            r = min(r, d1);
+            r = min(r, d2);
+        }
+
+        writeln!(lock, "{}", r).unwrap();
+    }
+}

storage/jungol/rs/completed/1660.rs

@@ -0,0 +1,35 @@
+use std::io::{read_to_string, stdin};
+
+fn countf2x(x: u64) -> u64 {
+    // f(2^x - 1) = 2^(x-1) * x;
+    if x == 0 {
+        0
+    } else {
+        2u64.pow((x - 1) as u32) * x
+    }
+}
+
+fn countf(n: u64) -> u64 {
+    let mut x = 32u64;
+    let mut t = 1u64 << 32u64;
+    if n == 0 {
+        return 0;
+    }
+    while t & n == 0 {
+        t >>= 1;
+        x -= 1;
+    }
+
+    countf2x(x) + (n + 1 - t) + countf(n - t)
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap() as u64;
+
+    println!("{}", countf(n));
+}

storage/jungol/rs/completed/2499.rs

@@ -0,0 +1,33 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let weights = {
+        let mut v = (0..n).map(|_| iter.next().unwrap()).collect::<Vec<_>>();
+        v.sort();
+        
+        v
+    };
+
+    // we can make the range [min(S), sum(S)]
+    let mut res = 0;
+    let mut cum = 0;
+    for &w in weights.iter() {
+        if cum + 1 < w {
+            res = cum + 1;
+            break;
+        }
+        cum += w;
+    }
+
+    if res == 0 {
+        res = cum + 1;
+    }
+
+    println!("{}", res);
+}

storage/jungol/rs/completed/5242.rs

@@ -0,0 +1,12 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let (l, r) = (iter.next().unwrap(), iter.next().unwrap());
+
+    println!("{}", if l | r == 1 { "True" } else { "False" });
+}

storage/jungol/rs/completed/8406.rs

@@ -0,0 +1,63 @@
+use std::io::{read_to_string, stdin};
+
+struct ReligionState {
+    parents: Vec<usize>,
+    counts: Vec<usize>,
+}
+
+impl ReligionState {
+    fn find(&self, x: usize) -> usize {
+        let mut node = x;
+        while (node != self.parents[node]) {
+            node = self.parents[node];
+        }
+        return node;
+    }
+
+    fn sames(&self, x: usize) -> usize {
+        return self.counts[self.find(x)];
+    }
+
+    fn unite(&mut self, x: usize, y: usize) {
+        let rx = self.find(x);
+        let ry = self.find(y);
+
+        if rx < ry {
+            self.parents[ry] = rx;
+            self.counts[rx] += self.counts[ry];
+        } else if rx > ry {
+            self.parents[rx] = ry;
+            self.counts[ry] += self.counts[rx]
+        } else {
+        }
+    }
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let q = iter.next().unwrap();
+
+    let mut parents = (0..n).map(|i| i).collect::<Vec<_>>();
+
+    let mut S = ReligionState {
+        parents,
+        counts: (0..n).map(|_| 1).collect(),
+    };
+
+    for _ in 0..q {
+        let query = iter.next().unwrap();
+        if (query == 1) {
+            let (x, y) = (iter.next().unwrap() - 1, iter.next().unwrap() - 1);
+
+            S.unite(x, y);
+        } else {
+            let x = iter.next().unwrap() - 1;
+            println!("{}", S.sames(x));
+        }
+    }
+}

storage/jungol/rs/completed/8566.rs

@@ -0,0 +1,38 @@
+use std::{
+    cmp::Reverse,
+    collections::BinaryHeap,
+    io::{read_to_string, stdin},
+};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let (n, p) = (iter.next().unwrap(), iter.next().unwrap());
+
+    let defs = (0..n).map(|_| iter.next().unwrap()).collect::<Vec<_>>();
+
+    let mut heap = BinaryHeap::new();
+    let mut total = 0;
+    let mut res = Vec::new();
+
+    for &d in defs.iter() {
+        heap.push(Reverse(d));
+        total += d;
+
+        while heap.len() > 0 && total - heap.peek().unwrap().0 >= p {
+            total -= heap.peek().unwrap().0;
+            heap.pop();
+        }
+        if total >= p {
+            res.push(heap.len() as isize);
+        } else {
+            res.push(-1);
+        }
+    }
+
+    res.iter().for_each(|x| print!("{} ", x));
+    println!();
+}

templates/template.cpp

@@ -1,17 +1,24 @@
 #include <iostream>
 #include <algorithm>
 #include <vector>
+#include <queue>
 
 #define let auto
 #define fn auto
-#define usize size_t
 using namespace std;
 
+typedef size_t usize;
+typedef ssize_t isize;
+typedef int32_t i32;
+typedef u_int32_t u32;
+typedef int64_t i64;
+typedef u_int64_t u64;
+
 fn fastio() {
     ios::sync_with_stdio(false);
     cin.tie(nullptr);
 }
 
 fn main() -> int {
-
+    fastio();
 }