Problem:
Score : 300 points

Problem Statement

You've come to your favorite store Infinitesco to buy some ice tea.

The store sells ice tea in bottles of different volumes at different costs.
Specifically, a 0.25-liter bottle costs Q yen, a 0.5-liter bottle costs H yen, a 1-liter bottle costs S yen, and a 2-liter bottle costs D yen.
The store has an infinite supply of bottles of each type.

You want to buy exactly N liters of ice tea. How many yen do you have to spend?

Constraints

1 \leq Q, H, S, D \leq 10^8

1 \leq N \leq 10^9

All input values are integers.

Input

Input is given from Standard Input in the following format:

Q H S D
N

Output

Print the smallest number of yen you have to spend to buy exactly N liters of ice tea.

Sample Input 1

20 30 70 90
3

Sample Output 1

150

Buy one 2-liter bottle and two 0.5-liter bottles. You'll get 3 liters for 90 + 30 + 30 = 150 yen.

Sample Input 2

10000 1000 100 10
1

Sample Output 2

100

Even though a 2-liter bottle costs just 10 yen, you need only 1 liter.
Thus, you have to buy a 1-liter bottle for 100 yen.

Sample Input 3

10 100 1000 10000
1

Sample Output 3

40

Now it's better to buy four 0.25-liter bottles for 10 + 10 + 10 + 10 = 40 yen.

Sample Input 4

12345678 87654321 12345678 87654321
123456789

Sample Output 4

1524157763907942

Solution in Python (3.4.3) (judge verdict: Wrong Answer)

import math 

if __name__ == '__main__':
    Q, H, S, D = map(int, input().split())
    N = int(input())
    q, h ,s ,d = [0.25, 0.5, 1, 2]
    cost_d1 = 0
    cost_d2 = 0
    cost_d3 = 0
    cost_d4 = 0
    cost_s1 = 0
    cost_s2 = 0
    cost_h = 0
    cost_q = 0
    if N > d:
        #DSHQ
        N_d = N
        idd = int(N_d/d)
        if idd > 0:
            N_d -= idd*d
            cost_d1 += idd*D
        ids = int(N_d/s)
        if ids > 0:
            N_d -= ids*s
            cost_d1 += ids*S
        idh = int(N_d/h)
        if idh > 0:
            N_d -= idh*h
            cost_d1 += idh*H
        idq = int(N_d/q)
        N_d -= idq*q
        cost_d1 += idq*Q
        #DSQ
        N_d = N
        idd = int(N_d/d)
        if idd > 0:
            N_d -= idd*d
            cost_d2 += idd*D
        ids = int(N_d/s)
        if ids > 0:
            N_d -= ids*s
            cost_d2 += ids*S
        idq = int(N_d/q)
        N_d -= idq*q
        cost_d2 += idq*Q
        #DHQ
        N_d = N
        idd = int(N_d/d)
        if idd > 0:
            N_d -= idd*d
            cost_d3 += idd*D
        idh = int(N_d/h)
        if idh > 0:
            N_d -= idh*h
            cost_d3 += idh*H
        idq = int(N_d/q)
        N_d -= idq*q
        cost_d3 += idq*Q
        #DQ
        N_d = N
        idd = int(N_d/d)
        if idd > 0:
            N_d -= idd*d
            cost_d4 += idd*D
        idq = int(N_d/q)
        N_d -= idq*q
        cost_d4 += idq*Q
    else:
        cost_d1 = float('inf')
        cost_d2 = float('inf')
        cost_d3 = float('inf')
        cost_d4 = float('inf')
    if N > s:
        #SHQ
        N_s = N
        iss = int(N_s/s)
        if iss>0:
            N_s -= iss*s
            cost_s1 += iss*S
        ish = int(N_s/h)
        if ish > 0:
            N_s -= ish*h
            cost_s1 += ish*H
        isq = int(N_s/q)
        N_s -= isq*q
        cost_s1 += isq*Q
        #SQ
        N_s = N
        iss = int(N_s/s)
        if iss > 0:
            N_s -= iss*s
            cost_s2 += iss*S
        isq = int(N_s/q)
        N_s -= isq*q
        cost_s2 += isq*Q
    else:
        cost_s1 = float('inf')
        cost_s1 = float('inf')
    if N > h:
        #HQ
        N_h = N 
        ihh = int(N_h/h)
        if ihh > 0:
            N_h -= ihh*h
            cost_h += ihh*H
        ihq = int(N_h/q)
        N_h -= ihq*q
        cost_h += ihq*Q
    else:
        cost_h = float('inf')
    #Q
    N_q = N
    iqq = int(N_q/q)
    N_q -= iqq*q
    cost_q += iqq*Q
    ans = min(cost_d1, cost_d2, cost_d3, cost_d4, cost_s1, cost_s2, cost_h, cost_q)
    print(ans)