Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)

const INF = 0x7FFFFFFF

func main() {
	for scanner.Scan() {
		n, _ := strconv.Atoi(scanner.Text())
		if n == 0 {
			break
		}
		matrix := make([][]int, 10)
		for i := range matrix {
			matrix[i] = make([]int, 10)
		}
		for i := range matrix {
			for j := range matrix[i] {
				if i == j {
					matrix[i][j] = 0
				} else {
					matrix[i][j] = INF
				}
			}
		}
		num := 0
		for i := 0; i < n; i++ {
			scanner.Scan()
			buf := strings.Split(scanner.Text(), " ")
			from, _ := strconv.Atoi(buf[0])
			to, _ := strconv.Atoi(buf[1])
			cost, _ := strconv.Atoi(buf[2])
			if num < from {
				num = from
			}
			if num < to {
				num = to
			}
			matrix[from][to] = cost
			matrix[to][from] = cost
		}
		num++
		for i := 0; i < num; i++ {
			for j := 0; j < num; j++ {
				for k := 0; k < num; k++ {
					if matrix[j][i]+matrix[i][k] < matrix[j][k] {
						matrix[j][k] = matrix[j][i]+matrix[i][k]
					}
				}
			}
		}
		ans, sum := 0, INF
		for i := 0; i < num; i++ {
			now := 0
			for j := 0; j < num; j++ {
				now += matrix[i][j]
			}
			if sum > now {
				sum = now
				ans = i
			}
		}
		fmt.Println(ans, sum)
	}
}

C++: #include <bits/stdc++.h>
using namespace std;
#define all(c) (c).begin(),(c).end()
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;i--)
#define REP(i,m,n) for(int i=(int)(m);i<(int)(n);i++)
#define rep(i,n) REP(i,0,n)
#define iter(c) __typeof((c).begin())
#define tr(it,c) for(iter(c) it=(c).begin();it!=(c).end();it++)
#define mem(a) memset(a,0,sizeof(a))
#define pd(a) printf("%.10f\n",a)
#define pb(a) push_back(a)
#define in(a) insert(a)
#define pi M_PI
#define R cin>>
#define F first
#define S second
#define C class
#define ll long long
#define ln cout<<'\n'
#define _(_1,_2,_3,N,...)N
#define pr(...) _(__VA_ARGS__,pr3,pr2,pr1)(__VA_ARGS__)
template<C T>void pr1(T a){cout<<a;ln;}
template<C T,C T2>void pr2(T a,T2 b){cout<<a<<' '<<b;ln;}
template<C T,C T2,C T3>void pr3(T a,T2 b,T3 c){cout<<a<<' '<<b<<' '<<c;ln;}
template<C T>void PR(T a,int n){rep(i,n){if(i)cout<<' ';cout<<a[i];}ln;}
bool check(int n,int m,int x,int y){return x>=0&&x<n&&y>=0&&y<m;}
const ll MAX=1000000007,MAXL=1LL<<60,dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
typedef pair<int,int> P;
typedef pair<P,int> PP;

void Main() {
  int n;
  while(R n && n) {
    PP a[n];
    map<int,int> m,mm;
    rep(i,n) {
      cin >> a[i].F.F >> a[i].F.S >> a[i].S;
      if(!m.count(a[i].F.F)) {
        int s=m.size();
        m[a[i].F.F]=s;
        mm[s]=a[i].F.F;
      }
      if(!m.count(a[i].F.S)) {
        int s=m.size();
        m[a[i].F.S]=s;
        mm[s]=a[i].F.S;
      }
    }
    int N=m.size();
    int d[N][N];
    rep(i,N)rep(j,N)d[i][j]=MAX;
    rep(i,N)d[i][i]=0;
    rep(i,n) {
      d[m[a[i].F.F]][m[a[i].F.S]]=a[i].S;
      d[m[a[i].F.S]][m[a[i].F.F]]=a[i].S;
    }
    rep(k,N)rep(i,N)rep(j,N){
      if(d[i][k]!=MAX&&d[k][j]!=MAX) d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
    }
    int M=MAX,x;
    rep(i,N) {
      int sum=0;
      rep(j,N)if(d[i][j]!=MAX)sum+=d[i][j];
      if(sum<M) {
        M=sum;
        x=mm[i];
      } else if(sum==M) x=min(x,mm[i]);
    }
    pr(x,M);
  }
}

int main() {
  ios::sync_with_stdio(0);cin.tie(0);
  Main();return 0;
}

C++: #include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
#define INF 1000000
int cost[1000][1000];
int d[1000];
bool used[1000];

int n,a,b,c,m;
using namespace std;

void dijkstra(int s){

  d[s] = 0;
  while(1){
    int v = -1;
    for(int u = 0 ; u <= m ; u++ ){
      if(!used[u] && (v == -1 || d[u] < d[v]))v = u;
    }

    if(v == -1)break;

    used[v] = true;

    for(int u = 0 ; u <= m ; u++ ){
      d[u] = min(d[u],d[v] + cost[v][u]);
    }
  }
}

int main(){
  int ans;
  while(cin >> n,n){
    memset(cost,INF,sizeof(cost));
    m = 0;
    for(int i = 0 ; i < n ; i++ ){

      cin >> a >> b >> c;

      cost[a][b] = cost[b][a] = c;
      if(m < a || m < b)m = max(a,b);
    }
    int ansj;
    int mn = 1000000;
    for(int j = 0 ; j <= m ; j++ ){
      fill(d,d + (m+1),INF);
      fill(used,used + (m+1),false);

      dijkstra(j);

      ans = 0;
      for(int i = 0 ; i <= m ; i++){
	ans+=d[i];
      }
      if(mn > ans){
	mn = ans;
	ansj = j;
      }
    }
    cout << ansj << " " << mn << endl;
  }
}

C++: #include<iostream>
using namespace std;
int n,t[100],a,L,R,M,ans;
int main(){
  while(cin>>n&&n){
    for(int i=0;i<n;i++){
      cin>>t[i];
    }
    cin>>a;
    L=0;R=n-1;M=(L+R)/2;
    ans=0;
    while(L<R){
      ans++;
      if(t[M]==a){
	break;
      }else if(t[M]>a){
	R=M-1;
	M=(L+R)/2;
      }else{
	L=M+1;
	M=(L+R)/2;
      }
    }
    cout<<ans+1<<endl;
  }
  
  return 0;
}

C++: #include<iostream>

#define TOWN_MAX 10
#define ROAD_MAX 45
#define INF 1000000000000000

void solve(int);

int main(int argc, char const* argv[]) {
    int n;

    while (true) {
        std::cin >> n;
        if (n == 0) break;
        solve(n);
    }
    return 0;
}

void solve(int road_num) {
    long long distances[TOWN_MAX][TOWN_MAX];
    bool used[TOWN_MAX];

    for (int i = 0; i < TOWN_MAX; i++) {
        used[i] = false;
        for (int j = 0; j < TOWN_MAX; j++)
            distances[i][j] = (i == j) ? 0 :INF;
    }

    for (int i = 0; i < road_num; i++) {
        int src, dest, cost;
        std::cin >> src >> dest >> cost;
        distances[src][dest] = cost;
        distances[dest][src] = cost;
        used[src] = used[dest] = true;
    }

    for (int infix_road = 0; infix_road < road_num; infix_road++) {
        for (int begin_town = 0; begin_town < TOWN_MAX; begin_town++) {
            for (int end_town = 0; end_town < TOWN_MAX; end_town++) {
                distances[begin_town][end_town] = std::min(distances[begin_town][end_town],
                        distances[begin_town][infix_road] + distances[infix_road][end_town]);
                distances[end_town][begin_town] = std::min(distances[end_town][begin_town],
                        distances[end_town][infix_road] + distances[infix_road][begin_town]);
            }
        }
    }

    long long min_cost       = INF;
    int min_cost_index = 0;
    for (int i = 0; i < TOWN_MAX; i++) {
        if (!used[i]) continue;

        int sum_cost   = 0;
        for (int j = 0; j < TOWN_MAX; j++) {
            if (!used[j]) continue;
            sum_cost += distances[i][j];
        }

        if (sum_cost < min_cost) {
            min_cost       = sum_cost;
            min_cost_index = i;
        }
    }

    std::cout << min_cost_index << " " << min_cost << std::endl;
}