結果

問題 No.2364 Knapsack Problem
ユーザー atcoder8atcoder8
提出日時 2023-06-30 23:35:12
言語 Rust
(1.77.0)
結果
AC  
実行時間 2,047 ms / 3,000 ms
コード長 3,625 bytes
コンパイル時間 1,779 ms
コンパイル使用メモリ 160,648 KB
実行使用メモリ 128,044 KB
最終ジャッジ日時 2023-09-21 17:51:30
合計ジャッジ時間 17,181 ms
ジャッジサーバーID
（参考情報） 		judge12 / judge11
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
4,384 KB
testcase_01 AC 1 ms
4,380 KB
testcase_02 AC 1 ms
4,376 KB
testcase_03 AC 1 ms
4,376 KB
testcase_04 AC 2 ms
4,376 KB
testcase_05 AC 3 ms
4,376 KB
testcase_06 AC 2 ms
4,380 KB
testcase_07 AC 331 ms
33,376 KB
testcase_08 AC 1 ms
4,380 KB
testcase_09 AC 31 ms
5,876 KB
testcase_10 AC 162 ms
17,696 KB
testcase_11 AC 4 ms
4,380 KB
testcase_12 AC 1,372 ms
127,988 KB
testcase_13 AC 1,143 ms
128,028 KB
testcase_14 AC 673 ms
64,924 KB
testcase_15 AC 1,839 ms
128,032 KB
testcase_16 AC 1,194 ms
128,044 KB
testcase_17 AC 1,006 ms
128,040 KB
testcase_18 AC 1,190 ms
127,972 KB
testcase_19 AC 2,047 ms
128,040 KB
testcase_20 AC 1,966 ms
128,036 KB
testcase_21 AC 1,126 ms
128,040 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

use std::collections::HashMap;

fn main() {
    let input = Input::read();

    let mut memo = HashMap::new();
    let ans = rec(&input, 0, 0, 0, 0, &mut memo);
    println!("{}", ans);
}

fn rec(
    input: &Input,
    used_products: usize,
    used_magics: usize,
    w: i64,
    v: i64,
    memo: &mut HashMap<(usize, usize, i64, i64), i64>,
) -> i64 {
    if w < 0 || w > input.weight_limit {
        return 0;
    }

    if let Some(&sum_v) = memo.get(&(used_products, used_magics, w, v)) {
        return sum_v;
    }

    let mut max_value = v;

    for product in 0..input.product_num {
        if (used_products >> product) & 1 == 1 {
            continue;
        }

        let next_used_products = used_products | (1 << product);

        let value1 = rec(input, next_used_products, used_magics, w, v, memo);
        let value2 = rec(
            input,
            next_used_products,
            used_magics,
            w + input.weights[product],
            v + input.values[product],
            memo,
        );
        max_value = max_value.max(value1).max(value2);
    }

    for magic in 0..input.magic_num {
        if (used_magics >> magic) & 1 == 1 {
            continue;
        }

        let next_used_magics = used_magics | (1 << magic);

        let value1 = rec(input, used_products, next_used_magics, w, v, memo);
        let value2 = rec(
            input,
            used_products,
            next_used_magics,
            w - input.reduce_weight[magic],
            v - input.reduce_value[magic],
            memo,
        );
        max_value = max_value.max(value1).max(value2);
    }

    memo.insert((used_products, used_magics, w, v), max_value);

    max_value
}

struct Input {
    product_num: usize,
    magic_num: usize,
    weights: Vec<i64>,
    values: Vec<i64>,
    weight_limit: i64,
    reduce_weight: Vec<i64>,
    reduce_value: Vec<i64>,
}

impl Input {
    fn read() -> Self {
        let (product_num, magic_num, weight_limit) = {
            let mut line = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
                iter.next().unwrap().parse::<usize>().unwrap(),
                iter.next().unwrap().parse::<usize>().unwrap(),
                iter.next().unwrap().parse::<i64>().unwrap(),
            )
        };
        let weights: Vec<_> = {
            let mut line = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.split_whitespace()
                .map(|x| x.parse::<i64>().unwrap())
                .collect()
        };
        let values: Vec<_> = {
            let mut line = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.split_whitespace()
                .map(|x| x.parse::<i64>().unwrap())
                .collect()
        };
        let reduce_weight: Vec<_> = {
            let mut line = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.split_whitespace()
                .map(|x| x.parse::<i64>().unwrap())
                .collect()
        };
        let reduce_value: Vec<_> = {
            let mut line = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.split_whitespace()
                .map(|x| x.parse::<i64>().unwrap())
                .collect()
        };

        Self {
            product_num,
            magic_num,
            weights,
            values,
            weight_limit,
            reduce_weight,
            reduce_value,
        }
    }
}
0