Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 1bf271c

Browse files
committed
Add solutions
1 parent fa5f23b commit 1bf271c

File tree

11 files changed

+380
-0
lines changed

11 files changed

+380
-0
lines changed

‎src/leetcode/interview/mod.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,3 @@
11
mod amazon;
22
mod robinhood;
3+
mod uber;

‎src/leetcode/interview/uber/mod.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
automod::dir!("src/leetcode/interview/uber");
Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
1+
use std::collections::{HashMap, HashSet, VecDeque};
2+
3+
// 815. Bus Routes, Hard
4+
// https://leetcode.com/problems/bus-routes/
5+
impl Solution {
6+
pub fn num_buses_to_destination(routes: Vec<Vec<i32>>, source: i32, target: i32) -> i32 {
7+
let mut hm: HashMap<i32, Vec<(i32, i32)>> = HashMap::new();
8+
9+
for (bus, route) in routes.iter().enumerate() {
10+
let bus = bus as i32;
11+
12+
let mut route = route.clone();
13+
route.push(route[0]);
14+
15+
for j in 0..route.len() - 1 {
16+
let j = j as i32;
17+
hm.entry(route[j as usize])
18+
.and_modify(|f| f.push((route[j as usize + 1], bus)))
19+
.or_insert(vec![(route[j as usize + 1], bus)]);
20+
}
21+
}
22+
23+
let mut queue: VecDeque<(i32, HashSet<i32>)> = VecDeque::new();
24+
queue.push_back((source, HashSet::<i32>::new()));
25+
26+
let mut seen: HashSet<i32> = HashSet::new();
27+
28+
let mut min_busses = usize::MAX;
29+
30+
while !queue.is_empty() {
31+
let (stop, busses) = queue.pop_front().unwrap();
32+
33+
if stop == target {
34+
min_busses = min_busses.min(busses.len());
35+
}
36+
37+
seen.insert(stop);
38+
39+
for edge in hm.get(&stop).unwrap_or(&vec![]) {
40+
if seen.contains(&edge.0) {
41+
continue;
42+
}
43+
44+
let mut busses = busses.clone();
45+
busses.insert(edge.1);
46+
queue.push_back((edge.0, busses));
47+
}
48+
}
49+
50+
min_busses as i32
51+
}
52+
}
53+
54+
struct Solution {}
55+
56+
#[cfg(test)]
57+
mod tests {
58+
use super::*;
59+
use crate::vec_vec_i32;
60+
61+
#[test]
62+
fn test_num_buses_to_destination() {
63+
assert_eq!(Solution::num_buses_to_destination(vec_vec_i32![[1, 2, 7], [3, 6, 7]], 1, 6), 2);
64+
}
65+
66+
#[test]
67+
fn test_num_buses_to_destination2() {
68+
assert_eq!(
69+
Solution::num_buses_to_destination(vec_vec_i32![[7, 12], [4, 5, 15], [6], [15, 19], [9, 12, 13]], 15, 12),
70+
-1
71+
);
72+
}
73+
}

‎src/leetcode/problem/can_construct.rs

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
use std::collections::HashMap;
2+
3+
// 1400. Construct K Palindrome Strings, Medium
4+
// https://leetcode.com/problems/construct-k-palindrome-strings/
5+
impl Solution {
6+
pub fn can_construct(s: String, k: i32) -> bool {
7+
let mut counter: HashMap<char, i32> = HashMap::new();
8+
9+
let n = s.len() as i32;
10+
for ch in s.chars() {
11+
counter.entry(ch).and_modify(|c| *c += 1).or_insert(1);
12+
}
13+
14+
let mut odds = 0;
15+
16+
for (_k, v) in counter {
17+
if v % 2 != 0 {
18+
odds += 1;
19+
}
20+
}
21+
22+
return n >= k && odds <= k;
23+
}
24+
}
25+
26+
struct Solution {}
Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
// 986. Interval List Intersections, Medium
2+
// https://leetcode.com/problems/interval-list-intersections/
3+
impl Solution {
4+
pub fn interval_intersection(first_list: Vec<Vec<i32>>, second_list: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
5+
let mut ans: Vec<Vec<i32>> = vec![];
6+
7+
let (mut i, mut j) = (0, 0);
8+
9+
while i < first_list.len() && j < second_list.len() {
10+
let start = i32::max(first_list[i][0], second_list[j][0]);
11+
let end = i32::min(first_list[i][1], second_list[j][1]);
12+
13+
if start <= end {
14+
ans.push(vec![start, end]);
15+
}
16+
17+
if first_list[i][1] < second_list[j][1] {
18+
i += 1;
19+
} else {
20+
j += 1;
21+
}
22+
}
23+
24+
ans
25+
}
26+
}
27+
28+
struct Solution {}

‎src/leetcode/problem/is_cousins.rs

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
#[derive(Debug, PartialEq, Eq)]
2+
pub struct TreeNode {
3+
pub val: i32,
4+
pub left: Option<Rc<RefCell<TreeNode>>>,
5+
pub right: Option<Rc<RefCell<TreeNode>>>,
6+
}
7+
8+
impl TreeNode {
9+
#[inline]
10+
pub fn new(val: i32) -> Self {
11+
TreeNode { val, left: None, right: None }
12+
}
13+
}
14+
15+
use std::cell::RefCell;
16+
use std::rc::Rc;
17+
18+
// 993. Cousins in Binary Tree, Easy
19+
// https://leetcode.com/problems/cousins-in-binary-tree/
20+
impl Solution {
21+
pub fn is_cousins(root: Option<Rc<RefCell<TreeNode>>>, x: i32, y: i32) -> bool {
22+
let mut found: Vec<(i32, i32)> = vec![]; // (parent, level)
23+
24+
fn bfs(node: Option<Rc<RefCell<TreeNode>>>, x: &i32, y: &i32, parent: i32, level: i32, found: &mut Vec<(i32, i32)>) {
25+
if node.is_some() {
26+
let node = node.as_ref().unwrap().borrow();
27+
28+
if found.len() == 2 {
29+
return;
30+
}
31+
32+
if node.val == *x || node.val == *y {
33+
found.push((parent, level));
34+
return;
35+
}
36+
37+
bfs(node.left.clone(), &x, &y, node.val, level + 1, found);
38+
bfs(node.right.clone(), &x, &y, node.val, level + 1, found);
39+
}
40+
}
41+
42+
bfs(root, &x, &y, -1, 0, &mut found);
43+
44+
found.len() == 2 && found[0].0 != found[1].0 && found[0].1 == found[1].1
45+
}
46+
}
47+
48+
struct Solution {}

‎src/leetcode/problem/min_transfers.rs

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
use std::collections::HashMap;
2+
3+
// 465. Optimal Account Balancing, Hard
4+
// https://leetcode.com/problems/optimal-account-balancing/
5+
impl Solution {
6+
pub fn min_transfers(transactions: Vec<Vec<i32>>) -> i32 {
7+
let mut hm = HashMap::new();
8+
9+
for transaction in transactions.iter() {
10+
let (from, to, amount) = (transaction[0], transaction[1], transaction[2]);
11+
hm.entry(from).and_modify(|d| *d -= amount).or_insert(-amount);
12+
hm.entry(to).and_modify(|d| *d += amount).or_insert(amount);
13+
}
14+
15+
let mut debts = vec![];
16+
for v in hm.values() {
17+
debts.push(*v);
18+
}
19+
20+
fn dfs(debts: &mut Vec<i32>, mut i: usize) -> i32 {
21+
while i < debts.len() && debts[i] == 0 {
22+
i += 1;
23+
}
24+
25+
let mut ans = i32::MAX;
26+
let mut prev = 0;
27+
for j in i + 1..debts.len() {
28+
if debts[j] != prev && debts[j] * debts[i] < 0 {
29+
debts[j] += debts[i];
30+
ans = i32::min(ans, 1 + dfs(debts, i + 1));
31+
debts[j] -= debts[i];
32+
prev = debts[j];
33+
}
34+
}
35+
36+
if ans < i32::MAX {
37+
ans
38+
} else {
39+
0
40+
}
41+
}
42+
43+
dfs(&mut debts, 0)
44+
}
45+
}
46+
47+
struct Solution {}
Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,68 @@
1+
use std::collections::{HashMap, VecDeque};
2+
3+
// 496. Next Greater Element I, Easy
4+
// https://leetcode.com/problems/next-greater-element-i/
5+
impl Solution {
6+
pub fn next_greater_element(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
7+
let mut queue = VecDeque::new();
8+
let mut nums2_next_bigger = HashMap::new();
9+
10+
for (i, curr_num) in nums2.iter().enumerate() {
11+
while queue.len() > 0 && *queue.back().unwrap() < curr_num {
12+
let num = queue.pop_back().unwrap();
13+
nums2_next_bigger.insert(num, *curr_num);
14+
}
15+
queue.push_back(curr_num);
16+
}
17+
18+
queue.iter().for_each(|k| {
19+
nums2_next_bigger.insert(*k, -1);
20+
});
21+
22+
let mut ans = vec![];
23+
24+
'outer: for i in 0..nums1.len() {
25+
for j in 0..nums2.len() {
26+
if nums1[i] == nums2[j] {
27+
ans.push(*nums2_next_bigger.get(&nums2[j]).unwrap());
28+
continue 'outer;
29+
}
30+
}
31+
}
32+
33+
ans
34+
}
35+
36+
pub fn next_greater_element_slow(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
37+
let mut ans = vec![];
38+
39+
'outer: for i in 0..nums1.len() {
40+
let mut found = -1;
41+
let mut found_i = -1;
42+
43+
for j in i + 1..nums2.len() {
44+
if nums1[i] == nums2[j] {
45+
found = nums2[j];
46+
found_i = j as i32;
47+
break;
48+
}
49+
}
50+
51+
if found_i != -1 {
52+
let found_i = found_i as usize;
53+
for i in found_i + 1..nums2.len() {
54+
if found < nums2[i] {
55+
ans.push(nums2[i]);
56+
continue 'outer;
57+
}
58+
}
59+
}
60+
61+
ans.push(-1);
62+
}
63+
64+
ans
65+
}
66+
}
67+
68+
struct Solution {}
Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
// 764. Largest Plus Sign, Medium
2+
// https://leetcode.com/problems/largest-plus-sign/
3+
impl Solution {
4+
pub fn order_of_largest_plus_sign(n: i32, mines: Vec<Vec<i32>>) -> i32 {
5+
let n = n as usize;
6+
let mut grid = vec![vec![0; n]; n];
7+
8+
for mine in mines.iter() {
9+
grid[mine[0] as usize][mine[1] as usize] = 1;
10+
}
11+
12+
let mut prefix_sum_grid = vec![vec![i32::MAX; n]; n];
13+
14+
for i in 0..n {
15+
let mut sum_right = 0;
16+
let mut sum_left = 0;
17+
let mut sum_down = 0;
18+
let mut sum_up = 0;
19+
20+
for j in 0..n {
21+
sum_right += grid[i][j];
22+
prefix_sum_grid[i][j] += i32::min(prefix_sum_grid[i][j], sum_right);
23+
24+
sum_left += grid[i][n - j - 1];
25+
prefix_sum_grid[i][n - j - 1] += i32::min(prefix_sum_grid[i][n - j - 1], sum_left);
26+
27+
sum_down += grid[j][i];
28+
prefix_sum_grid[j][i] += i32::min(prefix_sum_grid[j][i], sum_down);
29+
30+
sum_up += grid[n - j - 1][i];
31+
prefix_sum_grid[n - j - 1][i] += i32::min(prefix_sum_grid[n - j - 1][i], sum_up);
32+
}
33+
}
34+
35+
let mut ans = 0;
36+
for i in 0..n {
37+
for j in 0..n {
38+
ans = i32::max(ans, prefix_sum_grid[i][j]);
39+
}
40+
}
41+
42+
ans
43+
}
44+
}
45+
46+
struct Solution {}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /