Find the index in the circle such that a traveler can completes one round

Question

I appeared in an interview. I stuck in one question. I am asking the same.

Question: There is circular road is given. That road contains number of petrol pumps. Each petrol pump have given amount of petrol. Distance between each two consecutive petrol pump is also given. Now there is a vehicle is given having empty fuel tank of limitless capacity. Build an algorithm so that vehicle can cover complete round without any backtracking. It is given that such path is definitely possible.

Input: (int fuel[], int distance[])

Output: petrol pump index from where vehicle can make complete round of circular road.

My approaches:

1. Check from each petrol pump, if fuel tank is empty in between path, move to next petrol pump. and start the same process again. This algorithm takes O(N^2), here N = number of petrol pumps.

2. Then I move to the Binary search concept, to reduce the complexity to O(n*logn). But I failed to conclude the solution. I messed up in this solution.

3. Then I try to apply some intelligence, by choosing that petrol pump whose left petrol is maximum in between that two petrol pumps.

Answer 1

(This may be equivalent to the algorithm Evgeny Kluev posted, which I don't understand. If so, that answer has priority.)

Let F_i_j be the net, signed amount of fuel in the tank on arriving at j having started at i with zero fuel in the tank before filling at i.

Calculate F_0_i for every node i by working around the circle adding fuel at each node and subtracting the fuel cost of each edge.

If F_0_0, the net fuel at the end of a circuit starting at 0, is negative, then there is not enough fuel in the system (this is not supposed to happen according to the problem statement).

If no F_0_i is negative, report 0 as result.

Otherwise, find the node s with the most negative value of F_0_s. Pick s as the starting node.

For any node i, F_s_i is equal to F_0_i + abs(F_0_s). Since F_0_s is the most negative F_0_i, that makes F_s_i non-negative.

Worked example, as suggested in a comment by Handcraftsman:
Label nodes 0 through 4

node: 0,1,2,3,4
fuel: 1,3,4,4,1
dist: 1,4,2,2,2


First calculate F_0_i for i = 1, 2, 3, 4, 0
Start at node 0 with 0 fuel.

f_0_1 = 0 + 1 - 1 = 0, min score 0, node 1;
f_0_2 = 0 + 3 - 4 = -1, min score -1, node 2;
f_0_3 = -1 + 4 - 2 = 1;
f_0_4 = 1 + 4 - 2 = 3;
f_0_0 = 3 + 1 - 2 = 2;

f_0_0 is non-negative, so there is enough fuel.

The minimum score was -1, at node 2, so the result is node 2.

Answer 2

The bruteforce solution should be obvious. Start from every i, and check to see if every point is reachable with the gas available. Return the first i for which you can complete the trip without the gas reaching a negative number. This approach would however be quadratic. Lets look at how we can improve.

We can take greedy approach here.

1 If sum of gas is more than sum of cost, it imply that there wont be any solution. We can discard the point from which we started

2 Lets say you start at i, and hit first negative of sum(gas) - sum(cost) at j. We know TotalSum(gas) - TotalSum(cost) > 0. So we can discard i to j and start from j + 1.

Java code of above algo

        public int canCompleteCircuit(final List<Integer> gas, final List<Integer> cost) {
            int start = 0;
            int totalGas = 0;
            int totalCost = 0;
            int currentCost = 0;
            for (int i = 0; i < gas.size(); i++) {
                totalCost += cost.get(i);
                totalGas += gas.get(i);
                currentCost += gas.get(i) - cost.get(i);
                if (currentCost <0){
                    start = i + 1;
                    currentCost = 0;
                }
            }

            if (totalCost > totalGas){
                return -1;
            }

            return start;

        }

Answer 3

I couldn't solve the problem without first understanding, when it is possible to find a correct course.

D - sum of all the distances P - sum of all the fuel pumps

1. If P < D the problem is insolvable
2. If P = D it always has a solution, proof below
3. If P > D we can reduce some pumps and apply the solution as if P = D.

So we assume that P = D, that is we have exactly the amount of fuel needed to complete the course. Let's draw a chart, amount of fuel in tank as a function of time. If the tanking time is equal to 0, it is not a real function, but it's not important. We start anywhere and have some fuel in tank.

An example for pumps 1, 4, 3 and distances 2, 5, 1:

   |\       
   | \      
|\ |  \  |\ 
  \|   \ |  
        \|  

Notice things:

1. We may travel infinitely around and the chart will be repeated the same. We'll be back in the starting place with the same amount of fuel which we started with.
2. There will always be one point with the lowest fuel amount and it will be always the same station (if there are several minimal stations, it doesn't change anything)
3. If we start in a different place, the minimal point will always fall in the same station.

Based on the above we start in a minimal pump and assign 0 level to it. That is the proof that our fuel will never go below 0, that is we will be able to continue around and around and around...

Now we see that Evgeny's solution is correct, although calculation of S and S/N is unnecessary. We only need to add the pump value and subtract the distance, in Evgeny's algorithm it was V. So the optimal starting station is the one at which we arrive with minimal fuel contents.

It took me much time too understand why does Evgeny start in arbitrary direction. Why is he sure that the solution exists in the direction he took and not in the opposite? But when we know that P = D is a sufficient condition to complete the course, we also know that the direction is not important. We should pick a different station as a starting point in the opposite direction, but we can do it in both directions.

Nithis, how much time were you given? Could you say what was the company name? :) I think it was quite a difficult task, at least for a guy not familiar with similar circular problems.

Answer 4

This is a condition of recursion.First you check if you have fuel left for the last stretch. If the fuel needed is x and the fuel in the pump n is y.If x>y then we need to have (x-y)+the fuel needed for the stretch between pumps n,n-1 else only the fuel required for the last but one stretch is need from the pump n-1.This continues till you reach pump 1.

Answer 5

 public static void main(String[] args) {

  int petrol[] = { 1, 3, 4, 4, 1 };
  int distance[] = { 1, 4, 2, 2, 2 };

  petrol = new int[] { 4, 6, 7, 4 };
  distance = new int[] { 6, 5, 3, 5 };
  List<PetrolPump> petrolPumps = PetrolPump.getAll(petrol, distance);

  int start = 0;
  int end = petrol.length;

  int remainingPetrol = 0;

  do {
     remainingPetrol += petrolPumps.get(start).petrol - petrolPumps.get(start).distance;

     if (remainingPetrol < 0) {
        remainingPetrol = 0;
        end = start;
     }

     start++;
     if (start >= petrol.length) {
        start = 0;
     }
  } while (start != end);

  System.out.println(end + 1);

}

static class PetrolPump {
  int petrol;
  int distance;

  PetrolPump(int petrol, int distance) {
     this.petrol = petrol;
     this.distance = distance;
  }

  static List<PetrolPump> getAll(int[] petrol, int[] distance) {
     List<PetrolPump> petrolPumps = new ArrayList<PetrolPump>(distance.length);

     for (int i = 0; i < distance.length; i++) {
        petrolPumps.add(new PetrolPump(petrol[i], distance[i]));
     }

     return petrolPumps;
  }
}