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
}

C++: #include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 999999999
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;

//int dy[]={0, 0, 1, -1, 0};
//int dx[]={1, -1, 0, 0, 0};

struct edge{
  int to, cost;
};

int c, n, m, start, goal;
vector<edge> v[105];	       
vector<vector<int> > dp(11, vector<int>(105, 0));

int dijkstra(int s, int a){
  REP(i, 105) dp[a][i]=INF;
  dp[a][s]=0;

  priority_queue<P> q;
  q.push(P(0, s));
  while(!q.empty()){
    int u=q.top().second;
    if(dp[a][u]<q.top().first) continue;
    q.pop();

    REP(i, v[u].size()){
      int to=v[u][i].to;
      int cost=(a==0 ? v[u][i].cost+dp[a][u] : min(v[u][i].cost+dp[a][u], v[u][i].cost/2+dp[a-1][u]));
      if(dp[a][to]>cost){
	dp[a][to]=cost;
	q.push(P(-cost, to));
      }
    }
  }
}

int main(){
  while(1){
    scanf("%d%d%d%d%d", &c, &n, &m, &start, &goal);
    start--; goal--;
    if(c==0) return 0;
    
    REP(i, m){
      int from, to, f;
      scanf("%d%d%d", &from, &to, &f);
      from--; to--;
      v[to].push_back((edge){from, f});
      v[from].push_back((edge){to, f});
    }

    REP(i, c+1){
      dijkstra(start, i);
    }

    printf("%d\n", dp[c][goal]);

    REP(i, 105){
      v[i].erase(v[i].begin(), v[i].end());
    }
    REP(i, 11){
      dp[i].erase(dp[i].begin(), dp[i].end());
    }
  }
}

C++: #include <iostream>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

struct edge {
    int to, cost;
    edge() {}
    edge(int to_, int cost_): to(to_), cost(cost_) {}
};

struct state {
    int pos, cost;
    state (){}
    state (int pos_, int cost_): pos(pos_), cost(cost_) {}

    bool operator < (const state& o) const {
        return cost > o.cost;
    }
};

constexpr int INF = 1 << 29;

int C, M, N, S, D;

const int W = 100;
vector<edge> graph[1100];

int min_cost[1100];

bool solve() {
    cin >> C >> N >> M >> S >> D;
    if (C+N+M+S+D == 0) { return false; }
    --S; --D;

    for (int j = 0; j < 1100; ++j) {
        graph[j] = vector<edge>();
    }
    fill(min_cost, min_cost+1100, INF);
    min_cost[S] = 0;


    for (int j = 0; j < M; ++j) {
        int a, b, f; cin >> a >> b >> f;
        --a; --b;
        for (int j = 0; j < C; ++j) {
            graph[a+j*W].emplace_back(b+j*W, f);
            graph[b+j*W].emplace_back(a+j*W, f);

            graph[a+j*W].emplace_back(b+(j+1)*W, f/2);
            graph[b+j*W].emplace_back(a+(j+1)*W, f/2);
        }
        graph[a+C*W].emplace_back(b+C*W, f);
        graph[b+C*W].emplace_back(a+C*W, f);
    }

    priority_queue<state, vector<state>> que;
    que.emplace(S, 0);

    while (!que.empty()) {
        state st = que.top(); que.pop();
        int pos = st.pos;
        int cost = st.cost;
        if (cost > min_cost[st.pos]) { continue; }

        for (edge& e : graph[pos]) {
            int next_cost = cost + e.cost;
            if (next_cost < min_cost[e.to]) {
                min_cost[e.to] = next_cost;
                que.emplace(e.to, next_cost);
            }
        }
    }

    int ans = INF;
    for (int j = 0; j <= C; ++j) {
        ans = min(ans, min_cost[D+j*W]);
    }
    cout << ans << endl;

    return true;
}

int main() {
    for (; solve(); ) ;
    return 0;
}

C++: #include <iostream>
#include <queue>
#include <algorithm>
#define INF 9999999
using namespace std;

class State {
public:
  int id;
  int cost;
  int tiket;
  bool operator <(const State &s) const {
    if(tiket != s.tiket) return tiket < s.tiket;
    return cost > s.cost;
  }
  State(int id, int cost, int tiket) : id(id), cost(cost), tiket(tiket) {}
};

int main() {
  while(1) {
    int c, n, m, s, d;
    cin >> c >> n >> m >> s >> d;
    if(c == 0 && n == 0 && m == 0 && s == 0 && d == 0) break;
    int data[n+1][n+1];
    fill(&data[0][0], &data[n][n]+1, INF);
    for(int i = 0; i < m; i++) {
      int a, b, f;
      cin >> a >> b >> f;
      data[a][b] = data[b][a] = f;
    }

    priority_queue<State> PQ;
    PQ.push(State(s, 0, c));
    bool visited[n+1][c+1];
    int cost[n+1][c+1];
    fill(&visited[0][0], &visited[n][c] + 1, false);
    fill(&cost[0][0], &cost[n][c] + 1, INF);
    cost[s][c] = 0;
    while(!PQ.empty()) {
      State s = PQ.top();
      PQ.pop();
      visited[s.id][s.tiket] = true;
      for(int i = 1; i <= n; i++) {
	if(!visited[i][s.tiket] && data[s.id][i] != INF) {
	  int newValue = cost[s.id][s.tiket] + data[s.id][i];
	  if(newValue < cost[i][s.tiket]) {
	    cost[i][s.tiket] = newValue;
	    PQ.push(State(i, newValue, s.tiket));
	  }
	}
	if(s.tiket >= 1 && !visited[i][s.tiket-1] && data[s.id][i] != INF) {
	  int newValue = cost[s.id][s.tiket] + data[s.id][i]/2;
	  if(newValue < cost[i][s.tiket-1]) {
	    cost[i][s.tiket-1] = newValue;
	    PQ.push(State(i, newValue, s.tiket-1));
	  }
	}
      }
    }
    int min = INF;
    for(int i = 0; i <= c; i++) {
      if(cost[d][i] < min) min = cost[d][i];
    }
    cout << min << endl;
  }
  return 0;
}