Problem: Radewoosh is playing a computer game. There are n levels, numbered 1 through n. Levels are divided into k regions (groups). Each region contains some positive number of consecutive levels.

The game repeats the the following process:

  1. If all regions are beaten then the game ends immediately. Otherwise, the system finds the first region with at least one non-beaten level. Let X denote this region.
  2. The system creates an empty bag for tokens. Each token will represent one level and there may be many tokens representing the same level.
    * For each already beaten level i in the region X, the system adds ti tokens to the bag (tokens representing the i-th level). 
    * Let j denote the first non-beaten level in the region X. The system adds tj tokens to the bag. 
  3. Finally, the system takes a uniformly random token from the bag and a player starts the level represented by the token. A player spends one hour and beats the level, even if he has already beaten it in the past. 



Given n, k and values t1, t2, ..., tn, your task is to split levels into regions. Each level must belong to exactly one region, and each region must contain non-empty consecutive set of levels. What is the minimum possible expected number of hours required to finish the game?

Input

The first line of the input contains two integers n and k (1 ≤ n ≤ 200 000, 1 ≤ k ≤ min(50, n)) — the number of levels and the number of regions, respectively.

The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 100 000).

Output

Print one real number — the minimum possible expected value of the number of hours spent to finish the game if levels are distributed between regions in the optimal way. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct if <image>.

Examples

Input

4 2
100 3 5 7


Output

5.7428571429


Input

6 2
1 2 4 8 16 32


Output

8.5000000000

Note

In the first sample, we are supposed to split 4 levels into 2 regions. It's optimal to create the first region with only one level (it must be the first level). Then, the second region must contain other three levels.

In the second sample, it's optimal to split levels into two regions with 3 levels each.

Solution (in JAVA):

Solution:
//package baobab;

import java.io.*;
import java.util.*;

public class E {

    public static void main(String[] args) {
        EIO io = new EIO();
        try {
            Esolver solver = new Esolver(io);
        } finally {
            io.close();
        }
    }

}

class Esolver {

    public Esolver(EIO io) {
        io.println(solve(io));
    }

    public String solve(EIO io) {
        int n = io.nextInt();
        int k = io.nextInt();
        int[] t = new int[n+1];
        double[] pre = new double[n+1];
        long[] sum = new long[n+1];
        double[] rev = new double[n+1];
        for (int i=1; i<=n; i++) {
            t[i] = io.nextInt();
            sum[i] = sum[i-1] + t[i];
            rev[i] = rev[i-1] + 1.0 / t[i];
            pre[i] = pre[i-1] + 1.0 * sum[i] / t[i];
        }

        double[][] dp = new double[n+1][k+1];
        for (int i=0; i<=n; i++) {
            for (int j=0; j<=k; j++) {
                dp[i][j] = Double.POSITIVE_INFINITY;
            }
        }
        for (int i=1; i<=n; i++) {
            dp[i][1] = pre[i];
        }

        for (int j=2; j<=k; j++) {
            LinePouch pouch = new LinePouch();
            for (int i=j; i<=n; i++) {
                long slope = -sum[i-1];
                double constant = dp[i-1][j-1] - pre[i-1] + rev[i-1] * sum[i-1];
                Line newLine = new Line(slope, constant);
                pouch.addLine(newLine);
                double x = rev[i];
                double ans = pre[i] + pouch.getBest(x);
                dp[i][j] = ans;
            }
        }
        return ""+dp[n][k];
    }
}

/*
for (int l=j-1; l<i; l++) {
        if (dp[l][j-1] == Double.POSITIVE_INFINITY) continue;
        double ans = dp[l][j-1] - pre[l] + rev[l] * sum[l] - rev[i] * sum[l];
        bestAns = Math.min(ans, bestAns);
        }
        double ans = pre[i] + bestAns;*/

/* Convex Hull Trick */
class Line {
    double K;
    double B;

    Line(double K, double B) {
        this.K = K;
        this.B = B;
    }

    double intersectionX(Line other) {
        return (other.B - B) / (K - other.K);
    }
}

/* LinePouch by kraskevich @ http://codeforces.com/contest/674/submission/17797074 */
class LinePouch {

    ArrayList<Line> lines = new ArrayList<>();
    int first = 0;

    void addLine(Line newLine) {
        while (lines.size() >= 2) {
            Line p = lines.get(lines.size() - 1);
            Line pp = lines.get(lines.size() - 2);
            if (p.intersectionX(newLine) <= pp.intersectionX(newLine))
                lines.remove(lines.size() - 1);
            else
                break;
        }
        lines.add(newLine);
    }

    double getBest(double curX) {
        while (first < lines.size() - 1) {
            Line f = lines.get(first);
            Line ff = lines.get(first + 1);
            if (ff.K * curX + ff.B <= f.K * curX + f.B)
                first++;
            else
                break;
        }
        Line f = lines.get(first);
        return f.K * curX + f.B;
    }
}

class EIO extends PrintWriter {
    private InputStreamReader r;
    private static final int BUFSIZE = 1 << 15;
    private char[] buf;
    private int bufc;
    private int bufi;
    private StringBuilder sb;

    public EIO() {
        super(new BufferedOutputStream(System.out));
        r = new InputStreamReader(System.in);

        buf = new char[BUFSIZE];
        bufc = 0;
        bufi = 0;
        sb = new StringBuilder();
    }

    private void fillBuf() throws IOException {
        bufi = 0;
        bufc = 0;
        while(bufc == 0) {
            bufc = r.read(buf, 0, BUFSIZE);
            if(bufc == -1) {
                bufc = 0;
                return;
            }
        }
    }

    private boolean pumpBuf() throws IOException {
        if(bufi == bufc) {
            fillBuf();
        }
        return bufc != 0;
    }

    private boolean isDelimiter(char c) {
        return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
    }

    private void eatDelimiters() throws IOException {
        while(true) {
            if(bufi == bufc) {
                fillBuf();
                if(bufc == 0) throw new RuntimeException("IO: Out of input.");
            }

            if(!isDelimiter(buf[bufi])) break;
            ++bufi;
        }
    }

    public String next() {
        try {
            sb.setLength(0);

            eatDelimiters();
            int start = bufi;

            while(true) {
                if(bufi == bufc) {
                    sb.append(buf, start, bufi - start);
                    fillBuf();
                    start = 0;
                    if(bufc == 0) break;
                }

                if(isDelimiter(buf[bufi])) break;
                ++bufi;
            }

            sb.append(buf, start, bufi - start);

            return sb.toString();
        } catch(IOException e) {
            throw new RuntimeException("IO.next: Caught IOException.");
        }
    }

    public int nextInt() {
        try {
            int ret = 0;

            eatDelimiters();

            boolean positive = true;
            if(buf[bufi] == '-') {
                ++bufi;
                if(!pumpBuf()) throw new RuntimeException("IO.nextInt: Invalid int.");
                positive = false;
            }

            boolean first = true;
            while(true) {
                if(!pumpBuf()) break;
                if(isDelimiter(buf[bufi])) {
                    if(first) throw new RuntimeException("IO.nextInt: Invalid int.");
                    break;
                }
                first = false;

                if(buf[bufi] >= '0' && buf[bufi] <= '9') {
                    if(ret < -214748364) throw new RuntimeException("IO.nextInt: Invalid int.");
                    ret *= 10;
                    ret -= (int)(buf[bufi] - '0');
                    if(ret > 0) throw new RuntimeException("IO.nextInt: Invalid int.");
                } else {
                    throw new RuntimeException("IO.nextInt: Invalid int.");
                }

                ++bufi;
            }

            if(positive) {
                if(ret == -2147483648) throw new RuntimeException("IO.nextInt: Invalid int.");
                ret = -ret;
            }

            return ret;
        } catch(IOException e) {
            throw new RuntimeException("IO.nextInt: Caught IOException.");
        }
    }

    public long nextLong() {
        try {
            long ret = 0;

            eatDelimiters();

            boolean positive = true;
            if(buf[bufi] == '-') {
                ++bufi;
                if(!pumpBuf()) throw new RuntimeException("IO.nextLong: Invalid long.");
                positive = false;
            }

            boolean first = true;
            while(true) {
                if(!pumpBuf()) break;
                if(isDelimiter(buf[bufi])) {
                    if(first) throw new RuntimeException("IO.nextLong: Invalid long.");
                    break;
                }
                first = false;

                if(buf[bufi] >= '0' && buf[bufi] <= '9') {
                    if(ret < -922337203685477580L) throw new RuntimeException("IO.nextLong: Invalid long.");
                    ret *= 10;
                    ret -= (long)(buf[bufi] - '0');
                    if(ret > 0) throw new RuntimeException("IO.nextLong: Invalid long.");
                } else {
                    throw new RuntimeException("IO.nextLong: Invalid long.");
                }

                ++bufi;
            }

            if(positive) {
                if(ret == -9223372036854775808L) throw new RuntimeException("IO.nextLong: Invalid long.");
                ret = -ret;
            }

            return ret;
        } catch(IOException e) {
            throw new RuntimeException("IO.nextLong: Caught IOException.");
        }
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

}