g1501_1600.s1575_count_all_possible_routes.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g1501_1600.s1575_count_all_possible_routes;

// #Hard #Array #Dynamic_Programming #Memoization
// #2022_04_11_Time_111_ms_(72.26%)_Space_44.6_MB_(64.16%)

/**
 * 1575 - Count All Possible Routes\.
 *
 * Hard
 *
 * You are given an array of **distinct** positive integers locations where `locations[i]` represents the position of city `i`. You are also given integers `start`, `finish` and `fuel` representing the starting city, ending city, and the initial amount of fuel you have, respectively.
 *
 * At each step, if you are at city `i`, you can pick any city `j` such that `j != i` and `0 <= j < locations.length` and move to city `j`. Moving from city `i` to city `j` reduces the amount of fuel you have by `|locations[i] - locations[j]|`. Please notice that `|x|` denotes the absolute value of `x`.
 *
 * Notice that `fuel` **cannot** become negative at any point in time, and that you are **allowed** to visit any city more than once (including `start` and `finish`).
 *
 * Return _the count of all possible routes from_ `start` _to_ `finish`. Since the answer may be too large, return it modulo 10⁹ + 7.
 *
 * **Example 1:**
 *
 * **Input:** locations = [2,3,6,8,4], start = 1, finish = 3, fuel = 5
 *
 * **Output:** 4
 *
 * **Explanation:** The following are all possible routes, each uses 5 units of fuel:
 *
 * 1 -> 3
 *
 * 1 -> 2 -> 3
 *
 * 1 -> 4 -> 3
 *
 * 1 -> 4 -> 2 -> 3
 *
 * **Example 2:**
 *
 * **Input:** locations = [4,3,1], start = 1, finish = 0, fuel = 6
 *
 * **Output:** 5
 *
 * **Explanation:** The following are all possible routes:
 *
 * 1 -> 0, used fuel = 1
 *
 * 1 -> 2 -> 0, used fuel = 5
 *
 * 1 -> 2 -> 1 -> 0, used fuel = 5
 *
 * 1 -> 0 -> 1 -> 0, used fuel = 3
 *
 * 1 -> 0 -> 1 -> 0 -> 1 -> 0, used fuel = 5
 *
 * **Example 3:**
 *
 * **Input:** locations = [5,2,1], start = 0, finish = 2, fuel = 3
 *
 * **Output:** 0
 *
 * **Explanation:** It is impossible to get from 0 to 2 using only 3 units of fuel since the shortest route needs 4 units of fuel.
 *
 * **Constraints:**
 *
 * *   `2 <= locations.length <= 100`
 * *   1 <= locations[i] <= 10⁹
 * *   All integers in `locations` are **distinct**.
 * *   `0 <= start, finish < locations.length`
 * *   `1 <= fuel <= 200`
**/
public class Solution {
    private static final int MOD = 1000000007;
    private Integer[][] cache;

    public int countRoutes(int[] locations, int start, int finish, int fuel) {
        this.cache = new Integer[locations.length][fuel + 1];
        return dfs(locations, start, finish, fuel);
    }

    private int dfs(int[] locations, int start, int finish, int fuel) {
        if (this.cache[start][fuel] == null) {
            int count = 0;
            if (start == finish) {
                count = (count + 1) % MOD;
            }
            for (int i = 0; i < locations.length; i++) {
                if (i != start && Math.abs(locations[start] - locations[i]) <= fuel) {
                    count =
                            count
                                    + dfs(
                                            locations,
                                            i,
                                            finish,
                                            fuel - Math.abs(locations[start] - locations[i]));
                    count = count % MOD;
                }
            }
            this.cache[start][fuel] = count;
        }
        return this.cache[start][fuel];
    }
}