Go: package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

var scanner = bufio.NewScanner(os.Stdin)

const INF = 0x7FFFFFFF

var pass [][]int

func main() {
	for scanner.Scan() {
		pass = make([][]int, 200)
		for i := range pass {
			pass[i] = make([]int, 200)
		}
		buf := strings.Split(scanner.Text(), " ")
		c, _ := strconv.Atoi(buf[0])
		n, _ := strconv.Atoi(buf[1])
		m, _ := strconv.Atoi(buf[2])
		s, _ := strconv.Atoi(buf[3])
		d, _ := strconv.Atoi(buf[4])
		if c == 0 && n == 0 && m == 0 && s == 0 && d == 0 {
			break
		}
		s--
		d--
		for i := 0; i < 200; i++ {
			for j := 0; j < 200; j++ {
				pass[i][j] = INF
			}
		}
		for i := 0; i < 200; i++ {
			pass[i][i] = 0
		}
		for i := 0; i < m; i++ {
			scanner.Scan()
			buf_ := strings.Split(scanner.Text(), " ")
			a, _ := strconv.Atoi(buf_[0])
			b, _ := strconv.Atoi(buf_[1])
			f, _ := strconv.Atoi(buf_[2])
			a--
			b--
			pass[a][b] = f
			pass[b][a] = f
		}
		fmt.Println(dijkstra(s, d, c, n))
	}
}

func dijkstra(s, g, c, n int) float64 {
	d := make([][]float64, 200)
	used := make([][]bool, 200)
	for i := 0; i < 200; i++ {
		d[i] = make([]float64, 20)
		used[i] = make([]bool, 20)
	}
	for i := range d {
		for j := range d[i] {
			d[i][j] = INF
		}
	}
	d[s][c] = 0
	for {
		v := -1
		w := -1
		for u := 0; u < n; u++ {
			for i := 0; i < c+1; i++ {
				if !used[u][i] && (v == -1 || d[u][i] < d[v][w]) {
					v = u
					w = i
				}
			}
		}
		if v == -1 {
			break
		}
		used[v][w] = true
		for u := 0; u < n; u++ {
			d[u][w] = math.Min(d[u][w], d[v][w]+float64(pass[v][u]))
			if w-1 >= 0 && pass[v][u] != INF {
				d[u][w-1] = math.Min(d[u][w-1], d[v][w]+(float64(pass[v][u]/2.0)))
			}
		}
	}
	ret := float64(INF)
	for i := 0; i < c+1; i++ {
		ret = math.Min(ret, d[g][i])
	}
	return ret
}

Python: 
while True:
    c,n,m,s,d = list(map(int,input().split()))

    if c==0 and n == 0 and m == 0 and s == 0 and d == 0 : break

    f_list = [[ 0 for i in range(n+1)] for j in range(n+1)]
    path = {}
    for i in range(m):
        a,b,f = (list(map(int,input().split())))

        def add_path(a,b,f):
            global path
            global f_list
            if not a in path:
                path[a] = [b]
            else:
                path[a].append(b)
            f_list[a][b] = f

        add_path(a,b,f)
        add_path(b,a,f)

    #keiro tansaku
    stack = []
    stack.append(path[s])
    min_path  = None
    min_val = 999999999999

    work_val = []
    work_path = []
    def path_val(path):
        global c
        path.sort()
        v = 0
        if len(path) < c:
            v = sum(path) / 2
        else:
            v = sum(path[-c:])/2
            v += sum(path[:-c])

        return v
        
    work_path.append(s)
    work_val.append(0)

    while len(stack) > 0:


        ham = stack[-1]
        if len(ham) == 0:
            # 1階層上に
            stack.pop()
            work_val.pop()
            work_path.pop()
            continue

        next_p = ham.pop()

        if next_p in work_path: #already passed
            continue

        work_val.append(f_list[work_path[-1]][next_p])
        work_path.append(next_p)

        if next_p == d: #goal
            spam_val = path_val(work_val)
            if min(spam_val,min_val) != min_val:
                min_val = spam_val
            work_val.pop()
            work_path.pop()

        else:
            stack.append(path[next_p])

    print(int(min_val))

Python: 
while True:
    c,n,m,s,d = list(map(int,input().split()))

    if c==0 and n == 0 and m == 0 and s == 0 and d == 0 : break

    f_list = [[ 0 for i in range(n+1)] for j in range(n+1)]
    path = {}
    for i in range(m):
        a,b,f = (list(map(int,input().split())))

        def add_path(a,b,f):
            global path
            global f_list
            if not a in path:
                path[a] = [b]
            else:
                path[a].append(b)
            f_list[a][b] = f

        add_path(a,b,f)
        add_path(b,a,f)

    #keiro tansaku
    stack = []
    stack.append(path[s])
    min_path  = None
    min_val = 999999999999

    work_val = []
    work_path = []
    def path_val(path):
        global c
        path.sort()
        v = 0
        if len(path) < c:
            v = sum(path) / 2
        else:
            v = sum(path[-c:])/2
            v += sum(path[:-c])

        return v
        
    work_path.append(s)
    work_val.append(0)

    while len(stack) > 0:


        ham = stack[-1]
        if len(ham) == 0:
            # 1階層上に
            stack.pop()
            work_val.pop()
            work_path.pop()
            continue

        next_p = ham.pop()

        if next_p in work_path: #already passed
            continue

        work_val.append(f_list[work_path[-1]][next_p])
        work_path.append(next_p)

        if next_p == d: #goal
            spam_val = path_val(work_val[:])
            if min(spam_val,min_val) != min_val:
                min_val = spam_val
            work_val.pop()
            work_path.pop()

        else:
            stack.append(path[next_p][:])

    print(int(min_val))

Python: import heapq

Python: from heapq import *

while True:
    #input c,n,m,s,d & creating G
    #G[to,cost]
    c,n,m,s,d=map(int,input().split())
    
    if c==n==m==s==d==0:
        break
    
    G=[[]]
    for i in range(n):
        G.append([])
    for i in range(m):
        a,b,f=map(int,input().split())
        G[a].append([b,f])
        G[b].append([a,f])

    #creating dp[]
    INF=1e8
    dp=[]
    for i in range(c+1):
        temp=[INF for j in range(n+1)]
        dp.append(temp)

    def dijkstra(s,c):
        que=[]
        dp[0][s]=0
        heappush(que,[dp[c][s],s])

        while len(que)!=0:
            p=heappop(que)
            v=p[1] #v is the current location
            if(dp[c][v]<p[0]):
                continue
            for i in range(len(G[v])):
                e=G[v][i]
                Min=dp[c][v]+e[1] if c==0 else min(dp[c-1][v]+e[1]/2,dp[c][v]+e[1])
                if(dp[c][e[0]]>Min):
                    dp[c][e[0]]=Min
                    heappush(que,[dp[c][e[0]],e[0]])

    for i in range(c+1):
        dijkstra(s,i)
    print(int(dp[c][d]))

Python: from heapq import *

while True:
    #input c,n,m,s,d & creating G
    #G[to,cost]
    c,n,m,s,d=map(int,input().split())
    
    if c==n==m==s==d==0:
        break
    
    G=[[]]
    for i in range(n):
        G.append([])
    for i in range(m):
        a,b,f=map(int,input().split())
        G[a].append([b,f])
        G[b].append([a,f])

    #creating dp[]
    INF=1e8
    dp=[]
    for i in range(c+1):
        temp=[INF for j in range(n+1)]
        dp.append(temp)

    def dijkstra(s,c):
        que=[]
        dp[0][s]=0
        heappush(que,[dp[c][s],s])

        while len(que)!=0:
            p=heappop(que)
            v=p[1] #v is the current location
            if(dp[c][v]<p[0]):
                continue
            for i in range(len(G[v])):
                e=G[v][i]
                Min=dp[c][v]+e[1] if c==0 else min(dp[c-1][v]+e[1]/2,dp[c][v]+e[1])
                if(dp[c][e[0]]>Min):
                    dp[c][e[0]]=Min
                    heappush(que,[dp[c][e[0]],e[0]])

    for i in range(c+1):
        dijkstra(s,i)
    print(int(dp[c][d]))