Problem:
Railway Connection Tokyo has a very complex railway system.
For example, there exists a partial map of lines and stations
as shown in Figure D-1.   Figure D-1: A sample railway network   Suppose you are going to station D from station A.
Obviously, the path with the shortest distance is A→B→D.
However, the path with the shortest distance does not necessarily
mean the minimum cost.
Assume the lines A-B, B-C, and C-D are operated by one railway company,
and the line B-D is operated by another company.
In this case, the path A→B→C→D may cost less than A→B→D.
One of the reasons is that the fare is not proportional to the distance.
Usually, the longer the distance is, the fare per unit distance is lower.
If one uses lines of more than one railway company,
the fares charged by these companies are simply added together,
and consequently the total cost may become higher although the distance is shorter
than the path using lines of only one company. In this problem, a railway network including multiple railway companies is given.
The fare table (the rule to calculate the fare from the distance) of each company is also given.
Your task is, given the starting point and the goal point, to write a program
that computes the path with the least total fare. Input The input consists of multiple datasets, each in the following format.  n  m  c  s  g  x 1  y 1  d 1  c 1 ...  x m  y m  d m  c m  p 1 ... p c  q 1,1 ... q 1, p 1 -1  r 1,1 ... r 1, p 1 ...  q c ,1 ... q c,p c -1  r c ,1 ... r c,p c  Every input item in a dataset is a non-negative integer.
Input items in the same input line are separated by a space. The first input line gives the size of the railway network and the intended trip. n is the number of stations (2 ≤ n ≤ 100). m is the number of lines connecting two stations (0 ≤ m ≤ 10000). c is the number of railway companies (1 ≤ c ≤ 20). s is the station index of the starting point (1 ≤ s ≤ n ). g is the station index of the goal point (1 ≤ g ≤ n , g ≠ s ). The following m input lines give the details of (railway) lines.
The i -th line connects two stations x i  and y i  (1 ≤ x i ≤ n ,
1 ≤ y i ≤ n , x i ≠ y i ).
Each line can be traveled in both directions.
There may be two or more lines connecting the same pair of stations. d i  is the distance of the i -th line (1 ≤ d i ≤ 200). c i  is the company index of the railway company operating the line (1 ≤ c i ≤ c ). The fare table (the relation between the distance and the fare)
of each railway company can be expressed as a line chart.
For the railway company j ,
the number of sections of the line chart is given by p j  (1 ≤ p j ≤ 50). q j,k  (1 ≤ k ≤ p j -1) gives
the distance separating two sections of the chart
(1 ≤ q j,k ≤ 10000). r j,k  (1 ≤ k ≤ p j ) gives
the fare increment per unit distance for the corresponding section of the chart
(1 ≤ r j,k ≤ 100).
More precisely, with the fare for the distance z denoted by f j ( z ),
the fare for distance z satisfying q j , k -1 +1 ≤ z ≤ q j , k is computed by the recurrence relation f j ( z ) = f j ( z -1)+ r j,k .
Assume that q j ,0 and f j (0) are zero,
and q j , p j is infinity. For example, assume p j  = 3, q j ,1 = 3, q j ,2 = 6, r j ,1 = 10, r j ,2 = 5, and r j ,3 = 3.
The fare table in this case is as follows.  distance 1 2 3 4 5 6 7 8 9  fare 10 20 30 35 40 45 48 51 54   q j,k  increase monotonically with respect to k . r j,k  decrease monotonically with respect to k . The last dataset is followed by an input line containing five zeros
(separated by a space). Output For each dataset in the input, the total fare for the best route
(the route with the minimum total fare)
should be output as a line.
If the goal cannot be reached from the start, output "-1".
An output line should not contain extra characters such as spaces. Once a route from the start to the goal is determined,
the total fare of the route is computed as follows.
If two or more lines of the same railway company are used contiguously,
the total distance of these lines is used to compute the fare of this section.
The total fare of the route is the sum of fares of such "sections consisting
of contiguous lines of the same company".
Even if one uses two lines of the same company, if a line of another company
is used between these two lines, the fares of sections including these two
lines are computed independently.
No company offers transit discount. Sample Input 4 4 2 1 4
1 2 2 1
2 3 2 1
3 4 5 1
2 4 4 2
3 1
3 6
10 5 3

10
2 0 1 1 2
1

1
4 5 2 4 1
4 3 10 1
3 2 2 1
3 2 1 2
3 2 5 2
2 1 10 1
3 3
20 30
3 2 1
5 10
3 2 1
5 5 2 1 5
1 2 10 2
1 3 20 2
2 4 20 1
3 4 10 1
4 5 20 1
2 2
20
4 1
20
3 1
0 0 0 0 0 Output for the Sample Input 54
-1
63
130

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


class WarshallFloyd():
    def __init__(self, e, n):
        self.E = e
        self.N = n

    def search(self):
        n = self.N
        nl = list(range(n))
        d = [[inf] * n for _ in nl]
        for k,v in self.E.items():
            for b,c in v:
                if d[k][b] > c:
                    d[k][b] = c
        for i in nl:
            for j in nl:
                if i == j:
                    continue
                for k in nl:
                    if i != k and j != k and d[j][k] > d[j][i] + d[i][k]:
                        d[j][k] = d[j][i] + d[i][k]
                        d[j][k] = d[j][i] + d[i][k]
        return d

def main():
    rr = []

    def f(n,m,c,s,g):
        ms = [LI() for _ in range(m)]
        ps = LI()
        qrs = [([0] + LI(),LI()) for _ in range(c)]
        ec = collections.defaultdict(lambda: collections.defaultdict(list))
        for x,y,d,cc in ms:
            ec[cc][x].append((y,d))
            ec[cc][y].append((x,d))
        nl = list(range(n+1))
        ad = [[inf] * (n+1) for _ in nl]
        for cc,v in ec.items():
            q, r = qrs[cc-1]
            wf = WarshallFloyd(v, n+1)
            d = wf.search()
            w = [0]
            for i in range(1, len(q)):
                w.append(w[-1] + (q[i]-q[i-1]) * r[i-1])

            for i in nl:
                for j in nl:
                    dk = d[i][j]
                    if dk == inf:
                        continue
                    ri = bisect.bisect_left(q, dk) - 1
                    dw = w[ri] + r[ri] * (dk - q[ri])
                    if ad[i][j] > dw:
                        ad[i][j] = dw

        ae = collections.defaultdict(list)
        for i in nl:
            ai = ad[i]
            for j in nl:
                if ai[j] < inf:
                    ae[i].append((j, ai[j]))
        awf = WarshallFloyd(ae, n+1)
        awd = awf.search()
        r = awd[s][g]

        def search(s):
            d = collections.defaultdict(lambda: inf)
            d[s] = 0
            q = []
            heapq.heappush(q, (0, s))
            v = collections.defaultdict(bool)
            while len(q):
                k, u = heapq.heappop(q)
                if v[u]:
                    continue
                v[u] = True

                for uv, ud in ae[u]:
                    if v[uv]:
                        continue
                    vd = k + ud
                    if d[uv] > vd:
                        d[uv] = vd
                        heapq.heappush(q, (vd, uv))

            return d
        dkr = search(s)[g]
        if r == inf:
            return -1
        return r

    while True:
        n,m,c,s,g = LI()
        if n == 0 and m == 0:
            break
        rr.append(f(n,m,c,s,g))

    return '\n'.join(map(str, rr))



print(main())

Solution (Python):

import heapq
from collections import defaultdict
from functools import lru_cache
from bisect import bisect_right
while True:
    N, M, C, S, G = map(int, input().split())
    if N == M == C == S == G == 0:  
        break
    
    D = [[[float("inf")] * (N + 1) for _ in range(N + 1)] for _ in range(C + 1)]
    CE = [set() for _ in range(C+1)]
    for _ in range(M):
        x, y, d, c = map(int, input().split())  
        D[c][x][y] = min(D[c][x][y], d)
        D[c][y][x] = min(D[c][x][y], d)
        CE[c].add(x)
        CE[c].add(y)

    P = list(map(int, input().split()))  
    Q = []
    R = []
    for _ in range(C):
        Q.append(list(map(int, input().split())) + [1 << 30])
        R.append(list(map(int, input().split())))

    cum_fare = []
    for c_ in range(C):
        fare_ = [0]
        res = 0
        q_p = 0
        for q, r in zip(Q[c_][:-1], R[c_][:-1]):
            res += (q - q_p) * r
            q_p = q
            fare_.append(res)
        cum_fare.append(fare_)

    @lru_cache(maxsize=None)
    def fare(d_, c_):
        if d_==float("inf"):
            return float("inf")
        c_ -= 1
        idx = bisect_right(Q[c_], d_)
        
        return cum_fare[c_][idx] + (R[c_][0] * d_ if idx==0 else (d_ - Q[c_][idx-1]) * R[c_][idx])


    DD = [[float("inf")] * (N + 1) for _ in range(N + 1)]
    for c in range(1, C + 1):
        D_ = D[c]
        l = list(CE[c])
        for k in l:
            for i in l:
                for j in l:
                    d_ = D_[i][k] + D_[k][j]
                    if D_[i][j] > d_:
                        D_[i][j] = d_
        
        for i in l:
            for j in l:
                DD[i][j] = min(DD[i][j], fare(D_[i][j], c))
    
    dist = defaultdict(lambda: float("inf"))
    q = []
    start = S
    dist[start] = 0
    heapq.heappush(q, (0, start))
    while len(q) != 0:
        prob_cost, v = heapq.heappop(q)
        
        if dist[v] < prob_cost:
            continue
        if v == G:
            print(prob_cost)
            break
        for u, c in enumerate(DD[v]):
            if dist[u] > dist[v] + c:
                dist[u] = dist[v] + c
                heapq.heappush(q, (dist[u], u))
    else:
        print(-1)

Solution (Python):
while 1:
    N, M, C, s, g = map(int, raw_input().split())
    if N == M == 0:
        break
    es = [[] for i in xrange(C)]
    for i in xrange(M):
        x, y, d, c = map(int, raw_input().split())
        if not x < y:
            x, y = y, x
        es[c-1].append((x-1, y-1, d))
    P = map(int, raw_input().split())
    Q = []; R = []
    for i in xrange(C):
        Q.append([0] + map(int, raw_input().split()) + [10**18])
        R.append(map(int, raw_input().split()))
    def calc(c, z):
        p = P[c]; q = Q[c]; r = R[c]
        su = i = 0
        while q[i+1] < z:
            su += (q[i+1] - q[i]) * r[i]
            i += 1
        return su + (z - q[i]) * r[i]

    EA = {}
    INF = 10**18
    for c in xrange(C):
        E = {(i, i): 0 for i in xrange(N)}
        V = set()
        for x, y, d in es[c]:
            E[x, y] = min(E.get((x, y), INF), d)
            V.add(x); V.add(y)
        for k in V:
            for i in V:
                for j in V:
                    if not i < j:
                        continue
                    k1 = min((i, k), (k, i))
                    k2 = min((k, j), (j, k))
                    if k1 in E and k2 in E:
                        E[i, j] = min(E.get((i, j), INF), E[k1] + E[k2])
        for ps in E:
            EA[ps] = min(EA.get(ps, INF), calc(c, E[ps]))
    for k in xrange(N):
        for i in xrange(N):
            for j in xrange(i+1, N):
                k1 = min((i, k), (k, i))
                k2 = min((k, j), (j, k))
                if k1 in EA and k2 in EA:
                    EA[i, j] = min(EA.get((i, j), INF), EA[k1] + EA[k2])
    ps = min((s-1, g-1), (g-1, s-1))
    print -1 if ps not in EA else EA[ps]

Solution (Python):
inf=100000000

def calc(uth,dis,c):
    fare=0
    if dis>=inf:
        return inf
    if unchin[c]==1:
        return uth[c][1][0]*dis
    ddis=uth[c][0]
    dcost=uth[c][1]
    i=1
    while(i<unchin[c] and dis>ddis[i]):
        fare+=(ddis[i]-ddis[i-1])*dcost[i-1]
        i+=1
    fare+=(dis-ddis[i-1])*dcost[i-1]
    return fare

def floyd(bigmap,n):
    res=bigmap
    for k in range(1,n+1):
        for i in range(1,n+1):
            for j in range(1,n+1):
                if res[i][j]>res[i][k]+res[k][j]:
                    res[i][j]=res[i][k]+res[k][j]
    return res

def init2d(bigmap,n):
    for i in range(n+1):
        bigmap.append([])
    for map1 in bigmap:
        for j in range(n+1):
            map1.append(inf)
    for i in range(1,n+1):
        bigmap[i][i]=0
    return bigmap

while(1):
    n,m,c,s,g=map(int,raw_input().split())
    if(n==m==0): break
    rosen=[]
    for i in range(c+1):
        map0=[]
        rosen.append(init2d(map0,n))

    for i in range(m):
        x,y,d,c0=map(int,raw_input().split())
        rosen[c0][x][y]=min(rosen[c0][x][y],d)
        rosen[c0][y][x]=min(rosen[c0][x][y],d)

    unchin=list(map(int,raw_input().split()))
    unchin.insert(0,0)
    uth=[]
    uth.append([])
    for i in range(1,c+1):
        ddis=list(map(int,raw_input().split()))
        ddis.insert(0,0)
        dcost=list(map(int,raw_input().split()))
        uth.append([ddis,dcost])

    bigmap=[]
    bigmap=init2d(bigmap,n)


    for c0,cmap in enumerate(rosen[1:]):
        tmp=floyd(cmap,n)
        for i in range(1,n+1):
            for j in range(1,n+1):
                bigmap[i][j]=min(bigmap[i][j],calc(uth,tmp[i][j],c0+1))

    bigmap=floyd(bigmap,n)

    ans=bigmap[s][g]
    if ans < inf:
        print(ans)
    else:
        print(-1)

Solution (Python):
def solve():
    import sys
    from itertools import combinations
    from bisect import bisect
    from heapq import heappush, heappop
    file_input = sys.stdin
    inf = float('inf')
    while True:
        n, m, c, s, g = map(int, file_input.readline().split())
        if n == 0:
            break
        
        
        adj_matrices = [[[inf] * n for j in range(n)] for i in range(c)]
        
        for i in range(m):
            x, y, d, c = map(int, file_input.readline().split())
            mat = adj_matrices[c - 1]
            x -= 1
            y -= 1
            pre_d = mat[x][y]
            if d < pre_d:
                mat[x][y] = d
                mat[y][x] = d
        
        p = file_input.readline()
        
        
        adj_matrix = [[inf] * n for i in range(n)]
        
        for mat in adj_matrices:
            
            for k in range(n):
                for x, y in combinations(range(n), 2):
                    d1 = mat[x][y]
                    d2 = mat[x][k] + mat[k][y]
                    if d2 < d1:
                        mat[x][y] = d2
                        mat[y][x] = d2
            
            q = list(map(int, file_input.readline().split()))
            r = list(map(int, file_input.readline().split()))
            
            
            for x, y in combinations(range(n), 2):
                d = mat[x][y]
                if d != inf:
                    idx = bisect(q, d)
                    fare = 0
                    pre_sd = 0
                    for sd, f in zip(q[:idx], r):
                        fare += f * (sd - pre_sd)
                        pre_sd = sd
                    fare += r[idx] * (d - pre_sd)
                    if fare < adj_matrix[x][y]:
                        adj_matrix[x][y] = fare
                        adj_matrix[y][x] = fare
        
        
        s -= 1
        g -= 1
        fare = [inf] * n
        fare[s] = 0
        pq = [(0, s)]
        while pq:
            u_fare, u = heappop(pq)
                    
            if u == g:
                print(u_fare)
                break
            
            for v, f in enumerate(adj_matrix[u]):
                new_fare = u_fare + f
                if new_fare < fare[v]:
                    fare[v] = new_fare
                    heappush(pq, (new_fare, v))
        else:
            print(-1)

solve()