Go: package main

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

const MaxW = 1000
const MaxN = 1000

type Tuple struct {
	Value  int
	Weight int
}

func nextLine(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

func solve(w int, n int, vws []Tuple) Tuple {
	var dp [MaxN + 1][MaxW + 1]int

	for i := 0; i < n; i++ {
		for j:= w; j > 0; j-- {
			if j < vws[i].Weight {
				dp[i + 1][j] = dp[i][j]
			} else {
				dp[i + 1][j] = int(math.Max(float64(dp[i][j]), float64(dp[i][j - vws[i].Weight] + vws[i].Value)))
			}
		}
	}

	maxValue := dp[n][w]
	minWeight := w

	for j := w - 1; j > 0; j-- {
		if maxValue == dp[n][j] {
			minWeight = j
		} else {
			break
		}
	}

	return Tuple{Value: maxValue, Weight: minWeight}
}

func main() {
	var sc = bufio.NewScanner(os.Stdin)
	index := 1
	for {
		var w, n int
		w, _ = strconv.Atoi(nextLine(sc))
		if w == 0 {
			return
		}
		n, _ = strconv.Atoi(nextLine(sc))

		vws := make([]Tuple, n, n)
		for i := 0; i < n; i++ {
			array := strings.Split(nextLine(sc), ",")
			v, _ := strconv.Atoi(array[0])
			w, _ := strconv.Atoi(array[1])
			vws[i] = Tuple{Value: v, Weight: w}
		}

		t := solve(w, n, vws)
		fmt.Printf("Case %d:\n", index)
		fmt.Println(t.Value)
		fmt.Println(t.Weight)
		index++
	}
}

C++: #include <cstdio>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

#define INF (1<<29)
#define mp make_pair
#define pb push_back

typedef vector<int> vi;
typedef vector<vi> vii;
typedef pair<int,int> pii;

int main(){
	int W;
	for( int n = 1; cin >> W; n++ ){
		if( W == 0 ) break;
		int N;
		cin >> N;
		vi v(N), w(N);
		for( int i = 0; i < N; i++ ){
			//cin >> v[i] >> "," >> w[i];
			scanf("%d,%d", &v[i], &w[i]);
		}
		// DP
		pii ans = mp(0,INF);
		vector<vector<pii> > dp(N+1, vector<pii>(W+1,mp(0,0)));
		for( int i = 1; i <= N; i++ ){
			for( int j = 1; j <= W; j++ ){
				if( j-w[i-1] < 0 ){
					dp[i][j].first = dp[i-1][j].first;
					dp[i][j].second = dp[i-1][j].second;
				}else{
					if( dp[i-1][j].first <= dp[i-1][j-w[i-1]].first+v[i-1] ){
						dp[i][j] = mp(dp[i-1][j-w[i-1]].first+v[i-1], dp[i-1][j-w[i-1]].second+w[i-1]);
					}else{
						dp[i-1][j] = mp(dp[i-1][j].first, dp[i-1][j].second);
					}
				}
				if( (ans.first == dp[i][j].first && ans.second> dp[i][j].second) || ans.first < dp[i][j].first ){
					ans = dp[i][j];
				}
			}
		}
		cout << "Case " << n << ":" << endl;
		cout << ans.first << endl;
		cout << ans.second << endl;
	}
}

C++: #include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <cctype>
 
#include <iostream>
#include <vector>
#include <deque>
#include <queue>
#include <map>
#include <algorithm>
 
using namespace std;
 
//#define deb_table(arr, w, h) rep(w_n, w){  rep(h_n, h) {cout << arr[w][h] << " "  } cout << endl; }
#define rep(i, n) for(int i = 0; i < n; i++)
 
// P(価値, 重さ)
typedef pair<int ,int> P;
 
class data
{
    public:
        int v;
        int w;
    public:
        data(int a, int b){ v=a; w=b;}
};
 
int case_num=1;
/*
風呂敷の耐えられる重さW(1000 以下)
お宝の数 N
お宝 1 の価値(整数), お宝 1 の重さ( ＜ W:整数)
お宝 2 の価値(整数), お宝 2 の重さ( ＜ W:整数)
.
.
.
お宝 N の価値(整数), お宝 N の重さ( ＜ W:整数)
*/
 
int max( int a, int b)
{
    if(a > b) { return a;}
    else { return b; }
}
 
//
int solve()
{
    int w,n;
    vector<data> v;
    cin >> w;
    //終わりのときは-1を返す
    if(w == 0) { return -1; }
 
    cin >> n;
    int value, weight;
 
    //int dp[n+1][w+1];
    //dp[考えたインデックス][重さ]
    //インデックスは０から数えてnまで　=> [n+1]
    //重さは０から数えてwまで        　=> [w+1]
    int dp[n+1][w+1];
    //dp init
    rep(i,n+1)rep(j,w+1) dp[i][j] = 0;  
 
    rep(i, n)
    {
        scanf("%d,%d" ,&value, &weight);
        v.push_back( data(value, weight) );
    }
 
    //dp[何番目まで考えたか][重さ] = 最大値
 
    rep(i,n+1)
    {
        rep(j,w+1)
        {
            //dp[i][j]から二つ分岐、分岐先ではmaxをとる
            if(0 <= i && i < n && 0 <= j && j  <= w )
            {
                dp[i+1][j] = max(dp[i+1][j] , dp[i][j]);
                if ( j+v[i+1].w <= w )
                {
                    dp[i+1][j + v[i+1].w] = max(dp[i+1][j + v[i+1].w] , dp[i][j] + v[i+1].v);
                }
            }
        }
    }
    /*
    rep(i,n+1){
        cout << "[";
        rep(j,w+1){
            cout << dp[i][j] << " ";
        }
        cout << "]" << endl;
    }
    */
    //maxを取る値の最小の重さを探す
    int least_weight;
    rep(j,w){
         if(dp[n][j] < dp[n][j+1])
         {
             least_weight= j+1;
         }
    }
   
    cout << "Case " << case_num << ":" << endl;
    cout << dp[n][w] << endl;
    cout << least_weight<< endl;
    return 0;
}
 
int main()
{
    while (1)
    {
        if(solve() == -1){ break;};
        case_num++;
    }
}

C++: #include <iostream>
#include <cstdio>
#include <cstring>
#include <utility>

using namespace std;

pair<int, int> max(const pair<int, int> &a, const pair<int, int> &b) {
    if (a.first == b.first ? a.second < b.second : a.first > b.first) {
        return a;
    } else {
        return b;
    }
}

#define MAX_W 1001

int main() {
    int W;
    int case_n = 1;
    while (cin >> W, W != 0) {
        int N; cin >> N;
        pair<int, int> dp[N][W+1];
        for (int i = 0; i < N; i++) 
            for (int j = 0; j <= W; j++) 
                dp[i][j] = pair<int, int>(0, 0); // 価値、 重さ
        int value[N];
        int weight[N];
        for (int i = 0; i < N; i++) {
            scanf("%d,%d", value+i, weight+i);
        }

        for (int i = 1; i < N; i++) {
            for (int j = 0; j <= W; j++) {
                if (j < weight[i]) {
                    dp[i][j] = dp[i-1][j];
                } else {
                    dp[i][j] = max(dp[i-1][j], 
                            make_pair(dp[i-1][j-weight[i]].first + value[i], 
                                      dp[i-1][j-weight[i]].second + weight[i]));
                }
            }
        }

        cout << "Case " << case_n << ":" << endl;
        cout << dp[N-1][W].first << endl;
        cout << dp[N-1][W].second << endl;
        case_n++;
    }
    return 0;
}

C++: #include <string>
#include <iostream>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <vector>
 
using namespace std;
 

int main(){
	int n = 1;

	while(true){
		int W, N;
		cin >> W;
		if(W == 0){
			break;
		}

		cin >> N;
		int w[1001];
		int v[1001];
		for(int i = 0; i < N; i++){
			scanf("%d,%d", &v[i], &w[i]);
		}
		vector<int> best(W+1);
		best.assign(best.size(), 0);
		for(int i = 0; i < N; i++){
			for(int j = W; j >= 0; j--){
				if(j == 0 || best[j] != 0){
					if(j+w[i] <= W){
						best[j+w[i]] = best[j]+v[i];
//						cout << "best[" << j+w[i] << "]:" << best[j+w[i]] << endl;
					}
				}
			}
		}
		int m = W;
		for(int i = W; i >= 0; i--){
			if(best[i] >= best[m]){
				m = i;
			}
		}
		cout << "Case " << n++ << ":" << endl;
		cout << best[m] << endl;
		cout << m << endl;
	}
  
    return 0;
}