Problem:
Problem F: Atomic Car Race

In the year 2020, a race of atomically energized cars will be held. Unlike today’s car races, fueling
is not a concern of racing teams. Cars can run throughout the course without any refueling.
Instead, the critical factor is tire (tyre). Teams should carefully plan where to change tires of
their cars.

The race is a road race having n checkpoints in the course. Their distances from the start are a1, a2, ... , and an (in kilometers). The n-th checkpoint is the goal. At the i-th checkpoint (i < n),
tires of a car can be changed. Of course, a team can choose whether to change or not to change
tires at each checkpoint. It takes b seconds to change tires (including overhead for braking and
accelerating). There is no time loss at a checkpoint if a team chooses not to change tires.

A car cannot run fast for a while after a tire change, because the temperature of tires is lower
than the designed optimum. After running long without any tire changes, on the other hand,
a car cannot run fast because worn tires cannot grip the road surface well. The time to run
an interval of one kilometer from x to x + 1 is given by the following expression (in seconds).
Here x is a nonnegative integer denoting the distance (in kilometers) from the latest checkpoint
where tires are changed (or the start). r, v, e and f are given constants.

1/(v - e × (x - r)) (if x ≥ r)
1/(v - f × (r - x)) (if x < r)

Your mission is to write a program to determine the best strategy of tire changes which minimizes
the total time to the goal.

Input

The input consists of multiple datasets each corresponding to a race situation. The format of a
dataset is as follows.

n
a1 a2 . . . an
b
r v e f

The meaning of each of the input items is given in the problem statement. If an input line
contains two or more input items, they are separated by a space.

n is a positive integer not exceeding 100. Each of a1, a2, ... , and an is a positive integer satisfying 0 < a1 < a2 < . . . < an ≤ 10000. b is a positive decimal fraction not exceeding 100.0. r is a
nonnegative integer satisfying 0 ≤ r ≤ an - 1. Each of v, e and f is a positive decimal fraction.
You can assume that v - e × (an - 1 - r) ≥ 0.01 and v - f × r ≥ 0.01.

The end of the input is indicated by a line with a single zero.

Output

For each dataset in the input, one line containing a decimal fraction should be output. The
decimal fraction should give the elapsed time at the goal (in seconds) when the best strategy is
taken. An output line should not contain extra characters such as spaces.

The answer should not have an error greater than 0.001. You may output any number of digits
after the decimal point, provided that the above accuracy condition is satisfied.

Sample Input

2
2 3
1.0
1 1.0 0.1 0.3
5
5 10 15 20 25
0.15
1 1.0 0.04 0.5
10
1783 3640 3991 4623 5465 5481 6369 6533 6865 8425
4.172
72 59.4705 0.0052834 0.0611224
0

Output for the Sample Input

3.5397
31.9249
168.6682

Solution in JAVA (judge verdict: Accepted)

import java.util.*;
 
class Main{
 
    void solve(){
        Scanner sc = new Scanner(System.in);
 
        double INF = Double.MAX_VALUE;
 
        while(true){
            int n = sc.nextInt();
            if(n==0) break;
 
            int[] a = new int[n+1];
            for(int i=1; i<=n; i++) a[i] = sc.nextInt();
            double b = sc.nextDouble();
            int r = sc.nextInt();
            double v = sc.nextDouble(), e = sc.nextDouble(), f = sc.nextDouble();
 
            double[][] times = new double[n+1][n+1];
            for(int i=0; i<=n; i++){
                for(int j=0; j<=n; j++){
                    double time = 0.0;
                    for(int k=0; k+a[i]<a[j]; k++){
                        if(k>=r) time += 1.0/(v - e * (k-r));
                        else time += 1.0/(v - f * (r-k));
                    }
                    times[i][j] = time;
                }
            }
 
            double[][] dp = new double[n+1][n+1];
            for(int i=0; i<=n; i++) Arrays.fill(dp[i], INF);
 
            for(int i=0; i<=n; i++){
                dp[0][i] = times[0][i];
                if(i!=n) dp[1][i] = dp[0][i] + b;
                else dp[1][i] = dp[0][i];
                dp[1][n] = Math.min(dp[1][n], dp[1][i] + times[i][n]);
            }
 
            for(int i=2; i<=n; i++){
                for(int j=0; j<n; j++){
                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j]);
                    for(int l=0; l<=j; l++){
                        if(dp[i-1][l]==INF) continue;
                        dp[i][j] = Math.min(dp[i][j], dp[i-1][l] + times[l][j] + b);
                        dp[i][n] = Math.min(dp[i][n], dp[i-1][n]);
                        dp[i][n] = Math.min(dp[i][n], dp[i][j] + times[j][n]);
                    }
                }
            }
 
            System.out.printf("%.4f\n",dp[n][n]);
        }
    }
 
    public static void main(String[] args){
        new Main().solve();
    }
}