From bc67421e67ff20630065b1f89c7bbaf1b0f1df47 Mon Sep 17 00:00:00 2001
From: FiveMovesAhead <ying@tig.foundation>
Date: Thu, 16 Jan 2025 21:21:41 +0000
Subject: [PATCH] Compiled knapsack/quadkp_improved_opt

---
 tig-algorithms/src/knapsack/mod.rs            |   3 +-
 .../benchmarker_outbound.rs                   | 266 +++++++++++++++++
 .../quadkp_improved_opt/commercial.rs         | 266 +++++++++++++++++
 .../knapsack/quadkp_improved_opt/inbound.rs   | 270 ++++++++++++++++++
 .../quadkp_improved_opt/innovator_outbound.rs | 270 ++++++++++++++++++
 .../src/knapsack/quadkp_improved_opt/mod.rs   |   4 +
 .../knapsack/quadkp_improved_opt/open_data.rs | 266 +++++++++++++++++
 .../wasm/knapsack/quadkp_improved_opt.wasm    | Bin 0 -> 166446 bytes
 8 files changed, 1344 insertions(+), 1 deletion(-)
 create mode 100644 tig-algorithms/src/knapsack/quadkp_improved_opt/benchmarker_outbound.rs
 create mode 100644 tig-algorithms/src/knapsack/quadkp_improved_opt/commercial.rs
 create mode 100644 tig-algorithms/src/knapsack/quadkp_improved_opt/inbound.rs
 create mode 100644 tig-algorithms/src/knapsack/quadkp_improved_opt/innovator_outbound.rs
 create mode 100644 tig-algorithms/src/knapsack/quadkp_improved_opt/mod.rs
 create mode 100644 tig-algorithms/src/knapsack/quadkp_improved_opt/open_data.rs
 create mode 100644 tig-algorithms/wasm/knapsack/quadkp_improved_opt.wasm

diff --git a/tig-algorithms/src/knapsack/mod.rs b/tig-algorithms/src/knapsack/mod.rs
index 33ddf59d..34ebc68f 100644
--- a/tig-algorithms/src/knapsack/mod.rs
+++ b/tig-algorithms/src/knapsack/mod.rs
@@ -132,7 +132,8 @@
 
 // c003_a067
 
-// c003_a068
+pub mod quadkp_improved_opt;
+pub use quadkp_improved_opt as c003_a068;
 
 // c003_a069
 
diff --git a/tig-algorithms/src/knapsack/quadkp_improved_opt/benchmarker_outbound.rs b/tig-algorithms/src/knapsack/quadkp_improved_opt/benchmarker_outbound.rs
new file mode 100644
index 00000000..332ba15f
--- /dev/null
+++ b/tig-algorithms/src/knapsack/quadkp_improved_opt/benchmarker_outbound.rs
@@ -0,0 +1,266 @@
+/*!
+Copyright 2025 VNX
+
+Licensed under the TIG Benchmarker Outbound Game License v2.0 (the "License"); you
+may not use this file except in compliance with the License. You may obtain a copy
+of the License at
+
+https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.
+*/
+
+use anyhow::Result;
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use tig_challenges::knapsack::{Challenge, Solution};
+
+
+fn add_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let gain = values[i] + interaction_gains[i];
+    selected_bits[i] = true;
+    *total_value += gain;
+    *total_weight += weights[i];
+    // Mise à jour des interactions
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] += challenge.interaction_values[i][j];
+    }
+}
+
+
+fn remove_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let removal_loss = values[i] + interaction_gains[i];
+    selected_bits[i] = false;
+    *total_value -= removal_loss;
+    *total_weight -= weights[i];
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] -= challenge.interaction_values[i][j];
+    }
+}
+
+pub fn solve_challenge(challenge: &Challenge) -> Result<Option<Solution>> {
+    let vertex_count = challenge.weights.len();
+
+    let values: Vec<i32> = challenge.values.iter().map(|&v| v as i32).collect();
+    let weights: Vec<u32> = challenge.weights.clone(); // ou .to_vec()
+
+    let mut item_scores: Vec<(usize, f32)> = (0..vertex_count)
+        .map(|i| {
+            let interaction_sum: i32 = challenge.interaction_values[i].iter().sum();
+            let secondary_score = values[i] as f32 / (weights[i].max(1)) as f32;
+            let combined_score = (values[i] as f32 * 0.75
+                + interaction_sum as f32 * 0.15
+                + secondary_score * 0.1)
+                / (weights[i] as f32).max(1.0);
+            (i, combined_score)
+        })
+        .collect();
+
+    item_scores.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+
+    let mut selected_bits = vec![false; vertex_count];
+    let mut interaction_gains = vec![0; vertex_count];
+
+    let mut total_value: i32 = 0;
+    let mut total_weight: u32 = 0;
+
+    let mut selected_list = Vec::with_capacity(vertex_count);
+    let mut unselected_list = Vec::with_capacity(vertex_count);
+
+    for &(i, _) in &item_scores {
+        if total_weight + weights[i] <= challenge.max_weight {
+            add_item(
+                i,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            selected_list.push(i);
+        } else {
+            unselected_list.push(i);
+        }
+    }
+
+    let mut mutation_rates = vec![0; vertex_count];
+    for i in 0..vertex_count {
+        mutation_rates[i] = values[i] + interaction_gains[i];
+    }
+
+    let max_generations = (vertex_count ) / 2;    
+    let mut cooling_schedule = vec![0; vertex_count];
+    let rng = StdRng::seed_from_u64(challenge.seed[0] as u64);
+
+    for _generation in 0..max_generations {
+        let mut best_gain = 0;
+        let mut best_swap = None;
+
+        for (u_index, &mutant) in unselected_list.iter().enumerate() {
+            if cooling_schedule[mutant] > 0 {
+                continue;
+            }
+            let mutant_fitness = mutation_rates[mutant];
+
+            let extra_weight = (weights[mutant] as i32)
+                - (challenge.max_weight as i32 - total_weight as i32);
+
+            if mutant_fitness < 0 {
+                continue;
+            }
+
+            for (c_index, &sel) in selected_list.iter().enumerate() {
+                if cooling_schedule[sel] > 0 {
+                    continue;
+                }
+                if extra_weight > 0 && (weights[sel] as i32) < extra_weight {
+                    continue;
+                }
+
+                let interaction_penalty =
+                    (challenge.interaction_values[mutant][sel] as f32 * 0.3) as i32;
+                let fitness_gain = mutant_fitness - mutation_rates[sel] - interaction_penalty;
+
+                if fitness_gain > best_gain {
+                    best_gain = fitness_gain;
+                    best_swap = Some((u_index, c_index));
+                }
+            }
+        }
+
+        if let Some((u_index, c_index)) = best_swap {
+            let added_item = unselected_list[u_index];
+            let removed_item = selected_list[c_index];
+
+            remove_item(
+                removed_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            add_item(
+                added_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+
+            selected_list.swap_remove(c_index);
+            unselected_list.swap_remove(u_index);
+            selected_list.push(added_item);
+            unselected_list.push(removed_item);
+
+            for i in 0..vertex_count {
+                mutation_rates[i] = values[i] + interaction_gains[i];
+            }
+
+            if total_weight > challenge.max_weight {
+                continue;
+            }
+
+            cooling_schedule[added_item] = 3;
+            cooling_schedule[removed_item] = 3;
+        }
+
+        if total_value >= challenge.min_value as i32 {
+            let final_items: Vec<usize> = selected_list.clone();
+            return Ok(Some(Solution { items: final_items }));
+        }
+
+        for c in cooling_schedule.iter_mut() {
+            *c = if *c > 0 { *c - 1 } else { 0 };
+        }
+
+        if total_value as u32 > (challenge.min_value * 9 / 10) {
+            let high_potential_items: Vec<usize> = unselected_list
+                .iter()
+                .copied()
+                .filter(|&i| values[i] > (challenge.min_value as i32 / 4))
+                .collect();
+
+            for &item in high_potential_items.iter().take(2) {
+                if total_weight + weights[item] <= challenge.max_weight {
+                    unselected_list.retain(|&x| x != item);
+
+                    add_item(
+                        item,
+                        &mut selected_bits,
+                        &mut total_value,
+                        &mut total_weight,
+                        &mut interaction_gains,
+                        challenge,
+                        &values,
+                        &weights,
+                    );
+                    selected_list.push(item);
+
+                    for i in 0..vertex_count {
+                        mutation_rates[i] = values[i] + interaction_gains[i];
+                    }
+
+                    if total_value >= challenge.min_value as i32 {
+                        let final_items: Vec<usize> = selected_list.clone();
+                        return Ok(Some(Solution { items: final_items }));
+                    }
+                }
+            }
+        }
+    }
+
+    if total_value as u32 >= challenge.min_value && total_weight <= challenge.max_weight {
+        let final_items: Vec<usize> = selected_list.clone();
+        Ok(Some(Solution { items: final_items }))
+    } else {
+        Ok(None)
+    }
+}
+
+#[cfg(feature = "cuda")]
+mod gpu_optimisation {
+    use super::*;
+    use cudarc::driver::*;
+    use std::{collections::HashMap, sync::Arc};
+    use tig_challenges::CudaKernel;
+
+    pub const KERNEL: Option<CudaKernel> = None;
+
+    pub fn cuda_solve_challenge(
+        challenge: &Challenge,
+        dev: &Arc<CudaDevice>,
+        mut funcs: HashMap<&'static str, CudaFunction>,
+    ) -> anyhow::Result<Option<Solution>> {
+        solve_challenge(challenge)
+    }
+}
+#[cfg(feature = "cuda")]
+pub use gpu_optimisation::{cuda_solve_challenge, KERNEL};
\ No newline at end of file
diff --git a/tig-algorithms/src/knapsack/quadkp_improved_opt/commercial.rs b/tig-algorithms/src/knapsack/quadkp_improved_opt/commercial.rs
new file mode 100644
index 00000000..5cdb7efc
--- /dev/null
+++ b/tig-algorithms/src/knapsack/quadkp_improved_opt/commercial.rs
@@ -0,0 +1,266 @@
+/*!
+Copyright 2025 VNX
+
+Licensed under the TIG Commercial License v2.0 (the "License"); you 
+may not use this file except in compliance with the License. You may obtain a copy 
+of the License at
+
+https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.
+*/
+
+use anyhow::Result;
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use tig_challenges::knapsack::{Challenge, Solution};
+
+
+fn add_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let gain = values[i] + interaction_gains[i];
+    selected_bits[i] = true;
+    *total_value += gain;
+    *total_weight += weights[i];
+    // Mise à jour des interactions
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] += challenge.interaction_values[i][j];
+    }
+}
+
+
+fn remove_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let removal_loss = values[i] + interaction_gains[i];
+    selected_bits[i] = false;
+    *total_value -= removal_loss;
+    *total_weight -= weights[i];
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] -= challenge.interaction_values[i][j];
+    }
+}
+
+pub fn solve_challenge(challenge: &Challenge) -> Result<Option<Solution>> {
+    let vertex_count = challenge.weights.len();
+
+    let values: Vec<i32> = challenge.values.iter().map(|&v| v as i32).collect();
+    let weights: Vec<u32> = challenge.weights.clone(); // ou .to_vec()
+
+    let mut item_scores: Vec<(usize, f32)> = (0..vertex_count)
+        .map(|i| {
+            let interaction_sum: i32 = challenge.interaction_values[i].iter().sum();
+            let secondary_score = values[i] as f32 / (weights[i].max(1)) as f32;
+            let combined_score = (values[i] as f32 * 0.75
+                + interaction_sum as f32 * 0.15
+                + secondary_score * 0.1)
+                / (weights[i] as f32).max(1.0);
+            (i, combined_score)
+        })
+        .collect();
+
+    item_scores.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+
+    let mut selected_bits = vec![false; vertex_count];
+    let mut interaction_gains = vec![0; vertex_count];
+
+    let mut total_value: i32 = 0;
+    let mut total_weight: u32 = 0;
+
+    let mut selected_list = Vec::with_capacity(vertex_count);
+    let mut unselected_list = Vec::with_capacity(vertex_count);
+
+    for &(i, _) in &item_scores {
+        if total_weight + weights[i] <= challenge.max_weight {
+            add_item(
+                i,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            selected_list.push(i);
+        } else {
+            unselected_list.push(i);
+        }
+    }
+
+    let mut mutation_rates = vec![0; vertex_count];
+    for i in 0..vertex_count {
+        mutation_rates[i] = values[i] + interaction_gains[i];
+    }
+
+    let max_generations = (vertex_count ) / 2;    
+    let mut cooling_schedule = vec![0; vertex_count];
+    let rng = StdRng::seed_from_u64(challenge.seed[0] as u64);
+
+    for _generation in 0..max_generations {
+        let mut best_gain = 0;
+        let mut best_swap = None;
+
+        for (u_index, &mutant) in unselected_list.iter().enumerate() {
+            if cooling_schedule[mutant] > 0 {
+                continue;
+            }
+            let mutant_fitness = mutation_rates[mutant];
+
+            let extra_weight = (weights[mutant] as i32)
+                - (challenge.max_weight as i32 - total_weight as i32);
+
+            if mutant_fitness < 0 {
+                continue;
+            }
+
+            for (c_index, &sel) in selected_list.iter().enumerate() {
+                if cooling_schedule[sel] > 0 {
+                    continue;
+                }
+                if extra_weight > 0 && (weights[sel] as i32) < extra_weight {
+                    continue;
+                }
+
+                let interaction_penalty =
+                    (challenge.interaction_values[mutant][sel] as f32 * 0.3) as i32;
+                let fitness_gain = mutant_fitness - mutation_rates[sel] - interaction_penalty;
+
+                if fitness_gain > best_gain {
+                    best_gain = fitness_gain;
+                    best_swap = Some((u_index, c_index));
+                }
+            }
+        }
+
+        if let Some((u_index, c_index)) = best_swap {
+            let added_item = unselected_list[u_index];
+            let removed_item = selected_list[c_index];
+
+            remove_item(
+                removed_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            add_item(
+                added_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+
+            selected_list.swap_remove(c_index);
+            unselected_list.swap_remove(u_index);
+            selected_list.push(added_item);
+            unselected_list.push(removed_item);
+
+            for i in 0..vertex_count {
+                mutation_rates[i] = values[i] + interaction_gains[i];
+            }
+
+            if total_weight > challenge.max_weight {
+                continue;
+            }
+
+            cooling_schedule[added_item] = 3;
+            cooling_schedule[removed_item] = 3;
+        }
+
+        if total_value >= challenge.min_value as i32 {
+            let final_items: Vec<usize> = selected_list.clone();
+            return Ok(Some(Solution { items: final_items }));
+        }
+
+        for c in cooling_schedule.iter_mut() {
+            *c = if *c > 0 { *c - 1 } else { 0 };
+        }
+
+        if total_value as u32 > (challenge.min_value * 9 / 10) {
+            let high_potential_items: Vec<usize> = unselected_list
+                .iter()
+                .copied()
+                .filter(|&i| values[i] > (challenge.min_value as i32 / 4))
+                .collect();
+
+            for &item in high_potential_items.iter().take(2) {
+                if total_weight + weights[item] <= challenge.max_weight {
+                    unselected_list.retain(|&x| x != item);
+
+                    add_item(
+                        item,
+                        &mut selected_bits,
+                        &mut total_value,
+                        &mut total_weight,
+                        &mut interaction_gains,
+                        challenge,
+                        &values,
+                        &weights,
+                    );
+                    selected_list.push(item);
+
+                    for i in 0..vertex_count {
+                        mutation_rates[i] = values[i] + interaction_gains[i];
+                    }
+
+                    if total_value >= challenge.min_value as i32 {
+                        let final_items: Vec<usize> = selected_list.clone();
+                        return Ok(Some(Solution { items: final_items }));
+                    }
+                }
+            }
+        }
+    }
+
+    if total_value as u32 >= challenge.min_value && total_weight <= challenge.max_weight {
+        let final_items: Vec<usize> = selected_list.clone();
+        Ok(Some(Solution { items: final_items }))
+    } else {
+        Ok(None)
+    }
+}
+
+#[cfg(feature = "cuda")]
+mod gpu_optimisation {
+    use super::*;
+    use cudarc::driver::*;
+    use std::{collections::HashMap, sync::Arc};
+    use tig_challenges::CudaKernel;
+
+    pub const KERNEL: Option<CudaKernel> = None;
+
+    pub fn cuda_solve_challenge(
+        challenge: &Challenge,
+        dev: &Arc<CudaDevice>,
+        mut funcs: HashMap<&'static str, CudaFunction>,
+    ) -> anyhow::Result<Option<Solution>> {
+        solve_challenge(challenge)
+    }
+}
+#[cfg(feature = "cuda")]
+pub use gpu_optimisation::{cuda_solve_challenge, KERNEL};
\ No newline at end of file
diff --git a/tig-algorithms/src/knapsack/quadkp_improved_opt/inbound.rs b/tig-algorithms/src/knapsack/quadkp_improved_opt/inbound.rs
new file mode 100644
index 00000000..2e911fe7
--- /dev/null
+++ b/tig-algorithms/src/knapsack/quadkp_improved_opt/inbound.rs
@@ -0,0 +1,270 @@
+/*!
+Copyright 2025 VNX
+
+Identity of Submitter VNX
+
+UAI null
+
+Licensed under the TIG Inbound Game License v2.0 or (at your option) any later
+version (the "License"); you may not use this file except in compliance with the
+License. You may obtain a copy of the License at
+
+https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.
+*/
+
+use anyhow::Result;
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use tig_challenges::knapsack::{Challenge, Solution};
+
+
+fn add_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let gain = values[i] + interaction_gains[i];
+    selected_bits[i] = true;
+    *total_value += gain;
+    *total_weight += weights[i];
+    // Mise à jour des interactions
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] += challenge.interaction_values[i][j];
+    }
+}
+
+
+fn remove_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let removal_loss = values[i] + interaction_gains[i];
+    selected_bits[i] = false;
+    *total_value -= removal_loss;
+    *total_weight -= weights[i];
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] -= challenge.interaction_values[i][j];
+    }
+}
+
+pub fn solve_challenge(challenge: &Challenge) -> Result<Option<Solution>> {
+    let vertex_count = challenge.weights.len();
+
+    let values: Vec<i32> = challenge.values.iter().map(|&v| v as i32).collect();
+    let weights: Vec<u32> = challenge.weights.clone(); // ou .to_vec()
+
+    let mut item_scores: Vec<(usize, f32)> = (0..vertex_count)
+        .map(|i| {
+            let interaction_sum: i32 = challenge.interaction_values[i].iter().sum();
+            let secondary_score = values[i] as f32 / (weights[i].max(1)) as f32;
+            let combined_score = (values[i] as f32 * 0.75
+                + interaction_sum as f32 * 0.15
+                + secondary_score * 0.1)
+                / (weights[i] as f32).max(1.0);
+            (i, combined_score)
+        })
+        .collect();
+
+    item_scores.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+
+    let mut selected_bits = vec![false; vertex_count];
+    let mut interaction_gains = vec![0; vertex_count];
+
+    let mut total_value: i32 = 0;
+    let mut total_weight: u32 = 0;
+
+    let mut selected_list = Vec::with_capacity(vertex_count);
+    let mut unselected_list = Vec::with_capacity(vertex_count);
+
+    for &(i, _) in &item_scores {
+        if total_weight + weights[i] <= challenge.max_weight {
+            add_item(
+                i,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            selected_list.push(i);
+        } else {
+            unselected_list.push(i);
+        }
+    }
+
+    let mut mutation_rates = vec![0; vertex_count];
+    for i in 0..vertex_count {
+        mutation_rates[i] = values[i] + interaction_gains[i];
+    }
+
+    let max_generations = (vertex_count ) / 2;    
+    let mut cooling_schedule = vec![0; vertex_count];
+    let rng = StdRng::seed_from_u64(challenge.seed[0] as u64);
+
+    for _generation in 0..max_generations {
+        let mut best_gain = 0;
+        let mut best_swap = None;
+
+        for (u_index, &mutant) in unselected_list.iter().enumerate() {
+            if cooling_schedule[mutant] > 0 {
+                continue;
+            }
+            let mutant_fitness = mutation_rates[mutant];
+
+            let extra_weight = (weights[mutant] as i32)
+                - (challenge.max_weight as i32 - total_weight as i32);
+
+            if mutant_fitness < 0 {
+                continue;
+            }
+
+            for (c_index, &sel) in selected_list.iter().enumerate() {
+                if cooling_schedule[sel] > 0 {
+                    continue;
+                }
+                if extra_weight > 0 && (weights[sel] as i32) < extra_weight {
+                    continue;
+                }
+
+                let interaction_penalty =
+                    (challenge.interaction_values[mutant][sel] as f32 * 0.3) as i32;
+                let fitness_gain = mutant_fitness - mutation_rates[sel] - interaction_penalty;
+
+                if fitness_gain > best_gain {
+                    best_gain = fitness_gain;
+                    best_swap = Some((u_index, c_index));
+                }
+            }
+        }
+
+        if let Some((u_index, c_index)) = best_swap {
+            let added_item = unselected_list[u_index];
+            let removed_item = selected_list[c_index];
+
+            remove_item(
+                removed_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            add_item(
+                added_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+
+            selected_list.swap_remove(c_index);
+            unselected_list.swap_remove(u_index);
+            selected_list.push(added_item);
+            unselected_list.push(removed_item);
+
+            for i in 0..vertex_count {
+                mutation_rates[i] = values[i] + interaction_gains[i];
+            }
+
+            if total_weight > challenge.max_weight {
+                continue;
+            }
+
+            cooling_schedule[added_item] = 3;
+            cooling_schedule[removed_item] = 3;
+        }
+
+        if total_value >= challenge.min_value as i32 {
+            let final_items: Vec<usize> = selected_list.clone();
+            return Ok(Some(Solution { items: final_items }));
+        }
+
+        for c in cooling_schedule.iter_mut() {
+            *c = if *c > 0 { *c - 1 } else { 0 };
+        }
+
+        if total_value as u32 > (challenge.min_value * 9 / 10) {
+            let high_potential_items: Vec<usize> = unselected_list
+                .iter()
+                .copied()
+                .filter(|&i| values[i] > (challenge.min_value as i32 / 4))
+                .collect();
+
+            for &item in high_potential_items.iter().take(2) {
+                if total_weight + weights[item] <= challenge.max_weight {
+                    unselected_list.retain(|&x| x != item);
+
+                    add_item(
+                        item,
+                        &mut selected_bits,
+                        &mut total_value,
+                        &mut total_weight,
+                        &mut interaction_gains,
+                        challenge,
+                        &values,
+                        &weights,
+                    );
+                    selected_list.push(item);
+
+                    for i in 0..vertex_count {
+                        mutation_rates[i] = values[i] + interaction_gains[i];
+                    }
+
+                    if total_value >= challenge.min_value as i32 {
+                        let final_items: Vec<usize> = selected_list.clone();
+                        return Ok(Some(Solution { items: final_items }));
+                    }
+                }
+            }
+        }
+    }
+
+    if total_value as u32 >= challenge.min_value && total_weight <= challenge.max_weight {
+        let final_items: Vec<usize> = selected_list.clone();
+        Ok(Some(Solution { items: final_items }))
+    } else {
+        Ok(None)
+    }
+}
+
+#[cfg(feature = "cuda")]
+mod gpu_optimisation {
+    use super::*;
+    use cudarc::driver::*;
+    use std::{collections::HashMap, sync::Arc};
+    use tig_challenges::CudaKernel;
+
+    pub const KERNEL: Option<CudaKernel> = None;
+
+    pub fn cuda_solve_challenge(
+        challenge: &Challenge,
+        dev: &Arc<CudaDevice>,
+        mut funcs: HashMap<&'static str, CudaFunction>,
+    ) -> anyhow::Result<Option<Solution>> {
+        solve_challenge(challenge)
+    }
+}
+#[cfg(feature = "cuda")]
+pub use gpu_optimisation::{cuda_solve_challenge, KERNEL};
\ No newline at end of file
diff --git a/tig-algorithms/src/knapsack/quadkp_improved_opt/innovator_outbound.rs b/tig-algorithms/src/knapsack/quadkp_improved_opt/innovator_outbound.rs
new file mode 100644
index 00000000..a818daa7
--- /dev/null
+++ b/tig-algorithms/src/knapsack/quadkp_improved_opt/innovator_outbound.rs
@@ -0,0 +1,270 @@
+/*!
+Copyright 2025 VNX
+
+Identity of Submitter VNX
+
+UAI null
+
+Licensed under the TIG Innovator Outbound Game License v2.0 (the "License"); you
+may not use this file except in compliance with the License. You may obtain a copy
+of the License at
+
+https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.
+*/
+
+use anyhow::Result;
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use tig_challenges::knapsack::{Challenge, Solution};
+
+
+fn add_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let gain = values[i] + interaction_gains[i];
+    selected_bits[i] = true;
+    *total_value += gain;
+    *total_weight += weights[i];
+    // Mise à jour des interactions
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] += challenge.interaction_values[i][j];
+    }
+}
+
+
+fn remove_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let removal_loss = values[i] + interaction_gains[i];
+    selected_bits[i] = false;
+    *total_value -= removal_loss;
+    *total_weight -= weights[i];
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] -= challenge.interaction_values[i][j];
+    }
+}
+
+pub fn solve_challenge(challenge: &Challenge) -> Result<Option<Solution>> {
+    let vertex_count = challenge.weights.len();
+
+    let values: Vec<i32> = challenge.values.iter().map(|&v| v as i32).collect();
+    let weights: Vec<u32> = challenge.weights.clone(); // ou .to_vec()
+
+    let mut item_scores: Vec<(usize, f32)> = (0..vertex_count)
+        .map(|i| {
+            let interaction_sum: i32 = challenge.interaction_values[i].iter().sum();
+            let secondary_score = values[i] as f32 / (weights[i].max(1)) as f32;
+            let combined_score = (values[i] as f32 * 0.75
+                + interaction_sum as f32 * 0.15
+                + secondary_score * 0.1)
+                / (weights[i] as f32).max(1.0);
+            (i, combined_score)
+        })
+        .collect();
+
+    item_scores.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+
+    let mut selected_bits = vec![false; vertex_count];
+    let mut interaction_gains = vec![0; vertex_count];
+
+    let mut total_value: i32 = 0;
+    let mut total_weight: u32 = 0;
+
+    let mut selected_list = Vec::with_capacity(vertex_count);
+    let mut unselected_list = Vec::with_capacity(vertex_count);
+
+    for &(i, _) in &item_scores {
+        if total_weight + weights[i] <= challenge.max_weight {
+            add_item(
+                i,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            selected_list.push(i);
+        } else {
+            unselected_list.push(i);
+        }
+    }
+
+    let mut mutation_rates = vec![0; vertex_count];
+    for i in 0..vertex_count {
+        mutation_rates[i] = values[i] + interaction_gains[i];
+    }
+
+    let max_generations = (vertex_count ) / 2;    
+    let mut cooling_schedule = vec![0; vertex_count];
+    let rng = StdRng::seed_from_u64(challenge.seed[0] as u64);
+
+    for _generation in 0..max_generations {
+        let mut best_gain = 0;
+        let mut best_swap = None;
+
+        for (u_index, &mutant) in unselected_list.iter().enumerate() {
+            if cooling_schedule[mutant] > 0 {
+                continue;
+            }
+            let mutant_fitness = mutation_rates[mutant];
+
+            let extra_weight = (weights[mutant] as i32)
+                - (challenge.max_weight as i32 - total_weight as i32);
+
+            if mutant_fitness < 0 {
+                continue;
+            }
+
+            for (c_index, &sel) in selected_list.iter().enumerate() {
+                if cooling_schedule[sel] > 0 {
+                    continue;
+                }
+                if extra_weight > 0 && (weights[sel] as i32) < extra_weight {
+                    continue;
+                }
+
+                let interaction_penalty =
+                    (challenge.interaction_values[mutant][sel] as f32 * 0.3) as i32;
+                let fitness_gain = mutant_fitness - mutation_rates[sel] - interaction_penalty;
+
+                if fitness_gain > best_gain {
+                    best_gain = fitness_gain;
+                    best_swap = Some((u_index, c_index));
+                }
+            }
+        }
+
+        if let Some((u_index, c_index)) = best_swap {
+            let added_item = unselected_list[u_index];
+            let removed_item = selected_list[c_index];
+
+            remove_item(
+                removed_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            add_item(
+                added_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+
+            selected_list.swap_remove(c_index);
+            unselected_list.swap_remove(u_index);
+            selected_list.push(added_item);
+            unselected_list.push(removed_item);
+
+            for i in 0..vertex_count {
+                mutation_rates[i] = values[i] + interaction_gains[i];
+            }
+
+            if total_weight > challenge.max_weight {
+                continue;
+            }
+
+            cooling_schedule[added_item] = 3;
+            cooling_schedule[removed_item] = 3;
+        }
+
+        if total_value >= challenge.min_value as i32 {
+            let final_items: Vec<usize> = selected_list.clone();
+            return Ok(Some(Solution { items: final_items }));
+        }
+
+        for c in cooling_schedule.iter_mut() {
+            *c = if *c > 0 { *c - 1 } else { 0 };
+        }
+
+        if total_value as u32 > (challenge.min_value * 9 / 10) {
+            let high_potential_items: Vec<usize> = unselected_list
+                .iter()
+                .copied()
+                .filter(|&i| values[i] > (challenge.min_value as i32 / 4))
+                .collect();
+
+            for &item in high_potential_items.iter().take(2) {
+                if total_weight + weights[item] <= challenge.max_weight {
+                    unselected_list.retain(|&x| x != item);
+
+                    add_item(
+                        item,
+                        &mut selected_bits,
+                        &mut total_value,
+                        &mut total_weight,
+                        &mut interaction_gains,
+                        challenge,
+                        &values,
+                        &weights,
+                    );
+                    selected_list.push(item);
+
+                    for i in 0..vertex_count {
+                        mutation_rates[i] = values[i] + interaction_gains[i];
+                    }
+
+                    if total_value >= challenge.min_value as i32 {
+                        let final_items: Vec<usize> = selected_list.clone();
+                        return Ok(Some(Solution { items: final_items }));
+                    }
+                }
+            }
+        }
+    }
+
+    if total_value as u32 >= challenge.min_value && total_weight <= challenge.max_weight {
+        let final_items: Vec<usize> = selected_list.clone();
+        Ok(Some(Solution { items: final_items }))
+    } else {
+        Ok(None)
+    }
+}
+
+#[cfg(feature = "cuda")]
+mod gpu_optimisation {
+    use super::*;
+    use cudarc::driver::*;
+    use std::{collections::HashMap, sync::Arc};
+    use tig_challenges::CudaKernel;
+
+    pub const KERNEL: Option<CudaKernel> = None;
+
+    pub fn cuda_solve_challenge(
+        challenge: &Challenge,
+        dev: &Arc<CudaDevice>,
+        mut funcs: HashMap<&'static str, CudaFunction>,
+    ) -> anyhow::Result<Option<Solution>> {
+        solve_challenge(challenge)
+    }
+}
+#[cfg(feature = "cuda")]
+pub use gpu_optimisation::{cuda_solve_challenge, KERNEL};
\ No newline at end of file
diff --git a/tig-algorithms/src/knapsack/quadkp_improved_opt/mod.rs b/tig-algorithms/src/knapsack/quadkp_improved_opt/mod.rs
new file mode 100644
index 00000000..fcec9672
--- /dev/null
+++ b/tig-algorithms/src/knapsack/quadkp_improved_opt/mod.rs
@@ -0,0 +1,4 @@
+mod benchmarker_outbound;
+pub use benchmarker_outbound::solve_challenge;
+#[cfg(feature = "cuda")]
+pub use benchmarker_outbound::{cuda_solve_challenge, KERNEL};
\ No newline at end of file
diff --git a/tig-algorithms/src/knapsack/quadkp_improved_opt/open_data.rs b/tig-algorithms/src/knapsack/quadkp_improved_opt/open_data.rs
new file mode 100644
index 00000000..8e3174a1
--- /dev/null
+++ b/tig-algorithms/src/knapsack/quadkp_improved_opt/open_data.rs
@@ -0,0 +1,266 @@
+/*!
+Copyright 2025 VNX
+
+Licensed under the TIG Open Data License v2.0 or (at your option) any later version
+(the "License"); you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://github.com/tig-foundation/tig-monorepo/tree/main/docs/licenses
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.
+*/
+
+use anyhow::Result;
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use tig_challenges::knapsack::{Challenge, Solution};
+
+
+fn add_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let gain = values[i] + interaction_gains[i];
+    selected_bits[i] = true;
+    *total_value += gain;
+    *total_weight += weights[i];
+    // Mise à jour des interactions
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] += challenge.interaction_values[i][j];
+    }
+}
+
+
+fn remove_item(
+    i: usize,
+    selected_bits: &mut [bool],
+    total_value: &mut i32,
+    total_weight: &mut u32,
+    interaction_gains: &mut [i32],
+    challenge: &Challenge,
+    values: &[i32],
+    weights: &[u32],
+) {
+    let removal_loss = values[i] + interaction_gains[i];
+    selected_bits[i] = false;
+    *total_value -= removal_loss;
+    *total_weight -= weights[i];
+    for j in 0..interaction_gains.len() {
+        interaction_gains[j] -= challenge.interaction_values[i][j];
+    }
+}
+
+pub fn solve_challenge(challenge: &Challenge) -> Result<Option<Solution>> {
+    let vertex_count = challenge.weights.len();
+
+    let values: Vec<i32> = challenge.values.iter().map(|&v| v as i32).collect();
+    let weights: Vec<u32> = challenge.weights.clone(); // ou .to_vec()
+
+    let mut item_scores: Vec<(usize, f32)> = (0..vertex_count)
+        .map(|i| {
+            let interaction_sum: i32 = challenge.interaction_values[i].iter().sum();
+            let secondary_score = values[i] as f32 / (weights[i].max(1)) as f32;
+            let combined_score = (values[i] as f32 * 0.75
+                + interaction_sum as f32 * 0.15
+                + secondary_score * 0.1)
+                / (weights[i] as f32).max(1.0);
+            (i, combined_score)
+        })
+        .collect();
+
+    item_scores.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+
+    let mut selected_bits = vec![false; vertex_count];
+    let mut interaction_gains = vec![0; vertex_count];
+
+    let mut total_value: i32 = 0;
+    let mut total_weight: u32 = 0;
+
+    let mut selected_list = Vec::with_capacity(vertex_count);
+    let mut unselected_list = Vec::with_capacity(vertex_count);
+
+    for &(i, _) in &item_scores {
+        if total_weight + weights[i] <= challenge.max_weight {
+            add_item(
+                i,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            selected_list.push(i);
+        } else {
+            unselected_list.push(i);
+        }
+    }
+
+    let mut mutation_rates = vec![0; vertex_count];
+    for i in 0..vertex_count {
+        mutation_rates[i] = values[i] + interaction_gains[i];
+    }
+
+    let max_generations = (vertex_count ) / 2;    
+    let mut cooling_schedule = vec![0; vertex_count];
+    let rng = StdRng::seed_from_u64(challenge.seed[0] as u64);
+
+    for _generation in 0..max_generations {
+        let mut best_gain = 0;
+        let mut best_swap = None;
+
+        for (u_index, &mutant) in unselected_list.iter().enumerate() {
+            if cooling_schedule[mutant] > 0 {
+                continue;
+            }
+            let mutant_fitness = mutation_rates[mutant];
+
+            let extra_weight = (weights[mutant] as i32)
+                - (challenge.max_weight as i32 - total_weight as i32);
+
+            if mutant_fitness < 0 {
+                continue;
+            }
+
+            for (c_index, &sel) in selected_list.iter().enumerate() {
+                if cooling_schedule[sel] > 0 {
+                    continue;
+                }
+                if extra_weight > 0 && (weights[sel] as i32) < extra_weight {
+                    continue;
+                }
+
+                let interaction_penalty =
+                    (challenge.interaction_values[mutant][sel] as f32 * 0.3) as i32;
+                let fitness_gain = mutant_fitness - mutation_rates[sel] - interaction_penalty;
+
+                if fitness_gain > best_gain {
+                    best_gain = fitness_gain;
+                    best_swap = Some((u_index, c_index));
+                }
+            }
+        }
+
+        if let Some((u_index, c_index)) = best_swap {
+            let added_item = unselected_list[u_index];
+            let removed_item = selected_list[c_index];
+
+            remove_item(
+                removed_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+            add_item(
+                added_item,
+                &mut selected_bits,
+                &mut total_value,
+                &mut total_weight,
+                &mut interaction_gains,
+                challenge,
+                &values,
+                &weights,
+            );
+
+            selected_list.swap_remove(c_index);
+            unselected_list.swap_remove(u_index);
+            selected_list.push(added_item);
+            unselected_list.push(removed_item);
+
+            for i in 0..vertex_count {
+                mutation_rates[i] = values[i] + interaction_gains[i];
+            }
+
+            if total_weight > challenge.max_weight {
+                continue;
+            }
+
+            cooling_schedule[added_item] = 3;
+            cooling_schedule[removed_item] = 3;
+        }
+
+        if total_value >= challenge.min_value as i32 {
+            let final_items: Vec<usize> = selected_list.clone();
+            return Ok(Some(Solution { items: final_items }));
+        }
+
+        for c in cooling_schedule.iter_mut() {
+            *c = if *c > 0 { *c - 1 } else { 0 };
+        }
+
+        if total_value as u32 > (challenge.min_value * 9 / 10) {
+            let high_potential_items: Vec<usize> = unselected_list
+                .iter()
+                .copied()
+                .filter(|&i| values[i] > (challenge.min_value as i32 / 4))
+                .collect();
+
+            for &item in high_potential_items.iter().take(2) {
+                if total_weight + weights[item] <= challenge.max_weight {
+                    unselected_list.retain(|&x| x != item);
+
+                    add_item(
+                        item,
+                        &mut selected_bits,
+                        &mut total_value,
+                        &mut total_weight,
+                        &mut interaction_gains,
+                        challenge,
+                        &values,
+                        &weights,
+                    );
+                    selected_list.push(item);
+
+                    for i in 0..vertex_count {
+                        mutation_rates[i] = values[i] + interaction_gains[i];
+                    }
+
+                    if total_value >= challenge.min_value as i32 {
+                        let final_items: Vec<usize> = selected_list.clone();
+                        return Ok(Some(Solution { items: final_items }));
+                    }
+                }
+            }
+        }
+    }
+
+    if total_value as u32 >= challenge.min_value && total_weight <= challenge.max_weight {
+        let final_items: Vec<usize> = selected_list.clone();
+        Ok(Some(Solution { items: final_items }))
+    } else {
+        Ok(None)
+    }
+}
+
+#[cfg(feature = "cuda")]
+mod gpu_optimisation {
+    use super::*;
+    use cudarc::driver::*;
+    use std::{collections::HashMap, sync::Arc};
+    use tig_challenges::CudaKernel;
+
+    pub const KERNEL: Option<CudaKernel> = None;
+
+    pub fn cuda_solve_challenge(
+        challenge: &Challenge,
+        dev: &Arc<CudaDevice>,
+        mut funcs: HashMap<&'static str, CudaFunction>,
+    ) -> anyhow::Result<Option<Solution>> {
+        solve_challenge(challenge)
+    }
+}
+#[cfg(feature = "cuda")]
+pub use gpu_optimisation::{cuda_solve_challenge, KERNEL};
\ No newline at end of file
diff --git a/tig-algorithms/wasm/knapsack/quadkp_improved_opt.wasm b/tig-algorithms/wasm/knapsack/quadkp_improved_opt.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..a7737d0695d7a79bd87fb7e87c4628e1e1564e9b
GIT binary patch
literal 166446
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
H*^U1N)rXHO

literal 0
HcmV?d00001