結果

問題 No.2866 yuusaan's Knapsack
ユーザー maguroflymagurofly
提出日時 2024-08-30 22:41:44
言語 Rust
(1.77.0)
結果
AC  
実行時間 7 ms / 2,000 ms
コード長 2,436 bytes
コンパイル時間 13,655 ms
コンパイル使用メモリ 402,524 KB
実行使用メモリ 6,944 KB
最終ジャッジ日時 2024-09-09 17:04:16
合計ジャッジ時間 15,241 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
6,812 KB
testcase_01 AC 1 ms
6,812 KB
testcase_02 AC 2 ms
6,940 KB
testcase_03 AC 2 ms
6,944 KB
testcase_04 AC 1 ms
6,944 KB
testcase_05 AC 1 ms
6,940 KB
testcase_06 AC 7 ms
6,940 KB
testcase_07 AC 5 ms
6,940 KB
testcase_08 AC 6 ms
6,940 KB
testcase_09 AC 5 ms
6,940 KB
testcase_10 AC 5 ms
6,944 KB
testcase_11 AC 5 ms
6,940 KB
testcase_12 AC 5 ms
6,944 KB
testcase_13 AC 5 ms
6,940 KB
testcase_14 AC 6 ms
6,940 KB
testcase_15 AC 6 ms
6,940 KB
testcase_16 AC 5 ms
6,940 KB
testcase_17 AC 6 ms
6,940 KB
testcase_18 AC 5 ms
6,940 KB
testcase_19 AC 7 ms
6,940 KB
testcase_20 AC 5 ms
6,940 KB
testcase_21 AC 6 ms
6,944 KB
testcase_22 AC 6 ms
6,944 KB
testcase_23 AC 6 ms
6,940 KB
testcase_24 AC 6 ms
6,940 KB
testcase_25 AC 6 ms
6,944 KB
testcase_26 AC 5 ms
6,944 KB
testcase_27 AC 1 ms
6,944 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
warning: variable `N` should have a snake case name
 --> src/main.rs:8:9
  |
8 |         N: usize, W: i64,
  |         ^ help: convert the identifier to snake case: `n`
  |
  = note: `#[warn(non_snake_case)]` on by default

warning: variable `W` should have a snake case name
 --> src/main.rs:8:19
  |
8 |         N: usize, W: i64,
  |                   ^ help: convert the identifier to snake case (notice the capitalization): `w`

ソースコード

diff # 

use proconio::input;

const INF: i64 = 1_000_000_000_000_000_000;
const MOD: i64 = 998244353;

fn main() {
    input! {
        N: usize, W: i64,
        mut items: [(i64, i64); N],
    }
    items.sort_by_key(|p| p.1 );

    let mut dp = vec![(-INF, 0i64, false); 30000 as usize];
    dp[10000] = (0, 1, true);

    for (v, w) in items {
        if w > 0 {
            for w_sum in (0 .. dp.len() as i64).rev() {
                if (0 .. dp.len() as i64).contains(&(w_sum + w)) {
                    let (v_sum, count, exist) = dp[w_sum as usize];
                    if !exist {
                        continue;
                    }
                    let v_sum_next = v_sum + v;
                    let w_sum_next = (w_sum + w) as usize;
                    if dp[w_sum_next].0 < v_sum_next {
                        dp[w_sum_next] = (v_sum_next, count, true);
                    } else if dp[w_sum_next].0 == v_sum_next {
                        dp[w_sum_next].1 += count;
                        dp[w_sum_next].1 %= MOD;
                        dp[w_sum_next].2 = true;
                    }
                }
            }
        } else if w < 0 {
            for w_sum in 0 .. dp.len() as i64 {
                if (0 .. dp.len() as i64).contains(&(w_sum + w)) {
                    let (v_sum, count, exist) = dp[w_sum as usize];
                    if !exist {
                        continue;
                    }
                    let v_sum_next = v_sum + v;
                    let w_sum_next = (w_sum + w) as usize;
                    if dp[w_sum_next].0 < v_sum_next {
                        dp[w_sum_next] = (v_sum_next, count, exist);
                    } else if dp[w_sum_next].0 == v_sum_next {
                        dp[w_sum_next].1 += count;
                        dp[w_sum_next].1 %= MOD;
                        dp[w_sum_next].2 = true;
                    }
                }
            }
        } else if v > 0 {
            for x in &mut dp {
                x.0 += v;
            }
        }
    }

    let mut value_max = -INF;
    let mut count = 0;
    for i in 0 ..= (10000 + W) as usize {
        let (v, c, x) = dp[i];
        if x {
            if value_max < v {
                value_max = v;
                count = c;
            } else if value_max == v {
                count += c;
                count %= MOD;
            }
        }
    }
    println!("{value_max} {count}");
}
0