boolpurist/jump_game_challenge_solution
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Improved runtime by about 45 ms for leetcode submission

Browse source 
Adjusted start interval from all jumps steps to only jumps height
which exceed the greatest vested index.
This adjustment also removed one addition statement
This commit is contained in:
boolpurist 2024-08-06 13:23:45 +02:00
parent 4b3ff681fe
commit 36ecf4affa
1 changed files with 48 additions and 13 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
src/lib.rs
View file

@ -1,8 +1,8 @@
pub struct Solution; pub struct Solution;
// Copy from here for submitting this solution to leet code // Copy from here for submitting this solution to leet code
use std::collections::VecDeque; use std::collections::VecDeque;
impl Solution { impl Solution {
pub fn can_jump(nums: Vec<i32>) -> bool { pub fn can_jump(nums: Vec<i32>) -> bool {
Solution::idiom_can_jump(&nums) Solution::idiom_can_jump(&nums)
@ -35,7 +35,7 @@ impl Solution {
// Using a dequeue ensures that every index is visited // Using a dequeue ensures that every index is visited
let mut next_nodes = VecDeque::from([(0, nums[0])]); let mut next_nodes = VecDeque::from([(0, nums[0])]);
// index visited yet // index visited yet
let mut greatest_visted_indices = -1; let mut greatest_visited_indices = -1;
if Self::check_with_target_value(target_val, 0) { if Self::check_with_target_value(target_val, 0) {
return true; return true;
} }
@ -45,18 +45,18 @@ impl Solution {
if Self::check_with_target_value(target_val, max_jump_height) { if Self::check_with_target_value(target_val, max_jump_height) {
return true; return true;
} }
// It can start at 1 because the every index was checked in previous path walking // Going left to right and using a dequeue for FIFO access,
for next_to_check in 1..=steps { // all indices are visited
let to_add = index + next_to_check; let start_point = greatest_visited_indices + 1;
// Going left to right and using a dequeue // It can start at greatest_visited_indices + 1 because the every index was checked
// for subsequent path walking ensures that // in previous iterations.
// every index before to_add was visited. // If the max_jump_height is lower than the start_point
if greatest_visted_indices >= to_add { // then there is not new index to be discovered
// already visited this index for to_add in start_point..=max_jump_height {
continue; if to_add > greatest_visited_indices {
next_nodes.push_back((to_add, nums[to_add as usize]));
greatest_visited_indices = to_add;
} }
greatest_visted_indices = to_add;
next_nodes.push_front((to_add, nums[to_add as usize]));
} }
} }
false false
@ -124,6 +124,41 @@ mod testing {
let expected = true; let expected = true;
assert_case(given, expected); assert_case(given, expected);
} }
#[test]
// Taken from a failed submission
fn very_complex_cant_jump_complex_array() {
let given = vec![
3, 6, 2, 7, 1, 2, 8, 5, 7, 8, 3, 6, 4, 4, 3, 7, 5, 8, 4, 4, 5, 5, 4, 7, 8, 7, 8, 1, 2,
4, 8, 1, 6, 3, 6, 5, 3, 4, 6, 1, 1, 4, 7, 6, 1, 7, 7, 4, 8, 1, 1, 3, 3, 1, 7, 3, 4, 6,
2, 5, 8, 4, 1, 8, 4, 6, 4, 7, 5, 5, 6, 2, 2, 5, 2, 7, 5, 1, 7, 5, 8, 1, 1, 6, 4, 6, 8,
3, 7, 1, 1, 8, 2, 1, 3, 2, 5, 5, 5, 4, 7, 4, 5, 5, 7, 1, 7, 6, 6, 6, 6, 5, 1, 4, 5, 5,
2, 3, 7, 5, 8, 4, 2, 8, 3, 5, 7, 2, 1, 1, 3, 2, 8, 2, 2, 6, 2, 5, 7, 2, 3, 8, 1, 7, 7,
3, 2, 4, 6, 6, 5, 1, 5, 7, 2, 1, 6, 4, 4, 5, 3, 4, 8, 2, 7, 4, 2, 1, 2, 1, 4, 8, 2, 3,
7, 2, 1, 6, 5, 8, 8, 6, 6, 4, 5, 4, 4, 5, 1, 6, 5, 2, 3, 5, 6, 4, 6, 7, 4, 8, 4, 6, 4,
7, 5, 8, 6, 4, 3, 7, 4, 2, 3, 4, 8, 2, 1, 2, 5, 1, 8, 4, 6, 7, 4, 1, 1, 8, 8, 7, 7, 7,
3, 1, 2, 7, 2, 4, 5, 8, 5, 8, 2, 8, 3, 3, 6, 5, 5, 6, 3, 2, 5, 8, 5, 4, 6, 2, 5, 8, 7,
8, 7, 8, 6, 5, 6, 1, 3, 3, 4, 4, 6, 4, 5, 5, 5, 8, 5, 4, 4, 1, 5, 2, 8, 8, 7, 3, 7, 3,
7, 2, 4, 5, 2, 6, 2, 6, 5, 8, 4, 3, 4, 7, 4, 8, 8, 4, 3, 4, 7, 5, 5, 1, 3, 7, 5, 1, 8,
4, 4, 2, 7, 5, 3, 1, 5, 8, 7, 3, 3, 6, 1, 1, 7, 1, 3, 8, 7, 1, 2, 4, 3, 5, 2, 2, 5, 1,
6, 8, 2, 4, 8, 8, 4, 4, 3, 1, 2, 6, 2, 1, 1, 8, 1, 8, 8, 1, 5, 4, 1, 8, 1, 1, 2, 7, 8,
5, 6, 6, 5, 8, 5, 8, 1, 5, 5, 6, 5, 5, 3, 2, 3, 8, 4, 7, 5, 7, 4, 6, 5, 2, 7, 7, 8, 1,
7, 2, 4, 6, 5, 1, 3, 1, 8, 1, 5, 2, 2, 6, 6, 6, 1, 4, 8, 4, 1, 3, 7, 1, 1, 1, 7, 4, 5,
5, 6, 4, 5, 3, 5, 3, 5, 2, 7, 4, 3, 1, 4, 1, 7, 7, 6, 4, 3, 4, 2, 4, 2, 7, 3, 4, 1, 8,
8, 6, 7, 2, 3, 2, 5, 6, 5, 6, 5, 1, 2, 1, 6, 2, 1, 4, 2, 2, 6, 6, 7, 1, 2, 6, 2, 4, 2,
4, 1, 6, 7, 5, 5, 4, 5, 4, 4, 2, 4, 8, 6, 8, 1, 6, 3, 7, 7, 8, 4, 2, 8, 1, 2, 1, 7, 8,
4, 7, 2, 8, 6, 8, 3, 4, 3, 8, 8, 7, 3, 2, 4, 4, 1, 4, 6, 4, 6, 6, 7, 7, 4, 5, 8, 3, 8,
3, 6, 8, 8, 1, 1, 7, 1, 2, 2, 7, 8, 1, 6, 7, 6, 3, 8, 6, 5, 5, 2, 2, 8, 5, 1, 6, 5, 3,
6, 4, 2, 8, 5, 3, 1, 3, 4, 4, 1, 5, 2, 4, 8, 3, 7, 4, 1, 4, 7, 8, 4, 1, 3, 8, 3, 7, 4,
1, 1, 4, 3, 3, 2, 6, 6, 2, 8, 8, 6, 5, 4, 4, 6, 1, 8, 5, 5, 8, 3, 8, 1, 5, 6, 4, 1, 1,
6, 3, 8, 8, 7, 1, 6, 5, 5, 7, 4, 8, 7, 2, 6, 6, 8, 4, 4, 7, 2, 1, 7, 3, 5, 8, 8, 6, 2,
2, 5, 1, 3, 7, 7, 3, 4, 8, 5, 3, 7, 3, 3, 4, 2, 1, 4, 2, 6, 1, 1, 4, 7, 6, 8, 2, 3, 5,
3, 2, 2, 7, 1, 2, 1, 4, 2, 4, 8, 5, 2, 3, 7, 2, 4, 3, 6, 3, 8, 5, 7, 3, 7, 5, 3, 4, 3,
8, 7, 4, 4, 7, 3, 2, 1, 1, 1, 1, 3, 1, 6, 3, 6, 4, 3, 2, 1, 1, 1, 6, 5, 2, 2, 5, 5, 6,
6, 1, 8, 7, 8, 7, 6, 2, 2, 3, 5, 6, 1, 0, 0, 0, 0, 0, 0, 0, 0,
];
let expected = false;
assert_case(given, expected);
}
fn assert_case(given: Vec<i32>, expected: bool) { fn assert_case(given: Vec<i32>, expected: bool) {
let actual = Solution::idiom_can_jump(&given); let actual = Solution::idiom_can_jump(&given);