Problem:
泥棒

宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。

風呂敷が耐えられる重さ W、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が W を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。

Input

複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。

W
N
v1,w1
v2,w2
:
vN,wN

１行目に風呂敷の耐えられる重さを表す整数 W (W ≤ 1,000)、２行目にお宝の数 N (1 ≤ N ≤ 1,000) が与えられます。続く N 行に i 番目のお宝の価値を表す整数 vi (0 ≤ vi ≤ 10,000) とその重さを表す整数 wi (0 ≤ wi ≤ W) の組がそれぞれ１行に与えられます。

W が 0 のとき入力の最後とします。データセットの数は 50 を超えません。

Output

各データセットに対して以下のように出力して下さい。

Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和

Sample Input

50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0

Output for the Sample Input

Case 1:
220
49
Case 2:
220
49

Solution in Ruby (judge verdict: Runtime Error)

class Knapsack
	def initialize(items, budget)
		p @items = items.sort_by{|c, v| -v.to_f / c}
		@budget = budget

		@left_value = 0
		@left_cost = 0
		i = 0
		while i < @items.size
			c, v = @items[i]
			break if @left_cost + c > @budget
			@left_cost += c
			@left_value += v
			i += 1
		end

		@l = @r = i
		@states = []
		@lower_bound = @left_value
		@opt_cost = @left_cost 
	end

	def solve
		return @left_value if @left_cost == @budget || @l == @items.size

		@states << [@left_cost, @left_value]
		@states << [@left_cost + @items[@l][0], @left_value + @items[@l][1]]
	
		loop {
			if @r < @items.size - 1
				@r += 1
				@states += @states.map{|c, v|
					[c + @items[@r][0], v + @items[@r][1]]
				}
			end
	
			if @l > 0
				@l -= 1
				@left_cost -= @items[@l][0]
				@left_value -= @items[@l][1]
				@states += @states.map{|c, v|
					[c - @items[@l][0], v - @items[@l][1]]
				}
			end

			prun
			update_lower_bound
	
			break if @l == 0 && @r == @items.size-1
		}
	
		return [@opt_cost, @lower_bound]
	end

private
	def upper_bound(cost, value)
		if cost <= @budget
			if @r == @items.size-1
				value
			else
				value + (@budget - cost).to_f * @items[@r+1][1] / @items[@r+1][0]
			end
		else
			if @l == 0
				value
			else
				value + (@budget - cost).to_f * @items[@l-1][1] / @items[@l-1][0]
			end
		end
	end

	def prun
		@states.reject!{|c, v|
			next true if c - @left_cost > @budget
			next true if upper_bound(c, v) <= @lower_bound
			false
		}
		hash = Hash.new(0)
		@states.each{|c, v|
			hash[c] = v if v > hash[c]
		}
		@states = hash.to_a
	end

	def update_lower_bound
		@states.each{|c, v|	
			if c <= @budget && v > @lower_bound
				@lower_bound = v 
				@opt_cost = c
			end
		}
	end
end

def knapsack(items, budget, mode = :normal)
	cost_group = items.group_by(&:first)
	items = cost_group.map{|c, group|
		group.sort_by(&:last).last(budget / c)
	}.inject([], &:+)

	case mode
	when :normal
		return _knapsack_normal(items, budget) 
	when :core
		return _knapsack_core(items, budget)
	else
		raise "unknown mode"
	end
end

def _knapsack_normal(items, budget)
	table = (0..1).map{ Array.new(budget+1, 0) }
	for i in 0..items.size-1
		c, v = items[i]
		for j in 0..budget
			x = table[0][j]
			y = (j >= c ? table[0][j-c] + v : 0)
			table[1][j] = x > y ? x : y
		end
		table << table.shift
	end
	c = (1..budget).max_by{|i| table[0][i]}
	[c, table[0][c]]
end

def _knapsack_core(items, budget, mode = :normal)
	if mode == :drop_useless
		cost_group = items.group_by(&:first)
		items = cost_group.map{|c, group|
			group.sort_by(&:last).last(budget / c)
		}.inject([], &:+)
	end

	k = Knapsack.new(items, budget)
	k.solve
end

i = 1
loop {
	w = gets.to_i
	break if w == 0

	n = gets.to_i
	items = []
	n.times { items << gets.split(",").reverse.map(&:to_i) }
	
	c, v = knapsack(items, w, :normal)
	puts "Case #{i}:"
	puts v
	puts c
	i += 1
}