Skip to content

Commit 99c3870

Browse files
MaskRayMaskRay
committed
misc
1 parent 6c1def0 commit 99c3870

7 files changed

+181
-57
lines changed

‎checking-existence-of-edge-length-limited-paths.rs

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
// Checking Existence of Edge Length Limited Paths
2+
impl Solution {
3+
pub fn distance_limited_paths_exist(n: i32, mut es: Vec<Vec<i32>>, qs: Vec<Vec<i32>>) -> Vec<bool> {
4+
fn find(uf: &mut Vec<usize>, mut x: usize) -> usize {
5+
while uf[x] != x {
6+
uf[x] = uf[uf[x]];
7+
x = uf[x];
8+
}
9+
x
10+
}
11+
es.sort_unstable_by_key(|e| e[2]);
12+
let mut pi: Vec<usize> = (0..qs.len()).collect();
13+
pi.sort_unstable_by_key(|&i| qs[i][2]);
14+
let mut uf: Vec<usize> = (0..n as usize).collect();
15+
let mut ans = vec![false; qs.len()];
16+
let mut j = 0;
17+
for i in pi {
18+
while j < es.len() && es[j][2] < qs[i][2] {
19+
let u = find(&mut uf, es[j][0] as usize);
20+
let v = find(&mut uf, es[j][1] as usize);
21+
uf[u] = v;
22+
j += 1;
23+
}
24+
ans[i] = find(&mut uf, qs[i][0] as usize) == find(&mut uf, qs[i][1] as usize);
25+
}
26+
ans
27+
}
28+
}

‎closest-room.rs

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
// Closest Room
2+
impl Solution {
3+
pub fn closest_room(mut rooms: Vec<Vec<i32>>, queries: Vec<Vec<i32>>) -> Vec<i32> {
4+
use std::collections::BTreeSet;
5+
rooms.sort_unstable_by_key(|r| -r[1]);
6+
let mut queries: Vec<_> = queries.into_iter().enumerate().collect();
7+
queries.sort_unstable_by_key(|(_,q)| -q[1]);
8+
let mut tree = BTreeSet::new();
9+
let mut ret = vec![-1; queries.len()];
10+
let mut j = 0;
11+
for (i, q) in queries {
12+
while j < rooms.len() && rooms[j][1] >= q[1] {
13+
tree.insert(rooms[j][0]);
14+
j += 1;
15+
}
16+
if tree.is_empty() { continue; }
17+
if let Some(&x) = tree.range(..q[0]).next_back() {
18+
ret[i] = x;
19+
}
20+
if let Some(&x) = tree.range(q[0]..).next() {
21+
if ret[i] == -1 || q[0]-ret[i] > x-q[0] {
22+
ret[i] = x;
23+
}
24+
}
25+
}
26+
ret
27+
}
28+
}

‎maximum-xor-with-an-element-from-array.cc

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
#define ALL(x) (x).begin(), (x).end()
2+
#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
3+
#define REP(i, n) FOR(i, 0, n)
4+
5+
class Solution {
6+
public:
7+
vector<int> maximizeXor(vector<int>& nums, vector<vector<int>>& queries) {
8+
int n = nums.size(), m = queries.size();
9+
REP(i, m) queries[i].push_back(i);
10+
sort(ALL(nums));
11+
sort(ALL(queries), [](auto &l, auto &r) { return l[1] < r[1]; });
12+
vector<int> ans(m), best(m, -1), p0(n), p1(n);
13+
REP(i, n)
14+
p0[i] = i-1;
15+
for (int k = 1<<29; k; k >>= 1) {
16+
REP(i, n)
17+
if (p0[i] == -1)
18+
p1[i] = -1;
19+
else if (((nums[i]^nums[p0[i]]) & k) == 0)
20+
p1[i] = p1[p0[i]];
21+
else
22+
p1[i] = p0[i], p0[i] = p1[p0[i]];
23+
int i = 0;
24+
REP(j, m) {
25+
for (; i < n && nums[i] <= queries[j][1]; i++);
26+
int &b = best[j];
27+
if (b == -1)
28+
b = i-1;
29+
if (~b && ((queries[j][0]^nums[b]) & k) == 0 && ~p1[b])
30+
b = p1[b];
31+
}
32+
}
33+
REP(j, m)
34+
ans[queries[j][2]] = ~best[j] ? queries[j][0] ^ nums[best[j]] : -1;
35+
return ans;
36+
}
37+
};

‎maximum-xor-with-an-element-from-array.rs

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
// Maximum XOR With an Element From Array
2+
impl Solution {
3+
pub fn maximize_xor(mut nums: Vec<i32>, mut queries: Vec<Vec<i32>>) -> Vec<i32> {
4+
use std::usize::MAX;
5+
let n = nums.len();
6+
nums.sort_unstable();
7+
for (i, q) in queries.iter_mut().enumerate() { q.push(i as i32); }
8+
queries.sort_unstable_by_key(|q| q[1]);
9+
let mut ans = Vec::with_capacity(queries.len()); unsafe { ans.set_len(queries.len()); }
10+
let mut best = vec![MAX; queries.len()];
11+
let mut p0: Vec<usize> = (0..n).map(|i| i.wrapping_sub(1)).collect();
12+
let mut p1 = Vec::with_capacity(n); unsafe { p1.set_len(n); }
13+
for kk in (0..30).rev() {
14+
let k = 1 << kk;
15+
for i in 0..n {
16+
if p0[i] == MAX { p1[i] = MAX; }
17+
else if ((nums[i]^nums[p0[i]]) & k) == 0 { p1[i] = p1[p0[i]]; }
18+
else { p1[i] = p0[i]; p0[i] = p1[p0[i]]; }
19+
}
20+
let mut i = 0;
21+
for (q, b) in queries.iter().zip(&mut best) {
22+
while i < n && nums[i] <= q[1] { i += 1; }
23+
if *b == MAX { *b = i.wrapping_sub(1); }
24+
if *b != MAX && ((q[0]^nums[*b]) & k) == 0 && p1[*b] != MAX { *b = p1[*b]; }
25+
}
26+
}
27+
for (q, b) in queries.iter().zip(best) {
28+
ans[q[2] as usize] = if b == MAX { -1 } else { q[0]^nums[b] };
29+
}
30+
ans
31+
}
32+
}

‎minimum-adjacent-swaps-to-reach-the-kth-smallest-number.rs

+5-17
Original file line numberDiff line numberDiff line change
@@ -15,22 +15,10 @@ impl Solution {
1515
for _ in 0..k {
1616
Self::next_permutation(&mut num1);
1717
}
18-
let n = num.len();
19-
let mut a = vec![0; n];
20-
for i in 0..n {
21-
for j in 0..n {
22-
if num[j] == num1[i] {
23-
num[j] = b' ';
24-
a[i] = j;
25-
break;
26-
}
27-
}
28-
}
29-
let mut ans = 0;
30-
for j in 0..n {
31-
for i in 0..j {
32-
if a[i] > a[j] {
33-
ans += 1; } } }
34-
ans
18+
num1.into_iter().map(|x| {
19+
let j = num.iter().position(|&y| x == y).unwrap();
20+
num.remove(j);
21+
j as i32
22+
}).sum()
3523
}
3624
}

‎minimum-interval-to-include-each-query.rs

+11-16
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ impl Solution {
2929

3030
/// segment tree with range modification but no query
3131
impl Solution {
32-
pub fn min_interval(mut intervals: Vec<Vec<i32>>, queries: Vec<i32>) -> Vec<i32> {
32+
pub fn min_interval(intervals: Vec<Vec<i32>>, queries: Vec<i32>) -> Vec<i32> {
3333
use std::{i32,usize};
3434
let mut sorted = vec![];
3535
for itv in intervals.iter() {
@@ -39,17 +39,16 @@ impl Solution {
3939
sorted.sort_unstable();
4040
sorted.dedup();
4141
let n = sorted.len();
42-
// partition_point is unstable
42+
// partition_point is stable since 1.52.0
4343
let deflate = |key| -> usize { sorted.binary_search(&key).unwrap_or_else(|i| i) };
4444

4545
let mut seg = vec![i32::MAX; 2*n];
46-
intervals.sort_unstable_by_key(|itv| itv[1]-itv[0]);
4746
for itv in intervals.iter() {
4847
let mut l = deflate(itv[0]) + n-1;
4948
let mut r = deflate(itv[1]+1) + n;
5049
while (l ^ r) != 1 {
51-
if l%2 == 0 && seg[l^1] == i32::MAX { seg[l^1] = itv[1]-itv[0]+1; }
52-
if r%2 != 0 && seg[r^1] == i32::MAX { seg[r^1] = itv[1]-itv[0]+1; }
50+
if l%2 == 0 { seg[l^1] = seg[l^1].min(itv[1]-itv[0]+1); }
51+
if r%2 != 0 { seg[r^1] = seg[r^1].min(itv[1]-itv[0]+1); }
5352
l /= 2;
5453
r /= 2;
5554
}
@@ -58,12 +57,10 @@ impl Solution {
5857
seg[i] = seg[i].min(seg[i/2]);
5958
}
6059

61-
let mut ans = vec![];
62-
for q in queries {
60+
queries.into_iter().map(|q| {
6361
let i = deflate(q+1)-1;
64-
ans.push(if i == usize::MAX || seg[n+i] == i32::MAX { -1 } else { seg[n+i] });
65-
}
66-
ans
62+
if i == usize::MAX || seg[n+i] == i32::MAX { -1 } else { seg[n+i] }
63+
}).collect()
6764
}
6865
}
6966

@@ -79,7 +76,7 @@ impl Solution {
7976
sorted.sort_unstable();
8077
sorted.dedup();
8178
let n = sorted.len();
82-
// partition_point is unstable
79+
// partition_point is stable since 1.52.0
8380
let deflate = |key| -> usize { sorted.binary_search(&key).unwrap_or_else(|i| i) };
8481

8582
let mut uf: Vec<usize> = (0..n).collect();
@@ -103,11 +100,9 @@ impl Solution {
103100
}
104101
}
105102

106-
let mut ans = vec![];
107-
for q in queries {
103+
queries.into_iter().map(|q| {
108104
let i = deflate(q+1)-1;
109-
ans.push(if i == usize::MAX { -1 } else { len[i] });
110-
}
111-
ans
105+
if i == usize::MAX { -1 } else { len[i] }
106+
}).collect()
112107
}
113108
}

‎splitting-a-string-into-descending-consecutive-values.rs

+40-24
Original file line numberDiff line numberDiff line change
@@ -1,31 +1,47 @@
11
impl Solution {
2-
fn next_permutation(a: &mut [u8]) {
3-
for i in (0..a.len()-1).rev() {
4-
if a[i] >= a[i+1] { continue; }
5-
let mut j = a.len()-1;
6-
while a[i] >= a[j] { j -= 1; }
7-
a.swap(i, j);
8-
a[i+1..].reverse();
9-
break;
2+
pub fn split_string(s: String) -> bool {
3+
let s = s.as_bytes();
4+
let mut xx = 0;
5+
for mut i in 0..s.len()-1 {
6+
xx = xx*10 + (s[i]-b'0') as usize;
7+
let mut x = xx;
8+
let mut y = 0;
9+
loop {
10+
i += 1;
11+
if i == s.len() { break; }
12+
y = y*10 + (s[i]-b'0') as usize;
13+
if y >= x { break; }
14+
if y+1 == x && (y != 0 || i+1 == s.len()) {
15+
if i+1 == s.len() { return true; }
16+
x = y;
17+
y = 0;
18+
}
19+
}
1020
}
21+
false
1122
}
12-
pub fn get_min_swaps(num: String, k: i32) -> i32 {
13-
let mut num: Vec<u8> = num.as_bytes().to_vec();
14-
let mut num1 = num.clone();
15-
for _ in 0..k {
16-
Self::next_permutation(&mut num1);
17-
}
18-
let n = num.len();
19-
let mut ans = 0;
20-
for i in 0..n {
21-
for j in 0..n {
22-
if num[j] == num1[i] {
23-
num.remove(j);
24-
ans += j;
25-
break;
26-
}
23+
}
24+
25+
///
26+
27+
impl Solution {
28+
pub fn split_string(s: String) -> bool {
29+
fn dfs(s: &[u8], x: usize) -> bool {
30+
if s.is_empty() { return true; }
31+
let mut y = 0;
32+
for i in 0..s.len() {
33+
y = y*10 + (s[i]-b'0') as usize;
34+
if y >= x { break; }
35+
if y+1 == x && dfs(&s[i+1..], y) { return true; }
2736
}
37+
false
38+
}
39+
let s = s.as_bytes();
40+
let mut x = 0;
41+
for i in 0..s.len()-1 {
42+
x = x*10 + (s[i]-b'0') as usize;
43+
if dfs(&s[i+1..], x) { return true; }
2844
}
29-
ans as i32
45+
false
3046
}
3147
}

0 commit comments

Comments
 (0)