环游世界找到开始的最低点[关闭]

Question

我必须找到像这样开始两个数组的最小索引：

cities= [2,4,5,2] gallons = [4,3,1,3]

这个问题涉及2个部分

在第一部分中，我必须查找是否存在有效的起始城市。在上面的例子中，我不能从第一个位置开始，因为 city(cities[0]) 的第一个位置的值小于加仑的第一个位置的值 (gallons[0] = 4) .所以我必须继续寻找正确的索引才能开始。我可以开始旅行的第一点是索引 1，因为城市 [1] >= 加仑 [1]。此时路径将是：

4-gallons[1] + cities[2] = 4 -3 + 5 = 6
6-gallons[2] + cities[3] = 6 -1 + 2 = 7
7-gallons[3] + cities[0] = 7 -3 + 2 = 6
6-gallons[0] = 6-4 =2

返回值为 1，即我开始旅程的索引。

下一个路径无效，所以在这种情况下我必须返回 -1：

cities= [8,4,1,9] gallons= [10,9,3,5]

在上面的例子中，我从索引 3 开始，因为它是城市大于加仑的第一个位置，所以这种情况下的操作将是这样的：

注意：列表是循环的，因此在这种情况下，下一个城市是城市[0] =8，在下面的示例中：

 9-gallons[3] + cities[2] + cities[0] = 9 -5 + 8 = 12 
12-gallons[0] + cities[1] = 12 -10 + 4 = 6
6-gallons[1] + cities[2] = 6 - 9 + 1

在最后的操作中，6-9 = -3 出于这个原因，我们没有足够的加仑来继续旅程，所以响应为 -1，我们不必继续这个过程。

接下来是从索引 0 开始的另一种情况，因为城市[0] >= 加仑[0]：

cities[3,2,5,4] gallons = [2,3,4,2]

cities[0] - gallons [0] + cities[1] = 3-2+2 = 3
3 - gallons [1] + cities[2] = 3-3+5 = 5
5 - gallons [2] + cities[3] = 5-4+4 = 5
5 - gallons [3] = 5-2 = 3

这种情况下的响应是 0，因为我们从索引 0 开始并且路线是有效的，我的意思是我们总是有足够的加仑继续旅行（我们在总累积城市旅程减去加仑之间没有负面结果可用，与第二种情况的示例相反）。

下一个是我到目前为止的代码，但是我失败了几个测试用例，我做了几个个人测试用例，但我真的不知道为什么我的代码失败了，有什么想法吗？这两个阵列可以有不同的维度。

public static int bestIndexToStartJorney(List<Integer> cities, List<Integer> gallons) {
        int n = 0;
        int starts = -1;
        int total = 0;
        if (cities.size() > 0 && gallons.size() > 0 && (cities.size() == gallons.size())) {
            n = cities.size();
        } else {
            return -1;
        }
        for (int i = 0; i < n; i++) {
            if (cities.get(i) >= gallons.get(i)) {
                //Define a start point
                starts = i;
                break;
            }
        }
        //If we have a valid case.
        if (starts >= 0) {
            total = cities.get(starts);
            for (int i = 0; i < n; i++) {
                //Constraints
                if ((cities.get(i) < 0 || cities.get(i) > 10000) || (gallons.get(i) < 0 || gallons.get(i) > 10000)) {
                    starts = -1;
                    break;
                }
                //Define the current position to transverse circularly
                int position = (i + starts) % n;
                total += -gallons.get(position);
                //If total < gallonsance the path is invalid.
                if (total < 0) {
                    starts = -1;
                    break;
                }
                if (position < n - 1 && position + 1 != starts) {
                    total += cities.get(position + 1);
                } else {
                    if (starts > 0 && position + 1 != starts)
                        total += cities.get(0);
                }
            }
        }
        return starts;
    }

约束：

1<=size <= 100000
0<=cities[i] <= 10000
0<=gallons[i] <= 10000

Answer 1

目前您使用position + 1 计算下一个位置，但是如果没有您之前在循环索引位置本身使用的% n，它不会循环环绕。

因此，for 循环末尾的 if else 语句应该能够被以下使用循环索引的语句替换。

int nextPosition = (position + 1) % n;
if (nextPosition != starts) {
    total += cities.get(nextPosition);
}

这就是我在代码中看到的可能给您带来问题的全部内容，因此如果没有一些失败的测试用例，我无法进一步帮助您。