submission_id string | problem_id string | status string | code string | input string | output string | problem_description string |
|---|---|---|---|---|---|---|
s230884448 | p00042 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
W = int(stdin.readline().strip())
if not W:
break
N = int(stdin.readline().strip())
data = []
for _ in xrange(N):
data.append([int(s) for s in stdin.readline().strip().split(',')])
value, weight = 0, W
for i in xrange(1, N+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for v, w in cmb:
tv += v
tw += w
if W >= tw and (tv > value) or (tv == value and tw < weight):
value, weight = tv, tw
print('Case {}:\n{}\n{}'.format(case, value, weight)) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s440201306 | p00042 | Time Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
W = int(stdin.readline().strip())
if not W:
break
N = int(stdin.readline().strip())
data = []
for _ in xrange(N):
data.append([int(s) for s in stdin.readline().strip().split(',')])
data.sort(key=lambda (v,w): w)
value, weight = 0, W
for i in xrange(1, N+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for v, w in cmb:
tv += v
tw += w
if W < tw:
break
if W >= tw and (tv > value) or (tv == value and tw < weight):
value, weight = tv, tw
print('Case {}:\n{}\n{}'.format(case, value, weight)) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s885787464 | p00042 | Memory Limit Exceeded | from itertools import combinations
case = 0
while True :
limit = int(input())
if limit == 0 : break
case += 1
number = int(input())
value, weight = [], []
for _ in range(number) :
a, b = input().split(',')
value.append(int(a))
weight.append(int(b))
temp1, temp2 = [], []
for _ in range(1, number+1) :
temp1.append(list(combinations(value, _)))
temp2.append(list(combinations(weight, _)))
temp1, temp2 = sum(temp1, []), sum(temp2, [])
value, weight = [], []
for _ in temp1 : value.append(sum(_))
for _ in temp2 : weight.append(sum(_))
result = [0, 0]
for _ in range(len(temp1)) :
if result[0] < value[_] and weight[_] <= limit :
result = value[_], weight[_]
elif result[0] == value and weight[_] < result[1] :
result = value[_], weight[_]
print('Case {}:'.format(case))
print(result[0])
print(result[1]) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s785286723 | p00042 | Memory Limit Exceeded | from itertools import combinations
case = 0
while True :
limit = int(input())
if limit == 0 : break
case += 1
number = int(input())
value, weight = [], []
for _ in range(number) :
a, b = input().split(',')
value.append(int(a))
weight.append(int(b))
result = [0, 0]
for _ in range(1, number+1) :
temp1 = [sum(_2) for _2 in list(combinations(value, _))]
temp2 = [sum(_2) for _2 in list(combinations(weight, _))]
for _2 in range(len(temp1)) :
if (result[0] < temp1[_2] and temp2[_2] <= limit) or (result[0] == temp1[_2] and temp2[_2] < result[1]) : result = temp1[_2], temp2[_2]
print('Case {}:'.format(case))
print(result[0])
print(result[1]) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s454438147 | p00042 | Memory Limit Exceeded | from itertools import combinations
from collections import deque
case = 0
while True :
limit = int(input())
if limit == 0 : break
case += 1
number = int(input())
value, weight = deque(), deque()
for _ in range(number) :
a, b = input().split(',')
value.append(int(a))
weight.append(int(b))
result = [0, 0]
for _ in range(1, number+1) :
temp1 = [sum(_2) for _2 in deque(combinations(value, _))]
temp2 = [sum(_2) for _2 in deque(combinations(weight, _))]
for _2 in range(len(temp1)) :
if (result[0] < temp1[_2] and temp2[_2] <= limit) or (result[0] == temp1[_2] and temp2[_2] < result[1]) : result = temp1[_2], temp2[_2]
print('Case {}:'.format(case))
print(result[0])
print(result[1]) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s835211734 | p00042 | Memory Limit Exceeded | from itertools import combinations
case = 0
while True :
limit = int(input())
if limit == 0 : break
case += 1
number = int(input())
value, weight = [], []
for _ in range(number) :
a, b = input().split(',')
value.append(int(a))
weight.append(int(b))
result = [0, 0]
for _ in range(1, number+1) :
for a, b in zip(list(combinations(value, _)), list(combinations(weight, _))) :
if (result[0] < sum(a) and sum(b) <= limit) or (result[0] == sum(a) and sum(b) < result[1]) :
result = sum(a), sum(b)
print('Case {}:'.format(case))
print(result[0])
print(result[1]) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s780743242 | p00042 | Memory Limit Exceeded |
import sys
import itertools
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def solv(treasures, w_limit):
comb = t_combinations(treasures)
ts = filter(lambda x: t_sum_weight(x) <= w_limit, comb)
max_value = max(map(lambda x: t_sum_value(x), ts))
ts2 = filter(lambda x: t_sum_value(x) == max_value, ts)
if len(ts2) == 1:
return (t_sum_value(ts2[0]), t_sum_weight(ts2[0]))
else:
rt = rightest(ts2)
return (t_sum_value(rt), t_sum_weight(rt))
def t_combinations(t):
l = len(t)
r = []
for x in range(1, l+1):
for y in itertools.combinations(t, x):
r.append(y)
return r
def t_sum_weight(ts):
return sum(map(lambda x: x.weight, ts))
def t_sum_value(ts):
return sum(map(lambda x: x.value, ts))
def rightest(tss):
return reduce(lambda a, b: take_right(a, b), tss)
def take_right(a, b):
if t_sum_weight(a) <= t_sum_weight(b):
return a
else:
return b
case = 0
while True:
weight_limit = int(sys.stdin.readline())
case += 1
if weight_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, weight_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s874921447 | p00042 | Memory Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
WEIGHT = int(stdin.readline().strip())
if not WEIGHT:
break
NUM = int(stdin.readline().strip())
data = []
for _ in range(NUM):
data.append([int(s) for s in stdin.readline().strip().split(',')])
total = []
for i in range(1, NUM+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for value, weight in cmb:
tv += value
tw += weight
if WEIGHT >= tw:
total.append((tv, tw))
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw)) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s393970889 | p00042 | Memory Limit Exceeded | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count, combinations
for case in count(1):
WEIGHT = int(stdin.readline().strip())
if not WEIGHT:
break
NUM = int(stdin.readline().strip())
data = []
for _ in xrange(NUM):
data.append([int(s) for s in stdin.readline().strip().split(',')])
total = []
for i in xrange(1, NUM+1):
for cmb in combinations(data, i):
tv, tw = 0, 0
for value, weight in cmb:
tv += value
tw += weight
if WEIGHT >= tw:
total.append((tv, tw))
if len(total):
total = [max(total, key=lambda(tv, tw): (tv, -tw))]
if len(total):
tv, tw = max(total, key=lambda(tv, tw): (tv, -tw))
else:
tv, tw = 0, 0
print('Case {}:\n{}\n{}'.format(case, tv, tw))
del data
del total | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s828116728 | p00042 | Accepted | from sys import stdin
case = 0
while(True):
case += 1
W = int(stdin.readline())
if not W: break
print("Case %d:"%case)
N = int(stdin.readline())
v = [0] * N
w = [0] * N
dp = [[0]*(W + 1) for _ in range(N + 1)]
for k in range(N):
v[k], w[k] = map(int, stdin.readline().split(","))
for i in range(N-1,-1,-1):
for j in range(W+1):
if j < w[i]:
dp[i][j] = dp[i + 1][j]
else:
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i])
print(dp[0][W])
for i in range(W+1):
if dp[0][i] == dp[0][W]: print(i); break
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s435772392 | p00042 | Accepted | caseN = 0
while True:
caseN += 1
W = int(input())
if W == 0: break
N = int(input())
tr = [list(map(int, input().split(','))) for _ in range(N)]
dp = [0 for x in range(W+1)]
for x in range(N):
for y in range(W,tr[x][1]-1,-1):
dp[y] = max(dp[y], dp[y-tr[x][1]] + tr[x][0])
sum_weight = 0
sum_value = 0
ind = N%2
for x in range(W+1):
if dp[x] > sum_value:
sum_weight = x
sum_value = dp[x]
print("Case ", caseN, ":", sep='')
print(sum_value)
print(sum_weight) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s379050628 | p00042 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from itertools import *
from sys import *
def solve(n,w):
lp,lw = [],[]
for i in xrange(n):
s = map(int, raw_input().split(","))
lp.append(s[0])
lw.append(s[1])
c = [-1]*(w+1)
c[0] = 0
for i in xrange(n):
for j in reversed(xrange(w)):
if c[j] == -1 or j+lw[i] > w : continue
c[j+lw[i]] = max( c[j]+lp[i], c[j+lw[i]] )
print max(c)
print c.index(max(c))
case = 1
while True:
w = int(raw_input())
if w == 0: break
n = int(raw_input())
print "Case %d:" % (case)
solve(n,w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s306275546 | p00042 | Accepted | case=0
while True:
try:
case+=1
W=input()
if W==0:
break
N=input()
data=[[0 for i in range(2)] for j in range(N)]
for i in range(N):
data[i][0],data[i][1]=map(int,raw_input().split(","))
table=[[-1 for i in range(W+1)] for j in range(N)]
table[0][0],table[0][data[0][1]]=0,data[0][0]
for i in range(1,N):
for j in range(W+1):
table[i][j]=table[i-1][j]
for j in range(W+1):
if table[i-1][j]!=-1 and j+data[i][1]<=W and\
table[i-1][j]+data[i][0]>table[i][j+data[i][1]]:
table[i][j+data[i][1]]=table[i-1][j]+data[i][0]
print "Case "+str(case)+':'
m=max(table[N-1])
print m
print table[N-1].index(m)
except:
break | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s380289653 | p00042 | Accepted | def sol():
dp=[0]*(w+1)
for i in l:
for j in range(w-i[1],0,-1):
if(dp[j]!=0):
dp[j+i[1]]=max(dp[j+i[1]],dp[j]+i[0])
dp[i[1]]=max(dp[i[1]],i[0])
print "Case %d:"%cnt
print max(dp)
print dp.index(max(dp))
cnt=0
while 1:
w=int(raw_input())
cnt+=1
if w==0:
break
n=int(raw_input())
l=[]
for i in range(n):
l.append(map(int,raw_input().split(',')))
sol() | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s466229830 | p00042 | Accepted | case = 1
while True:
w_limit = int(input())
if not w_limit:
break
n = int(input())
treasures = [tuple(map(int, input().split(','))) for _ in range(n)]
furoshiki = [0] * (w_limit + 1)
for v, w in treasures:
for j in range(w_limit, w - 1, -1):
furoshiki[j] = max(furoshiki[j], furoshiki[j - w] + v)
max_v = max_v_w = 0
for w in range(w_limit + 1):
if furoshiki[w] > max_v:
max_v = furoshiki[w]
max_v_w = w
print('Case {}:'.format(case))
print(max_v)
print(max_v_w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s982053075 | p00042 | Accepted | if __name__ == '__main__':
W = int(input())
v = [0]
w = [0]
d = []
m = []
counter = 1
result = []
while W != 0:
N = int(input())
v[:] = [0]
w[:] = [0]
d[:] = []
m[:] = []
"""the initialization of array d"""
for x in range(W + 1):
temp = [0] * (N + 1)
d.append(temp)
for x in range(W + 1):
temp = [0] * (N + 1)
m.append(temp)
"""prepare the dataset"""
for x in range(N):
i = input().split(',')
v.append(int(i[0]))
w.append(int(i[1]))
"""processing"""
for weight in range(W + 1):
for kind in range(N + 1):
if weight != 0 and kind != 0:
if w[kind] > weight:
d[weight][kind] = d[weight][kind - 1]
m[weight][kind] = m[weight][kind - 1]
else:
if d[weight - w[kind]][kind - 1] + v[kind] > d[weight][kind - 1]:
d[weight][kind] = d[weight - w[kind]][kind - 1] + v[kind]
m[weight][kind] = m[weight - w[kind]][kind - 1] + w[kind]
elif d[weight - w[kind]][kind - 1] + v[kind] == d[weight][kind - 1]:
d[weight][kind] = d[weight][kind - 1]
if m[weight - w[kind]][kind - 1] + w[kind] < m[weight][kind - 1]:
m[weight][kind] = m[weight - w[kind]][kind- 1] + w[kind]
else:
m[weight][kind] = m[weight][kind - 1]
else:
d[weight][kind] = d[weight][kind - 1]
m[weight][kind] = m[weight][kind - 1]
result.append("Case " + counter.__str__() + ":")
result.append(d[W][N])
result.append(m[W][N])
W = int(input())
counter += 1
for line in result:
print(line) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s110973062 | p00042 | Accepted | cnt=0
while 1:
cnt+=1
w=int(raw_input())
if w==0:break
n=int(raw_input())
tre=[map(int,raw_input().split(",")) for _ in xrange(n)]
dp=[[0]*(w+1) for _ in xrange(n+1)]
dp[0][0]=0
for i in xrange(n):
for j in xrange(w+1):
if tre[i][1]>j:dp[i+1][j]=dp[i][j]
else:
dp[i+1][j]=max(dp[i][j],dp[i][j-tre[i][1]]+tre[i][0])
print('Case '+str(cnt)+":")
print(dp[n][w])
print(dp[n].index(dp[n][w])) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s616819874 | p00042 | Accepted | for i in range(1, 100):
W = int(input())
if not W:
break
N = int(input())
data = [tuple(map(int, input().split(','))) for _ in range(N)]
dp = [[[0, 0] for j in range(W + 1)] for i in range(N + 1)]
print('Case {0}:'.format(i))
for i in range(1, N + 1):
for j in range(W + 1):
if data[i - 1][1] <= j:
pt = dp[i - 1][j - data[i - 1][1]][:]
for k in range(2):
pt[k] += data[i - 1][k]
dpt = dp[i - 1][j][:]
if pt[0] > dpt[0]:
dp[i][j] = pt
elif dpt[0] > pt[0]:
dp[i][j] = dpt
else:
dp[i][j] = pt if pt[1] < dpt[1] else dpt
else:
dp[i][j] = dp[i - 1][j]
for i in range(2):
print(dp[N][W][i]) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s870145826 | p00042 | Accepted | class Knapack(object):
def __init__(self, data, limit):
self.limit = limit
data_size = len(data)
self.C = [[0]*(limit+1) for _ in range(data_size+1)]
self.data = data[:]
def solve(self):
for i in range(1, len(self.data)+1):
i_value = self.data[i-1][0]
i_weight = self.data[i-1][1]
for w in range(1, self.limit+1):
if i_weight <= w:
if i_value + self.C[i-1][w-i_weight] > self.C[i-1][w]:
self.C[i][w] = i_value + self.C[i-1][w-i_weight]
else:
self.C[i][w] = self.C[i-1][w]
else:
self.C[i][w] = self.C[i-1][w]
if __name__ == '__main__':
# ??????????????\???
# limit = 50
# data = [[60, 10], [100, 20], [120, 30], [210, 45], [10, 4]]
case_no = 1
while True:
limit = int(input())
if limit == 0:
break
num_of_items = int(input())
data = []
for i in range(num_of_items):
data.append(list(map(int, input().split(','))))
# ????????????????????????????§£???
ks = Knapack(data, limit)
ks.solve()
# ???????????¨???
target = ks.C[len(data)][limit]
weight = limit
for w in range(limit, 0, -1):
if ks.C[len(data)][w] == target:
weight = w
print('Case {0}:'.format(case_no))
print('{0}\n{1}'.format(target, weight))
case_no += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s971653222 | p00042 | Accepted | Case_num = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
List = [[0] * (W + 1)] * (N + 1) #????????? w??\????????°n??\?????§??????????????????????????§
for i in range(1,N + 1):
v,w = map(int,input().split(","))
for j in range(W,w - 1,-1):
List[i][j] = max(List[i - 1][j] ,List[i - 1][j - w] + v)
print("Case",Case_num,end = ":\n")
print(List[N][W])
print(List[N].index(List[N][W]))
Case_num += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s751822112 | p00042 | Accepted | cnt=0
while True:
cnt+=1
W=int(input())
if W==0:
break
n=int(input())
dp=[0]*(W+1)
for i in range(n):
v,w=map(int,input().split(','))
for j in range(W,w-1,-1):
dp[j]=max(dp[j],dp[j-w]+v)
wgt=0
for i in range(W+1):
if max(dp)==dp[i]:
wgt=i
break
print("Case {0}:".format(cnt))
print(max(dp))
print(wgt) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s427614149 | p00042 | Accepted | cnt=0
while True:
cnt+=1
W=int(input())
if W==0:
break
n=int(input())
dp=[0]*(W+1)
for i in range(n):
v,w=map(int,input().split(','))
for j in range(W,w-1,-1):
dp[j]=max(dp[j],dp[j-w]+v)
wgt=0
md=max(dp)
for i in range(W+1):
if md==dp[i]:
wgt=i
break
print("Case {0}:".format(cnt))
print(md)
print(wgt) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s068463580 | p00042 | Accepted | cnt = 0
while True:
cnt += 1
maxweight = int(input())
if maxweight == 0:
break
length = int(input())
tresure = []
dp = [[0 for n in range(length+1)] for m in range(maxweight + 1)]
answeight = 0
ansvalue = 0
for l in range(length):
v,w = (int(n) for n in input().split(","))
tresure.append([v,w])
for outer in range(length + 1):
if outer == 0:
continue
weight = tresure[outer-1][1]
value = tresure[outer-1][0]
dp[weight][outer] = max(dp[weight][outer],value)
for inner in range(maxweight + 1):
if dp[inner][outer - 1] != 0:
beforevalue = dp[inner][outer - 1]
beforeweight = inner
dp[inner][outer] = max(beforevalue,dp[inner][outer])
if beforeweight + weight <= maxweight:
nowvalue = dp[beforeweight + weight][outer]
dp[beforeweight + weight][outer] = max(nowvalue,beforevalue+value)
#print(dp)
for a in range(maxweight+1):
#print(dp[a][length])
if ansvalue < dp[a][length]:
ansvalue = dp[a][length]
answeight = a
print("Case {0}:".format(cnt))
print(ansvalue)
print(answeight) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s171017437 | p00042 | Accepted | c=1
while 1:
W=int(input())
if W==0:break
n=int(input())
dp=[0]*(W+1)
for i in range(n):
v,w = map(int, input().split(','))
for j in range(W,w-1,-1):
dp[j]=max(dp[j-w]+v,dp[j])
for i in range(W+1):
if dp[W]==dp[i]:break
print('Case %d:\n%d\n%d'%(c,dp[W],i))
c+=1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s763289547 | p00042 | Accepted | c=1
while 1:
W=int(input())
if W==0:break
dp=[0]*(W+1)
for i in range(int(input())):
v,w=map(int, input().split(','))
for j in range(W,w-1,-1):
if dp[j]<dp[j-w]+v:dp[j]=dp[j-w]+v
for i in range(W+1):
if dp[W]==dp[i]:break
print('Case %d:\n%d\n%d'%(c,dp[W],i))
c+=1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s614525907 | p00042 | Accepted | ctr = 1
while True:
w = int(input())
if w==0: break
dp = [0]*(w+1)
n = int(input())
for i in range(n):
vi, wi = map(int, input().split(","))
for j in range(w,wi-1,-1):
dp[j] = max(dp[j],dp[j-wi]+vi)
print("Case "+str(ctr)+":")
print(max(dp))
print(dp.index(max(dp)))
ctr += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s370728561 | p00042 | Accepted | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0042
??\?£?
"""
class Knapack(object):
def __init__(self, data, limit):
self.limit = limit
data_size = len(data)
self.C = [[0]*(limit+1) for _ in range(data_size+1)]
self.data = data[:]
def solve(self):
for i in range(1, len(self.data)+1):
i_value = self.data[i-1][0]
i_weight = self.data[i-1][1]
for w in range(1, self.limit+1):
if i_weight <= w:
if i_value + self.C[i-1][w-i_weight] > self.C[i-1][w]:
self.C[i][w] = i_value + self.C[i-1][w-i_weight]
else:
self.C[i][w] = self.C[i-1][w]
else:
self.C[i][w] = self.C[i-1][w]
if __name__ == '__main__':
# ??????????????\???
# limit = 50
# data = [[60, 10], [100, 20], [120, 30], [210, 45], [10, 4]]
case_no = 1
while True:
limit = int(input())
if limit == 0:
break
num_of_items = int(input())
data = []
for i in range(num_of_items):
data.append(list(map(int, input().split(','))))
# ????????????????????????????§£???
ks = Knapack(data, limit)
ks.solve()
# ???????????¨???
target = ks.C[len(data)][limit]
weight = limit
for w in range(limit, 0, -1):
if ks.C[len(data)][w] == target:
weight = w
print('Case {0}:'.format(case_no))
print('{0}\n{1}'.format(target, weight))
case_no += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s711358640 | p00042 | Accepted | # -*- coding: utf-8 -*-
import sys
import os
import math
import itertools
case = 1
for s in sys.stdin:
# capacity
C = int(s)
if C == 0:
break
N = int(input())
V = [0]
W = [0]
# max value table of (N+1) x (C+1)
VT = [[0 for i in range(C+1)] for j in range(N+1)]
WT = [[0 for i in range(C+1)] for j in range(N+1)]
for i in range(N):
v, w = map(int, input().split(','))
V.append(v)
W.append(w)
for i in range(1, N+1):
for j in range(1, C+1):
if j >= W[i]:
# can load
value_on_load = VT[i-1][j - W[i]] + V[i]
value_not_load = VT[i-1][j]
weight_on_load = WT[i-1][j - W[i]] + W[i]
weight_not_load = WT[i-1][j]
if value_on_load > value_not_load:
VT[i][j] = value_on_load
WT[i][j] = weight_on_load
elif value_on_load == value_not_load:
VT[i][j] = value_on_load
WT[i][j] = min(weight_on_load, weight_not_load)
else:
VT[i][j] = value_not_load
WT[i][j] = weight_not_load
else:
VT[i][j] = VT[i - 1][j]
WT[i][j] = WT[i - 1][j]
print('Case {}:'.format(case))
case += 1
print(VT[N][C])
print(WT[N][C]) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s427555448 | p00042 | Accepted | case = 0
while True:
W = int(input())
if W == 0:
break
N, case = int(input()), case + 1
items = [[0,0]] + [list(map(int, input().split(','))) for _ in range(N)]
C = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(1, N+1):
for w in range(1, W+1):
if items[i][1] <= w:
C[i][w] = max(items[i][0]+C[i-1][w-items[i][1]], C[i-1][w])
else:
C[i][w] = C[i-1][w]
maxv = max(C[-1])
print("Case {0}:\n{1}\n{2}".format(case, maxv, C[-1].index(maxv))) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s265169755 | p00042 | Accepted | # coding: utf-8
# Here your code !
count = 1
while 1:
W = int(input())
if W == 0:
break
N = int(input())
data =[]
dp = [[[-1,0]for i in range(W+1)]for i in range(N+1)]
for i in range(N):
data.append(input().split(","))
for i in range(W+1):
dp[N][i][0] = 0
for i in reversed(range(N)):
for capa in range(W+1):
if int(data[i][1]) > capa:
dp[i][capa][0] = dp[i+1][capa][0]
dp[i][capa][1] = dp[i+1][capa][1]
else:
dp[i][capa][0] = max(int(data[i][0])+dp[i+1][capa-int(data[i][1])][0],dp[i+1][capa][0])
dp[i][capa][1] = dp[i+1][capa][1]
if dp[i][capa][0] != dp[i+1][capa][0]:
dp[i][capa][1] = int(data[i][1])+dp[i+1][capa-int(data[i][1])][1]
print("Case " + str(count) +":")
print(max(max(dp))[0])
print(max(max(dp))[1])
count += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s079563928 | p00042 | Accepted | C_num = 1
while True:
Nap = []
W = int(input())
if W == 0:
break
N = int(input())
for i in range(N):
v,w = map(int,input().split(","))
Nap.append([v,w])
DP = [[0 for j in range(W + 1)] for i in range(N + 1)]
for i in range(1,N+1):
for j in range(W+1):
if j - Nap[i-1][1] >= 0:
DP[i][j] = max(DP[i-1][j],DP[i - 1][j - Nap[i - 1][1]] + Nap[i - 1][0])
else:
DP[i][j] = DP[i-1][j]
omo = DP[N].index(DP[N][W])
print("Case ",C_num,":",sep = "",end = "\n")
print(DP[N][W])
print(omo)
C_num += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s669720089 | p00042 | Accepted | c = 0
while True:
W = int(input())
if W == 0:
break
c += 1
N = int(input())
vl = [0]
wl = [0]
for i in range(N):
[v,w] = list(map(int,input().split(",")))
vl.append(v)
wl.append(w)
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(N+1):
for j in range(W+1):
if i == 0 or j == 0:
dp[i][j] = 0
else:
if wl[i] <= j:
dp[i][j] = max(dp[i-1][j-wl[i]] + vl[i], dp[i-1][j])
else:
dp[i][j] = dp[i-1][j]
ls = dp[N].copy()
ls.reverse()
max_w = W
for i in range(1,W+1):
if ls[i] == dp[N][W]:
max_w -= 1
else:
break
print("Case "+str(c)+":")
print(dp[N][W])
print(max_w) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s486034945 | p00042 | Accepted | out = []
cnt = 0
while True:
W = int(input())
if W == 0:
break
N = int(input())
v = []
w = []
C = list([0 for i in range(W + 1)] for j in range(N + 1))
for i in range(N):
n, m = list(map(int,input().split(",")))
v.append(n)
w.append(m)
for i in range(1, N + 1):
for j in range(1, W + 1):
if j - w[i - 1] < 0:
C[i][j] = C[i-1][j]
else:
C[i][j] = max(int(C[i-1][j]),int(C[i-1][j-w[i - 1]]+v[i - 1]))
for i in range(1,W+1):
if C[N][i] == C[N][W]:
min_wt = i
break
out.append([C[N][W] , min_wt])
cnt += 1
for cs in range(cnt):
print("Case "+str(cs+1)+":")
print(out[cs][0])
print(out[cs][1]) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s442756311 | p00042 | Accepted | import itertools
for dn in itertools.count(1):
W = int(input())
if W == 0: break
N = int(input())
d = [tuple(map(int, input().split(','))) for _ in range(N)]
v = [0 for _ in range(W + 1)]
for i in range(N):
for j in range(W, d[i][1] - 1, -1):
v[j] = max(v[j], v[j - d[i][1]] + d[i][0])
print("Case %d:\n%d\n%d" % (dn, max(v), v.index(max(v)))) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s280981375 | p00042 | Accepted | for c in range(1,51):
W = int(input())
if W == 0: break
N = int(input())
dp = [0 for w in range(W+1)]
for i in range(N):
v,w = map(int,input().split(','))
for j in range(W-w,-1,-1):
if dp[j] == 0 and j > 0: continue
dp[j+w] = max(dp[j+w], dp[j] + v)
ansv = answ = 0
for w,v in enumerate(dp):
if v > ansv:
ansv = v
answ = w
print('Case ' + str(c) + ':')
print(ansv)
print(answ)
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s502522999 | p00042 | Accepted | caseN = 0
while True:
caseN += 1
W = int(input())
if W == 0: break
N = int(input())
tr = [list(map(int, input().split(','))) for _ in range(N)]
dp = [0 for x in range(W+1)]
for x in range(N):
for y in range(W,tr[x][1]-1,-1):
dp[y] = max(dp[y], dp[y-tr[x][1]] + tr[x][0])
sum_weight = 0
sum_value = 0
ind = N%2
for x in range(W+1):
if dp[x] > sum_value:
sum_weight = x
sum_value = dp[x]
print("Case ", caseN, ":", sep='')
print(sum_value)
print(sum_weight)
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s254301131 | p00042 | Accepted | import itertools
case = 0
while True:
case += 1
w_max = int(input())
if w_max == 0:
break
n = int(input())
w = [0 for i in range(n)]
v = [0 for i in range(n)]
for i in range(n):
a, b = map(int, input().split(","))
v[i] = a
w[i] = b
dp = [[0 for j in range(w_max + 1)] for i in range(n + 1)]
for i in range(n)[::-1]:
for j in range(w_max + 1):
if j < w[i]:
dp[i][j] = dp[i + 1][j]
else:
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i])
print("Case ",case,":",sep="")
print(max(dp[0]))
print(dp[0].index(max(dp[0])))
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s651325012 | p00042 | Accepted | case = 0
while True:
case += 1
w_max = int(input())
if w_max == 0:
break
n = int(input())
w = [0 for i in range(n)]
v = [0 for i in range(n)]
for i in range(n):
a, b = map(int, input().split(","))
v[i] = a
w[i] = b
dp = [[0 for j in range(w_max + 1)] for i in range(n + 1)]
for i in range(n)[::-1]:
for j in range(w_max + 1):
if j < w[i]:
dp[i][j] = dp[i + 1][j]
else:
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i])
print("Case ",case,":",sep="")
print(max(dp[0]))
print(dp[0].index(max(dp[0])))
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s168753016 | p00042 | Accepted | case = 0
while True:
case += 1
W = int(input())
if (W == 0):
break
N = int(input())
vl = [0]
wl = [0]
for i in range(N):
(v,w) = tuple(map(int,input().split(",")))
vl.append(v)
wl.append(w)
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(1,N+1):
for j in range(1,W+1):
if j >= wl[i]:
dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-wl[i]] + vl[i])
else:
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
print("Case " + str(case) + ":")
print(dp[N][W])
for i in range(W+1):
if dp[N][i] == dp[N][W]:
print(i)
break
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s292542779 | p00042 | Accepted | c=0
while True:
W=int(input())#重さの上限
if W==0:
break
c+=1
N=int(input())#宝物の数
vl=[0]#価値のリスト
wl=[0]#重さのリスト
for i in range(N):
[v,w]=list(map(int,input().split(",")))#vとwのリストを作る
vl.append(v)
wl.append(w)
#横がW+1で縦がN+1の表を作成する
dp=[[0 for i in range(W+1)]for j in range(N+1)]
#表を埋める
for i in range(N+1):
for j in range(W+1):
if i==0 or j==0:
dp[i][j]=0
else:
if wl[i]<=j:
dp[i][j]=max(dp[i-1][j-wl[i]]+vl[i],dp[i-1][j])
else:
dp[i][j]=dp[i-1][j]
#print(dp)
ls=dp[N].copy()
ls.reverse()
#print(ls)
max_w=W
for i in range(1,W+1):
if ls[i]==dp[N][W]:
max_w-=1
else:
break
print("Case "+str(c)+":")
print(dp[N][W])
print(max_w)
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s298212389 | p00042 | Accepted | c=0
for W in iter(input,'0'):
c+=1
W=int(W)
dp=[0]*-~W
for _ in[0]*int(input()):
v,w=map(int,input().split(','))
for i in range(W,w-1,-1):
if dp[i]<dp[i-w]+v:dp[i]=dp[i-w]+v
for i in range(W+1):
if dp[W]==dp[i]:print(f'Case {c}:\n{dp[W]}\n{i}');break
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s661914681 | p00042 | Accepted | c=0
for W in iter(input,'0'):
c+=1
W=int(W)
dp=[0]*-~W
for _ in[0]*int(input()):
v,w=map(int,input().split(','))
for i in range(W,w-1,-1):
if dp[i]<dp[i-w]+v:dp[i]=dp[i-w]+v
print(f'Case {c}:\n{dp[W]}\n{dp.index(dp[W])}')
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s288328272 | p00042 | Accepted | c=0
for W in iter(input,'0'):
c+=1
W=int(W)
d=[0]*-~W
for _ in[0]*int(input()):
v,w=map(int,input().split(','))
for i in range(W,w-1,-1):
if d[i]<d[i-w]+v:d[i]=d[i-w]+v
print(f'Case {c}:\n{d[W]}\n{d.index(d[W])}')
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s419321881 | p00042 | Accepted | c=0
for W in iter(input,'0'):
c+=1
W=int(W)
d=[0]*-~W
for _ in[0]*int(input()):
v,w=map(int,input().split(','))
for i in range(W,w-1,-1):
t=d[i-w]+v
if d[i]<t:d[i]=t
print(f'Case {c}:\n{d[W]}\n{d.index(d[W])}')
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s716924762 | p00042 | Accepted | def f():
c=0
for W in iter(input,'0'):
c+=1
W=int(W)
d=[0]*-~W
for _ in[0]*int(input()):
v,w=map(int,input().split(','))
for i in range(W,w-1,-1):
if d[i]<d[i-w]+v:d[i]=d[i-w]+v
print(f'Case {c}:\n{d[W]}\n{d.index(d[W])}')
if'__main__'==__name__:f()
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s743976281 | p00042 | Accepted | def f():
c=0
for W in iter(input,'0'):
c+=1
W=int(W)
d=[0]*-~W
for _ in[0]*int(input()):
v,w=map(int,input().split(','))
for i in range(W,w-1,-1):
if d[i]<d[i-w]+v:d[i]=d[i-w]+v
print(f'Case {c}:\n{d[W]}\n{d.index(d[W])}')
f()
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s467078962 | p00042 | Accepted | """
0-1ナップザック
dp[i][j]...i個目までの宝で重さjの時の価値の最大
wi = wlst[i]...i個目の重さ
vi = vlst[i]...i個目の価値
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - wi] + vi) (wi <= j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) (wi > j)
"""
def main():
case = 0
while True:
w = int(input())
if not w:
break
case += 1
n = int(input())
vlst = [0]
wlst = [0]
for _ in range(n):
vin, win = map(int, input().split(","))
vlst.append(vin)
wlst.append(win)
dp = [[0 for _ in range(w + 1)] for _ in range(n + 1)]
for i in range(1, n + 1):
vi, wi = vlst[i], wlst[i]
dpi = dp[i]
dpim = dp[i - 1]
for j in range(1, w + 1):
if j >= wi:
dpi[j] = max(dpim[j], dpi[j - 1], dpim[j - wi] + vi)
else:
dpi[j] = max(dpim[j], dpi[j - 1])
print("Case " + str(case) + ":")
print(dp[n][w])
for i in range(w, -1, -1):
if dp[n][i] != dp[n][w]:
print(i + 1)
break
main()
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s170572248 | p00042 | Accepted | """
0-1ナップザック
wi = wlst[i]...i個目の重さ
vi = vlst[i]...i個目の価値
2次元
dp[i][j]...i個目までの宝で重さjの時の価値の最大
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - wi] + vi) (wi <= j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) (wi > j)
or
dp[j]...重さjの時の価値の最大
temp...1つ前のdp
dp[j] = max(dp[j], dp[j - 1], temp[j - wi] + vi) (wi <= j)
dp[j] = max(dp[j], dp[j - 1]) (wi > j)
"""
INF = 10 ** 20
def main():
case = 0
while True:
w = int(input())
if not w:
break
case += 1
n = int(input())
vlst = [0]
wlst = [0]
for _ in range(n):
vin, win = map(int, input().split(","))
vlst.append(vin)
wlst.append(win)
dp = [0 for _ in range(w + 1)]
for i in range(1, n + 1):
vi, wi = vlst[i], wlst[i]
temp = dp[:]
for j in range(1, w + 1):
if j >= wi:
dp[j] = max(dp[j], dp[j - 1], temp[j - wi] + vi)
else:
dp[j] = max(dp[j], dp[j - 1])
print("Case " + str(case) + ":")
print(dp[w])
print(dp.index(dp[w]))
main()
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s545275817 | p00042 | Accepted | """
0-1ナップザック
wi...i個目の重さ
vi...i個目の価値
2次元
dp[i][j]...i個目までの宝で重さjの時の価値の最大
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - wi] + vi) (wi <= j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) (wi > j)
1次元
dp[j]...重さjの時の価値の最大
dp[j] = max(dp[j], dp[j - wi] + vi) (wi <= j <= w)
wi <= j <= wについて更新(j < wiについては変化が無いため更新不要)
前から更新すると更新した結果を使って更新してしまうため後ろから更新
"""
INF = 10 ** 20
def main():
case = 0
while True:
w = int(input())
if not w:
break
case += 1
n = int(input())
dp = [0 for _ in range(w + 1)]
for i in range(1, n + 1):
vi, wi = map(int, input().split(","))
for j in range(w, wi - 1, -1):
dp[j] = max(dp[j], dp[j - wi] + vi)
print("Case " + str(case) + ":")
print(dp[w])
print(dp.index(dp[w]))
main()
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s837777010 | p00042 | Accepted | nCase = 0
while True:
W = int(input())
if W == 0: break
nCase += 1
N = int(input())
# [(value, weight), ... ]
items = [tuple(map(int, input().split(','))) for _ in range(N)]
bestValueFor = [0] * (W + 1) # item -> best value, idx -> capacity
for item in items:
for capa in reversed(range(W-item[1]+1)):
# if taken wins not taken
if bestValueFor[capa] + item[0] > bestValueFor[capa + item[1]]:
bestValueFor[capa + item[1]] = bestValueFor[capa] + item[0]
bestValue = max(bestValueFor)
bestWeight = bestValueFor.index(bestValue)
print('Case ',str(nCase),':',sep='')
print(bestValue)
print(bestWeight)
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s526520967 | p00042 | Accepted | # AOJ 0042 A Thief
# Python3 2018.6.22 bal4u
MAX = 1003
for cno in range(1, 100):
lim = int(input())
if lim == 0: break
print("Case ", cno, ":", sep='')
N = int(input())
vw = [(0, 0)]
for i in range(N):
v, w = list(map(int, input().split(',')))
vw.append((v, w))
V = [[0 for j in range(MAX)] for i in range(2)]
W = [[0 for j in range(MAX)] for i in range(2)]
k1, k2 = 0, 1
for i in range(1, N+1):
for j in range(1, lim+1):
v, w = vw[i]
if w > j:
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
else:
d = j - w
if V[k1][d] + v >= V[k1][j]:
V[k2][j] = V[k1][d] + v
W[k2][j] = W[k1][d] + w
else:
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
k1, k2 = k2, k1
print(V[k1][lim], W[k1][lim], sep='\n')
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s023745497 | p00042 | Accepted | # AOJ 0042 A Thief
# Python3 2018.6.22 bal4u
MAX = 1003
for cno in range(1, 100):
lim = int(input())
if lim == 0: break
print("Case ", cno, ":", sep='')
N = int(input())
V = [[0 for j in range(MAX)] for i in range(2)]
W = [[0 for j in range(MAX)] for i in range(2)]
k1, k2 = 0, 1
for i in range(1, N+1):
v, w = map(int, input().split(','))
for j in range(1, w):
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
for j in range(w, lim+1):
d = j - w
if V[k1][d] + v >= V[k1][j]:
V[k2][j] = V[k1][d] + v
W[k2][j] = W[k1][d] + w
else:
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
k1, k2 = k2, k1
print(V[k1][lim], W[k1][lim], sep='\n')
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s350144300 | p00042 | Accepted | case=0
while True:
case+=1
W=input()
if W==0:break
print "Case {}:".format(case)
dp=[0]*1001
w=[0]*1001
v=[0]*1001
n=input()
for i in xrange(n):
v[i],w[i]=map(int,raw_input().strip().split(","))
for i in xrange(n):
for j in xrange(W,-1,-1):
if j+w[i]<=W:
dp[j+w[i]]=max(dp[j+w[i]],dp[j]+v[i])
print max(dp)
print dp.index(max(dp)) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s569428033 | p00042 | Accepted | num=1
while True:
maxw=input()
if maxw==0:break
print "Case %d:"%num
dp,w,v=[0]*1001,[0]*1001,[0]*1001
n=input()
for i in xrange(n):
v[i],w[i]=map(int,raw_input().strip().split(","))
for i in xrange(n):
for j in xrange(maxw,-1,-1):
if j+w[i]<=maxw:
dp[j+w[i]]=max(dp[j+w[i]],dp[j]+v[i])
print max(dp)
print dp.index(max(dp))
num+=1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s844364162 | p00042 | Accepted |
import sys
import itertools
class Treasure:
def __init__(self, value, weight):
self.value = value
self.weight = weight
def solv(treasures, w_limit):
dp = []
dp.append(0)
for n in range(w_limit):
dp.append(-1)
for i in treasures:
for j in range(w_limit - i.weight, -1, -1):
if dp[j] >= 0:
dp[j + i.weight] = max(dp[j + i.weight], dp[j] + i.value)
p = 0
q = 0
for i in range(w_limit + 1):
if dp[i] > p:
p = dp[i]
q = i
return (p, q)
case = 0
while True:
weight_limit = int(sys.stdin.readline())
case += 1
if weight_limit == 0:
exit()
n = int(sys.stdin.readline())
treasures = []
for i in range(n):
v, w = map(int, sys.stdin.readline().split(','))
treasures.append(Treasure(v, w))
value, weight = solv(treasures, weight_limit)
print 'Case ' + str(case) + ':'
print value
print weight | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s692901726 | p00042 | Accepted | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
from itertools import count
def douteki(limit, data):
V = [[0 for w in xrange(limit+1)] for i in xrange(len(data)+1)]
W = [[0 for w in xrange(limit+1)] for i in xrange(len(data)+1)]
for i in xrange(len(data)+1):
for w in xrange(limit+1):
diff = w - data[i-1][1]
if i - 1 >= 0 and diff >= 0:
v1 = V[i-1][diff] + data[i-1][0]
w1 = W[i-1][diff] + data[i-1][1]
else:
v1 = 0
w1 = 0
v2 = V[i-1][w]
w2 = W[i-1][w]
V[i][w], W[i][w] = (v1, w1) if v1 >= v2 else (v2, w2)
return V[-1][-1], W[-1][-1]
for case in count(1):
W = int(stdin.readline())
if not W:
break
N = int(stdin.readline())
data = []
for _ in xrange(N):
data.append([int(s) for s in stdin.readline().split(',')])
value, weight = douteki(W, data)
print('Case {}:\n{}\n{}'.format(case, value, weight)) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s367636643 | p00042 | Accepted | case = 0
while True:
w = int(raw_input())
if w == 0:
break
n = int(raw_input())
dp = [[0] * 1001 for i in range(1001)]
r1,r2 = 0,0
for i in range(1, n + 1):
a,b = map(int, raw_input().split(','))
for j in range(w + 1):
if j - b >= 0:
dp[i][j] = max(dp[i - 1][j],dp[i - 1][j - b] + a)
else:
dp[i][j] = dp[i - 1][j]
if r1 <= dp[i][j]:
if r1 == dp[i][j]:
r2 = min(r2, j)
else:
r2 = j
r1 = dp[i][j]
case += 1
print 'Case {}:'.format(case)
print r1
print r2 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s995279965 | p00042 | Accepted | count =0
while True:
W = input()
if (W==0): break
work={0:0}
count +=1
N = input()
for i in range(N):
p,w = input()
for w0 in sorted(work.keys(),reverse=True):
w1 = w0+w
p1 = work[w0]+p
if w1>W or (work.has_key(w1) and work[w1]>=p1): continue
else: work[w1] = p1
m = max(work.values())
tmp = work.values().index(m)
n = work.keys()[tmp]
print "Case %d:" %(count)
print m
print n | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s348883445 | p00042 | Accepted | count =0
while True:
W = input()
if W==0: break
work = [0]*1001
count +=1
N = input()
m = 0
n = 0
for i in range(N):
p,w = input()
for w0 in range(W+1)[::-1]:
p0 = work[w0]
if w0>0 and p0==0: continue
w1 = w0+w
p1 = p0+p
if w1<=W and work[w1]<p1:
work[w1] = p1
if m<p1:
m = p1
n = work.index(m)
print "Case {}:".format(count)
print m
print n | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s628575886 | p00042 | Accepted | c =0
while True:
W = input()
if W==0: break
dt = [0]*1001
c +=1
N = input()
m = 0
n = 0
for i in range(N):
p,w = input()
for w0 in range(W+1)[::-1]:
p0 = dt[w0]
if w0==0 or p0!=0:
w1 = w0+w
p1 = p0+p
if w1<=W and dt[w1]<p1: dt[w1]=p1
m = max(dt)
n = dt.index(m)
print "Case {}:".format(c)
print m
print n | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s313277878 | p00042 | Accepted | case = 1
while 1:
W = input()
if W == 0: break
N = input()
v, w = [0]*N, [0]*N
for i in range(N):
v[i], w[i] = map(int, raw_input().split(','))
dp = [0]*(W+1)
for i in range(N):
for j in range(W,0,-1):
if j-w[i] >= 0:
dp[j] = max(dp[j-w[i]]+v[i], dp[j])
av, aw = 0, 0
for w, v in enumerate(dp):
if av < v:
av = v
aw = w
print 'Case {}:'.format(case)
print av
print aw
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s627737925 | p00042 | Accepted | def f():
p,w = input()
for w0 in R[w:]:
w1,p1 = w0+w,dt[w0]+p
if dt[w1]<p1: dt[w1]=p1
return
c = 0
while 1:
W = input()
if W==0: break
R = range(W+1)[::-1]
dt = [0]*1001
c += 1
N = input()
for i in range(N): f()
m = max(dt)
n = dt.index(m)
print "Case {}:\n{}\n{}".format(c,m,n) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s725303931 | p00042 | Accepted | def get():
p,w = map(int, raw_input().split(","))
for i in range(W-w,-1,-1):
if bag[i] > 0 and bag[i]+p > bag[i+w]:
bag[i+w] = bag[i]+p
else:
if p > bag[w]: bag[w] = p
return
c = 1
while True:
W = int(raw_input())
if W == 0: break
bag = [0]*(W+1)
N = int(raw_input())
for i in range(N): get()
w_all = max(bag)
money = bag.index(w_all)
print "Case {}:\n{}\n{}".format(c,w_all,money)
c += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s552412986 | p00042 | Accepted | from itertools import *
def mlist(n, *args, **keys):
if args:
return [mlist(*args, **keys) for i in range(n)]
else:
return [keys.get('default')] * n
for h in count(1):
w = int(raw_input())
if w == 0: break
n = int(raw_input())
a, b = zip(*[map(int, raw_input().split(',')) for i in range(n)])
c = mlist(1010, 1010)
c[0][0] = 0
for i in range(n):
for j in range(w + 1):
if c[i][j] is None: continue
c[i + 1][j] = max(c[i + 1][j], c[i][j])
if j + b[i] <= w:
c[i + 1][j + b[i]] = max(c[i + 1][j + b[i]], c[i][j] + a[i])
mx = max(c[n])
print 'Case {}:'.format(h)
print mx
print c[n].index(mx) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s293726838 | p00042 | Accepted | #!/bin/env python3
# -*- coding: utf-8 -*-
from __future__ import division, print_function
try:
input = raw_input
range = xrange
except NameError:
pass
# 上記のコードはPython2とPython3の違いを一部吸収するためのもの
def main():
value = [0] * 1000
weight = [0] * 1000
casenum = 1
while True:
W = int(input())
if(W == 0):
return
N = int(input())
dp = [[0 for x in range(W+1)] for y in range(N+1)]
for x in range(0, N):
value[x], weight[x] = map(int, input().split(','))
for i in range(0, N):
for w in range(0, W+1):
if w - weight[i] >= 0:
use = dp[i][w - weight[i]] + value[i]
else:
use = 0
unuse = dp[i][w]
dp[i+1][w] = max(use, unuse)
print("Case " + str(casenum) + ":")
for w in range(W+1):
if(dp[N][w] == dp[N][W]):
print(str(dp[N][w]) + "\n" + str(w))
break
casenum += 1
main() | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s603973223 | p00042 | Accepted | #coding:utf-8
from __future__ import division, print_function
try:
input = raw_input
range = xrange
except NameError:
pass
def solve(W, N, treasures):
dp = [0] + [-1] * W
for v, w in treasures:
for j in range(W, w - 1, -1):
if dp[j - w] >= 0:
dp[j] = max(dp[j], dp[j - w] + v)
ans = max(dp)
return ans, dp.index(ans)
cnt = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
treasures = [tuple(map(int, input().split(','))) for _ in range(N)]
(v, w) = solve(W, N, treasures)
print('Case %d:\n%d\n%d' % (cnt, v, w))
cnt += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s874359689 | p00042 | Accepted | #coding:utf-8
from __future__ import division, print_function
try:
input = raw_input
range = xrange
except NameError:
pass
def solve(cnt, W, N, treasures):
dp = [0] + [-1] * W
for v, w in treasures:
for j in range(W, w - 1, -1):
if dp[j - w] >= 0:
dp[j] = max(dp[j], dp[j - w] + v)
ans = max(dp)
print('Case %d:\n%d\n%d' % (cnt, ans, dp.index(ans)))
cnt = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
treasures = [tuple(map(int, input().split(','))) for _ in range(N)]
solve(cnt, W, N, treasures)
cnt += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s776953144 | p00042 | Accepted | import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve(k):
W = int(readline())
if W == 0:
return False
INF = 10**18
dp = [-INF]*(W+1)
dp[0] = 0
N = int(readline())
for i in range(N):
v, w = map(int, readline().split(","))
for j in range(W-w, -1, -1):
dp[j+w] = max(dp[j+w], dp[j] + v)
vm = max(dp)
wm = dp.index(vm)
write("Case %d:\n%d\n%d\n" % (k, vm, wm))
return True
i = 1
while solve(i):
i += 1
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s813573700 | p00042 | Accepted | cnt = 1
while 1:
l = int(input())
if l == 0:
break
n = int(input())
v = [0] * (n+1)
w = [0] * (n+1)
for i in range(1, n+1):
v[i], w[i] = map(int, input().split(','))
dp = [[0]*(l+1) for i in range(n+1)]
for i in range(1, n+1):
for j in range(1, l+1):
if (j < w[i]):
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j - w[i]] + v[i], dp[i-1][j])
print('Case ', cnt, ':', sep='')
print(dp[n][l])
for i in range(l + 1):
if dp[n][l] == dp[n][i]:
print(i)
break
cnt += 1
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s844598139 | p00042 | Accepted | cnt = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
dp = [0] * (W+1)
for i in range(N):
v, w = map(int, input().split(','))
for j in range(W, w-1, -1):
dp[j] = max(dp[j], dp[j-w] + v)
av = 0
aw = 0
for i in range(W+1):
if av < dp[i]:
av = dp[i]
aw = i
print("Case {}:".format(cnt))
print(av)
print(aw)
cnt += 1
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s752520978 | p00042 | Accepted | MAX = 1005
for cno in range(1, 100):
lim = int(input())
if lim == 0: break
print("Case ", cno, ":", sep='')
N = int(input())
V = [[0 for j in range(MAX)] for i in range(2)]
W = [[0 for j in range(MAX)] for i in range(2)]
k1, k2 = 0, 1
for i in range(1, N+1):
v, w = map(int, input().split(','))
for j in range(1, w):
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
for j in range(w, lim+1):
d = j - w
if V[k1][d] + v >= V[k1][j]:
V[k2][j] = V[k1][d] + v
W[k2][j] = W[k1][d] + w
else:
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
k1, k2 = k2, k1
print(V[k1][lim], W[k1][lim], sep='\n')
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s741013385 | p00042 | Accepted | # AOJ 0042 A Thief
# Python3 2018.6.22 bal4u
MAX = 1003
for cno in range(1, 100):
lim = int(input())
if lim == 0: break
print("Case ", cno, ":", sep='')
N = int(input())
V = [[0 for j in range(MAX)] for i in range(2)]
W = [[0 for j in range(MAX)] for i in range(2)]
k1, k2 = 0, 1
for i in range(1, N+1):
v, w = map(int, input().split(','))
for j in range(1, w):
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
for j in range(w, lim+1):
d = j - w
if V[k1][d] + v >= V[k1][j]:
V[k2][j] = V[k1][d] + v
W[k2][j] = W[k1][d] + w
else:
V[k2][j] = V[k1][j]
W[k2][j] = W[k1][j]
k1, k2 = k2, k1
print(V[k1][lim], W[k1][lim], sep='\n')
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s536919488 | p00042 | Accepted | l=1
for W in iter(input,'0'):
W=int(W)
D=[0,0]*W
for p in[0]*int(input()):
v,w=map(int,input().split(','))
for i in range(W,w-1,-1):D[i]=max(D[i],D[i-w]+v)
print(f'Case {l}:\n{D[W]}\n{D.index(D[W])}')
l+=1
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s286274671 | p00042 | Accepted | mininf = -10**8
inf = 10**8
count = 0
while(1):
count += 1
W = int(input())
if W == 0:
break
N = int(input())
dp = [0 for j in range(W+1)]
for _ in range(N):
v,w = [int(i) for i in input().split(",")]
for i in range(w,W+1)[::-1]:
dp[i] = max(dp[i], dp[i-w]+v)
value = 0
weight = 0
for i in range(W+1):
if value < dp[i]:
value = dp[i]
weight = i
print("Case {}:".format(count))
print(value)
print(weight)
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s926182470 | p00042 | Accepted | r,m,I=range,max,input
for lp in r(99):
W=I()+1
if W==1:break
N=I()
D=[0]*W
for loop in r(N):
v,w=map(int,raw_input().split(','))
for i in r(w,W)[::-1]:D[i]=m(D[i],D[i-w]+v)
print'Case',str(lp+1)+':'
print m(D)
print D.index(m(D))
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s815822257 | p00042 | Accepted |
# メモ化+非再帰を用いた場合
case_no = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
treasures = [tuple(map(int, input().split(','))) for _ in range(N)]
V = [[0 for w in range(W+1)] for i in range(N+1)]
weight = [[0 for w in range(W+1)] for i in range(N+1)]
for i in range(1, N+1):
for w in range(W+1):
vi = treasures[i-1][0]
wi = treasures[i-1][1]
if wi <= w and vi != 0:
l = V[i-1][w-wi] + vi
r = V[i-1][w]
if l > r:
V[i][w] = l
weight[i][w] = weight[i-1][w-wi] + wi
else:
V[i][w] = r
weight[i][w] = weight[i-1][w]
else:
V[i][w] = V[i-1][w]
weight[i][w] = weight[i-1][w]
sum_value = 0
sum_weight = 1e100
for i in range(1, N+1):
for j in range(W+1):
if V[i][j] > sum_value or (V[i][j] == sum_value and weight[i][j] < sum_weight):
sum_value = V[i][j]
sum_weight = weight[i][j]
print('Case {}:'.format(case_no))
print(sum_value)
print(sum_weight if sum_weight != 1e100 else 0)
case_no += 1
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s562102812 | p00042 | Runtime Error | count = 0
while True:
count += 1
W = int(input())
if W == 0:
break
N = int(input())
value = []
weight = []
for i in range(N):
a, b = map(int, input().split())
value.append(a)
weight.append(b)
dp = [[-float("inf") for i in range(W+1)] for j in range(N+1)]
for i in range(W+1):
dp[0][i] = 0
for i in range(N):
for w in range(W+1):
if w >= weight[i]:
dp[i+1][w] = max(dp[i][w-weight[i]]+value[i], dp[i][w])
else:
dp[i+1][w] = dp[i][w]
print("Case {0}:\n{1}\n{2}".format(count, dp[N][W], dp[N].index(dp[N][W])))
| 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s581468718 | p00042 | Runtime Error | while True:
# try:
case=0
while True:
case+=1
weight=input()
if weight==0:
break
N=input()
data=[[0 for i in range(2)] for j in range(N)]
for i in range(N):
data[i][0],data[i][1]=map(int,raw_input().split(","))
table=[[-1 for i in range(weight+1)] for j in range(N)]
for i in range(N):
table[i][0]=0
table[0][data[0][1]]=data[0][0]
for i in range(0,N-1):
for j in range(weight+1):
if table[i][j]!=-1 and j+data[i+1][1] <= weight:
table[i+1][j+data[i+1][1]]=table[i][j]+data[i+1][0]
sum=max(table[N-1])
print "Case "+str(case)+":"
print sum
print table[N-1].index(sum)
# except:
#break | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s119841462 | p00042 | Runtime Error | import itertools
count = 0
while True:
w = int(raw_input())
if w == 0:
break
m = int(raw_input())
n = [0 for _ in xrange(m)]
h = [0 for _ in xrange(m)]
count += 1
for i in xrange(m):
n[i],h[i] = map(int,raw_input().split(","))
js= []
for i in xrange(m):
lis = list(itertools.combinations(n, m - i))
for j in lis:
js.append(sum(j))
jk = []
for i in xrange(m):
lis = list(itertools.combinations(h, m - i))
for j in lis:
jk.append(sum(j))
jc = list(filter(lambda x: x < w, jk))
jc.sort()
js.sort()
print "Case " + str(count) + ":"
print js[len(jc) - 1]
print jc[len(jc) - 1] | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s755133983 | p00042 | Runtime Error | import itertools
count = 0
while True:
w = int(raw_input())
if w == 0:
break
m = int(raw_input())
n = [0 for _ in xrange(m)]
h = [0 for _ in xrange(m)]
count += 1
for i in xrange(m):
n[i],h[i] = map(int,raw_input().split(","))
js= []
jk = []
for i in xrange(m):
lis = list(itertools.combinations(h, m - i))
for j in lis:
jk.append(sum(j))
las = list(itertools.combinations(n, m - i))
for j in las:
js.append(sum(j))
jc = list(filter(lambda x: x < w, jk))
jc.sort()
js.sort()
print "Case " + str(count) + ":"
print js[len(jc) - 1]
print jc[len(jc) - 1] | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s477125888 | p00042 | Runtime Error | import itertools
count = 0
while True:
w = int(raw_input())
if w == 0:
break
m = int(raw_input())
n = [0 for _ in xrange(m)]
h = [0 for _ in xrange(m)]
count += 1
for i in xrange(m):
n[i],h[i] = map(int,raw_input().split(","))
tr = []
ty = []
for i in xrange(m):
lis = list(itertools.combinations(h, m - i))
for j in lis:
tr.append(sum(j))
las = list(itertools.combinations(n, m - i))
for j in las:
ty.append(sum(j))
te = list(filter(lambda x: x < w, tr))
te.sort()
ty.sort()
print "Case " + str(count) + ":"
print ty[len(te) - 1]
print te[len(te) - 1] | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s819002453 | p00042 | Runtime Error | import itertools
count = 0
if __name__ == "__main__":
while True:
w = int(raw_input())
if w == 0:
break
m = int(raw_input())
n = [0 for _ in xrange(m)]
h = [0 for _ in xrange(m)]
count += 1
for i in xrange(m):
n[i],h[i] = map(int,raw_input().split(","))
tr = []
ty = []
for i in xrange(m):
lis = list(itertools.combinations(h, m - i))
for j in lis:
tr.append(sum(j))
las = list(itertools.combinations(n, m - i))
for j in las:
ty.append(sum(j))
te = list(filter(lambda x: x < w, tr))
te.sort()
ty.sort()
print "Case " + str(count) + ":"
print ty[len(te) - 1]
print te[len(te) - 1] | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s759286285 | p00042 | Runtime Error |
def rec(i, j):
if dp[i][j] != -1:
return dp[i][j]
if i == N:
ans = 0, W - j
elif j < wl[i]:
ans = rec(i + 1, j)
else:
v1, w1 = rec(i + 1, j)
v2, w2 = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = v1, w1
elif v1 < v2:
ans = v2, w2
elif v1 == v2:
if w1 < w2:
ans = v1, w1
else:
ans = v2, w2
dp[i][j] = ans
return ans
case = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
dp = [[-1 for j in range(2000)] for i in range(2000)]
v, w = rec(0, W)
print("Case {}:".format(case))
print(v)
print(w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s815694651 | p00042 | Runtime Error |
def rec(i, j):
if dp[i][j] != -1:
return dp[i][j]
if i == N:
ans = 0, W - j
elif j < wl[i]:
ans = rec(i + 1, j)
else:
v1, w1 = rec(i + 1, j)
v2, w2 = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = v1, w1
elif v1 < v2:
ans = v2, w2
elif v1 == v2:
if w1 < w2:
ans = v1, w1
else:
ans = v2, w2
dp[i][j] = ans
return ans
case = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
dp = [[-1 for j in range(1100)] for i in range(1100)]
v, w = rec(0, W)
print("Case {}:".format(case))
print(v)
print(w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s048310023 | p00042 | Runtime Error |
def rec(i, j):
if dp[i][j] != -1:
return dp[i][j]
if i == N:
ans = 0, W - j
elif j < wl[i]:
ans = rec(i + 1, j)
else:
v1, w1 = rec(i + 1, j)
v2, w2 = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = v1, w1
elif v1 < v2:
ans = v2, w2
elif v1 == v2:
if w1 < w2:
ans = v1, w1
else:
ans = v2, w2
dp[i][j] = ans
return ans
case = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
dp = [[-1 for j in range(2500)] for i in range(2500)]
v, w = rec(0, W)
print("Case {}:".format(case))
print(v)
print(w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s966402467 | p00042 | Runtime Error |
def rec(i, j):
if dp[i][j] != -1:
return dp[i][j]
if i == N:
ans = (0, W - j)
elif j < wl[i]:
ans = rec(i + 1, j)
else:
(v1, w1) = rec(i + 1, j)
(v2, w2) = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = (v1, w1)
elif v1 < v2:
ans = (v2, w2)
elif v1 == v2:
if w1 < w2:
ans = (v1, w1)
else:
ans = (v2, w2)
dp[i][j] = ans
return ans
case = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
dp = [[-1 for j in range(2500)] for i in range(2500)]
(v, w) = rec(0, W)
print("Case {}:".format(case))
print(v)
print(w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s961308360 | p00042 | Runtime Error |
def rec(i, j):
if 3000 < i or 3000 < j:
while True:
print("aaa")
if dp[i][j] != -1:
return dp[i][j]
if i == N:
ans = (0, W - j)
elif j < wl[i]:
ans = rec(i + 1, j)
else:
(v1, w1) = rec(i + 1, j)
(v2, w2) = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = (v1, w1)
elif v1 < v2:
ans = (v2, w2)
elif v1 == v2:
if w1 < w2:
ans = (v1, w1)
else:
ans = (v2, w2)
dp[i][j] = ans
return ans
case = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
dp = [[-1 for j in range(2500)] for i in range(2500)]
(v, w) = rec(0, W)
print("Case {}:".format(case))
print(v)
print(w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s883618968 | p00042 | Runtime Error |
def rec(i, j):
#print("rec({}, {}) called".format(i, j))
"""
if dp[i][j] != -1:
return dp[i][j]
"""
if i in dphash and j in dphash[i]:
return dphash[i][j]
if i == N:
ans = (0, W - j)
elif j < wl[i]:
ans = rec(i + 1, j)
else:
(v1, w1) = rec(i + 1, j)
(v2, w2) = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = (v1, w1)
elif v1 < v2:
ans = (v2, w2)
elif v1 == v2:
if w1 < w2:
ans = (v1, w1)
else:
ans = (v2, w2)
#dp[i][j] = ans
if i in dphash:
dphash[i][j] = ans
else:
dphash[i] = {}
dphash[i][j] = ans
return ans
case = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
#dp = [[-1 for j in range(2500)] for i in range(2500)]
dphash = {}
(v, w) = rec(0, W)
print("Case {}:".format(case))
print(v)
print(w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s680688302 | p00042 | Runtime Error |
def rec(i, j):
#print("rec({}, {}) called".format(i, j))
if i in dphash and j in dphash[i]:
return dphash[i][j]
if i == N:
ans = (0, W - j)
elif j < wl[i]:
ans = rec(i + 1, j)
else:
(v1, w1) = rec(i + 1, j)
(v2, w2) = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = (v1, w1)
elif v1 < v2:
ans = (v2, w2)
elif v1 == v2:
if w1 < w2:
ans = (v1, w1)
else:
ans = (v2, w2)
#dp[i][j] = ans
if i in dphash:
dphash[i][j] = ans
else:
dphash[i] = {}
dphash[i][j] = ans
return ans
case = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
#dp = [[-1 for j in range(2500)] for i in range(2500)]
dphash = {}
(v, w) = rec(0, W)
print("Case {}:".format(case))
print(v)
print(w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s494253673 | p00042 | Runtime Error |
def rec(i, j):
#print("rec({}, {}) called".format(i, j))
if i in dphash and j in dphash[i]:
return dphash[i][j]
if i == N:
ans = (0, W - j)
elif j < wl[i]:
ans = rec(i + 1, j)
else:
(v1, w1) = rec(i + 1, j)
(v2, w2) = rec(i + 1, j - wl[i])
v2 += vl[i]
if v1 > v2:
ans = (v1, w1)
elif v1 < v2:
ans = (v2, w2)
elif v1 == v2:
if w1 < w2:
ans = (v1, w1)
else:
ans = (v2, w2)
#dp[i][j] = ans
if i in dphash:
dphash[i][j] = ans
else:
dphash[i] = {}
dphash[i][j] = ans
return ans
casea = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
#dp = [[-1 for j in range(2500)] for i in range(2500)]
dphash = {}
(v, w) = rec(0, W)
print("Case {}:".format(casea))
print(v)
print(w)
casea += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s851735541 | p00042 | Runtime Error | case = 1
while True:
W = int(input())
if W == 0: break
N = int(input())
vl = []
wl = []
for _ in range(N):
v, w = map(int, input().split(','))
vl.append(v)
wl.append(w)
dp = [[[0, 0] for j in range(W + 1)] for i in range(N + 1)]
for i in range(N - 1, -1, -1):
for j in range(0, W + 1):
if j < wl[i]:
dp[i][j] = dp[i + 1][j]
else:
if dp[i + 1][j][0] > dp[i+1][j - wl[i]][0] + vl[i]:
dp[i][j] = dp[i + 1][j]
elif dp[i + 1][j][0] < dp[i+1][j - wl[i]][0] + vl[i]:
dp[i][j] = dp[i+1][j - wl[i]]
dp[i][j][0] += vl[i]
elif dp[i + 1][j][0] = dp[i+1][j - wl[i]][0] + vl[i]:
v, w = dp[0][W]
print("Case {}:".format(case))
print(v)
print(w)
case += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s774923613 | p00042 | Runtime Error | times=0
while True:
times+=1
W=int(input())
n=int(input())
if W==0:
break
w=[0]*n
v=[0]*n
for i in range(n):
v[i],w[i]=map(int,input().split(","))
dp=[[0]*(W+1) for i in range(n+1)]
for i in range(n):
for j in range(W+1):
if j<w[i]:
dp[i+1][j]=dp[i][j]
else:
dp[i+1][j]=max(dp[i][j],dp[i][j-w[i]]+v[i])
MIN=0
for i in range(W+1):
if dp[n][i]==dp[n][W]:
MIN=i
break
print("Case %d:"%times)
print(dp[n][W])
print(MIN) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s761508934 | p00042 | Runtime Error | def dfs_dp(w, v, N, W, index, dp):
if (dp[index][W][0] != -1):
return dp[index][W]
if index==N: return [0,0]
if W<w[index]: return dfs_dp(w, v, N, W, index + 1, dp)
temp1=dfs_dp(w, v, N, W, index + 1, dp)
temp=dfs_dp(w, v, N, W - w[index], index + 1, dp)
temp2=[v[index] + temp[0],w[index]+temp[1]]
if temp1[0]==temp2[0]:
if temp1[1]<temp2[1]:
ret=temp1
else: ret=temp2
elif temp1[0]>temp2[0]:
ret=temp1
else: ret=temp2
dp[index][W]=ret
return ret
count=1
W=int(input())
while(W!=0):
N=int(input())
w=[]
v=[]
dp=[[[-1,-1] for i in range(W+1)] for j in range(N+1)]
for i in range(N):
a,b=input().split(',')
v.append(int(a))
w.append(int(b))
sum=dfs_dp(w,v,N,W,0,dp)
print("Case "+str(count)+":")
print(sum[0])
print(sum[1])
W=int(input())
count+=1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s133473839 | p00042 | Runtime Error | # i????????\??????????????§??????j??§??????(?????§??????, ??????????????????)
def ns(vs, ws, i, j, dp):
if dp[i][j][0] != -1:
return dp[i][j]
if i == len(vs):
return [0, 0]
else:
if ws[i] > j:
dp[i][j] = ns(vs, ws, i+1, j, dp)
return dp[i][j]
else:
tmp = ns(vs, ws, i+1, j-ws[i], dp)
dp[i][j] = max(ns(vs, ws, i+1, j, dp), [vs[i]+tmp[0], ws[i]+tmp[1]], key = lambda x: x[0])
return dp[i][j]
casenum = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
vs, ws = [], []
for _ in range(N):
v, w = map(int, input().split(','))
vs.append(v)
ws.append(w)
dp = [[[-1, -1] for _ in range(W+1)] for __ in range(N+1)]
v, w = ns(vs, ws, 0, W, dp)
print('Case ' + str(casenum) + ':')
print(v)
print(w)
casenum += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s428893666 | p00042 | Runtime Error | # i????????\??????????????§??????j??§??????(?????§??????, -??????????????????)
def ns(vs, ws, i, j, dp):
if dp[i][j][0] != -1:
return dp[i][j]
if i == len(vs):
return [0, 0]
else:
if ws[i] > j:
dp[i][j] = ns(vs, ws, i+1, j, dp)
return dp[i][j]
else:
tmp = ns(vs, ws, i+1, j-ws[i], dp)
dp[i][j] = max(ns(vs, ws, i+1, j, dp), [vs[i]+tmp[0], -ws[i]+tmp[1]], key = lambda x: (x[0], x[1]))
return dp[i][j]
casenum = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
vs, ws = [], []
for _ in range(N):
v, w = map(int, input().split(','))
vs.append(v)
ws.append(w)
dp = [[[-1, -1] for _ in range(W+1)] for __ in range(N+1)]
v, w = ns(vs, ws, 0, W, dp)
print('Case ' + str(casenum) + ':')
print(v)
print(-w)
casenum += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s323617671 | p00042 | Runtime Error | def ns(vs, ws, i, j, dp):
if dp[i][j][0] != -1:
return dp[i][j]
if i == len(vs):
return [0, 0]
else:
if ws[i] > j:
dp[i][j] = ns(vs, ws, i+1, j, dp)
return dp[i][j]
else:
tmp = ns(vs, ws, i+1, j-ws[i], dp)
dp[i][j] = max(ns(vs, ws, i+1, j, dp), [vs[i]+tmp[0], -ws[i]+tmp[1]], key = lambda x: (x[0], x[1]))
return dp[i][j]
casenum = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
vs, ws = [], []
for _ in range(N):
v, w = map(int, input().split(','))
vs.append(v)
ws.append(w)
dp = [[[-1, -1] for _ in range(W+1)] for __ in range(N+1)]
v, w = ns(vs, ws, 0, W, dp)
print('Case ' + str(casenum) + ':')
print(v)
print(-w)
casenum += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s397182723 | p00042 | Runtime Error | # coding: utf-8
count += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s619283595 | p00042 | Runtime Error | # coding: utf-8
count = 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s361318135 | p00042 | Runtime Error | def get():
p,w = map(int, raw_input().split(","))
for i in range(W-w,-1,-1):
if bag[i] > 0 and bag[i]+p > bag[i+w]:
bag[i+w] = bag[i]+p
else:
if p > bag[w]: bag[w] = p
return
c = 1
while True:
W = int(raw_input())
if W == 0: break
bag = [0]*(W+1)
N = int(raw_input())
for i in range(N): get()
w_all = max(bag)
money = bag.index(w_all)
print "Case {}:\n{}\n{}".format(c,w_all,money)
c += 1 | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
s213256570 | p00042 | Runtime Error | from itertools import combinations
case = 0
while True :
limit = int(input())
if limit == 0 : break
case += 1
number = int(input())
value, weight = [], []
for _ in range(number) :
a, b = input().split(',')
value.append(int(a))
weight.append(int(b))
temp1, temp2 = [], []
for _ in range(1, number+1) :
temp1.append(list(combinations(value, _)))
temp2.append(list(combinations(weight, _)))
temp1, temp2 = sum(temp1, []), sum(temp2, [])
value, weight = [], []
for _ in temp1 : value.append(sum(_))
for _ in temp2 : weight.append(sum(_))
result = [0, 0]
for _ in range(len(temp1)) :
if result[0] < value[_] and weight[_] =< limit :
result = value[_], weight[_]
elif result[0] == value and weight[_] < result[1] :
result = value[_], weight[_]
print('Case {}:'.format(case))
print(result[0])
print(result[1]) | 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
| Case 1:
220
49
Case 2:
220
49
|
<H1>泥棒</H1>
<p>
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
</p>
<p>
風呂敷が耐えられる重さ <var>W</var>、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が <var>W</var> を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
</p>
<!--
また、博物館にあるお宝の総数は 1000 以下とし、お宝の価値は10000 以下とします。
-->
<H2>Input</H2>
<p>
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
</p>
<pre>
<var>W</var>
<var>N</var>
<var>v<sub>1</sub></var>,<var>w<sub>1</sub></var>
<var>v<sub>2</sub></var>,<var>w<sub>2</sub></var>
:
<var>v<sub>N</sub></var>,<var>w<sub>N</sub></var>
</pre>
<p>
１行目に風呂敷の耐えられる重さを表す整数 <var>W</var> (<var>W</var> ≤ 1,000)、２行目にお宝の数 <var>N</var> (1 ≤ <var>N</var> ≤ 1,000) が与えられます。続く <var>N</var> 行に <var>i</var> 番目のお宝の価値を表す整数 <var>v<sub>i</sub></var> (0 ≤ <var>v<sub>i</sub></var> ≤ 10,000) とその重さを表す整数 <var>w<sub>i</sub></var> (0 ≤ <var>w<sub>i</sub></var> ≤ <var>W</var>) の組がそれぞれ１行に与えられます。
</p>
<p>
<var>W</var> が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
</p>
<H2>Output</H2>
<p>
各データセットに対して以下のように出力して下さい。
</p>
<pre>
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
</pre>
<H2>Sample Input</H2>
<pre>
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
</pre>
<H2>Output for the Sample Input</H2>
<pre>
Case 1:
220
49
Case 2:
220
49
</pre>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.