Bittijono

warning: variable does not need to be mutable
  --> input/code.rs:13:9
   |
13 |     let mut nums = input.trim().chars();
   |         ----^^^^
   |         |
   |         help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: variable does not need to be mutable
  --> input/code.rs:14:9
   |
14 |     let mut list_a = nums.map(|c| c == '1').collect::<Vec<_>>();
   |         ----^^^^^^
   |         |
   |         help: remove this `mut`

warning: variable does not need to be mutable
  --> input/code.rs:18:9
   |
18 |     let mut nums = input.trim().chars();
   |         ----^^^^
   |         |
   |         help: remove this `mut`

warning: variable does not need to be mutable
  --> input/code.rs:19:9
   |
19 |     let mut list_b = nums.map(|c| c == '1').collect::<Vec<_>>();
   |         ----^^^^^^
   |         |
   |         help: remove this `mut`

warning: unused variable: `a`
  --> input/code.rs:41:41
   |
41 |     fn new(amount: usize, change: bool, a:...

use std::io::stdin;
fn main() {
    let stdin = stdin();
    let mut input = String::new();
    _ = stdin.read_line(&mut input);
    let mut nums = input.split_whitespace();
    let n = nums.next().unwrap().parse::<usize>().unwrap();
    let a = nums.next().unwrap().parse::<usize>().unwrap();
    let b = nums.next().unwrap().parse::<usize>().unwrap();

    input.clear();
    _ = stdin.read_line(&mut input);
    let mut nums = input.trim().chars();
    let mut list_a = nums.map(|c| c == '1').collect::<Vec<_>>();

    input.clear();
    _ = stdin.read_line(&mut input);
    let mut nums = input.trim().chars();
    let mut list_b = nums.map(|c| c == '1').collect::<Vec<_>>();

    let mut lines = vec![];

    for i in 0..n {
        let val = list_a[i] ^ list_b[i];
        Line::list_lines_add(&mut lines, val, a, b);
    }

    println!("{lines:?}");

    let cost = Line::start_cost_eval(lines, a, b);

    println!("{cost}");
}

#[derive(Clone, Copy, Debug)]
struct Line {
    amount: usize,
    change: bool,
}
impl Line {
    fn new(amount: usize, change: bool, a: usize, b: usize) -> Self {
        //let c = Self::flip_cost(amount, a, b);
        Self { amount, change }
    }
    fn list_lines_add(list: &mut Vec<Line>, change: bool, a: usize, b: usize) {
        if list.len() > 0 {
            let last = list.last_mut().unwrap();
            let amount = last.amount;
            if last.change == change {
                last.amount += 1;
            } else {
                list.push(Line::new(1, change, a, b));
            }
        } else {
            list.push(Line::new(1, change, a, b));
        }
    }
    fn start_cost_eval(mut list: Vec<Line>, a: usize, b: usize) -> usize {
        if !list[0].change {
            list.remove(0);
        }
        if let Some(l) = list.last() {
            if !l.change {
                list.remove(list.len() - 1);
            }
        }
        Self::list_lines_cost(&list, a, b)
    }
    fn list_lines_cost(list: &[Line], a: usize, b: usize) -> usize {
        let seperate_cost = list
            .iter()
            .fold(0, |acc, o| if o.change { acc + o.cost(a, b) } else { acc });
        let total_amount = list.iter().fold(0, |acc, a| acc + a.amount);
        let all_flip_cost = Self::flip_cost(total_amount, a, b);
        if list.len() < 3 {
            return seperate_cost;
        }
        if list.len() == 3 {
            if all_flip_cost + list[1].cost(a, b) < seperate_cost {
                return all_flip_cost + list[1].cost(a, b);
            }
            return seperate_cost;
        }
        let pairs = (list.len() - 1) / 2;
        let mut best: Option<usize> = None;
        for i in 0..pairs {
            let start_i = i * 2;

            for l in 0..pairs - i {
                let end_i = start_i + 2 * (l + 1);
                let t_cost = Self::list_lines_cost(&list[start_i..end_i], a, b);
                let mut excluded_cost = 0;
                excluded_cost += Self::list_lines_cost(&list[..start_i], a, b);
                excluded_cost += Self::list_lines_cost(&list[end_i..], a, b);
                if let Some(b) = best.as_mut() {
                    *b = (*b).min(t_cost + excluded_cost);
                } else {
                    best = Some(t_cost + excluded_cost);
                }
                println!("best: {best:?}");
                println!("curr:  i: {start_i} l: {end_i}");
            }
        }
        return best.unwrap();
    }
    fn cost(&self, a: usize, b: usize) -> usize {
        Self::flip_cost(self.amount, a, b)
    }
    fn flip_cost(amount: usize, a: usize, b: usize) -> usize {
        let use_b_if_more = b / a;
        if amount > use_b_if_more {
            return b;
        }
        amount * a
    }
}

Test 1 (public)

Group: 1, 3

Verdict: WRONG ANSWER

Test 2

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 3

Group: 1, 3

Verdict: WRONG ANSWER

Test 4

Group: 1, 3

Verdict: WRONG ANSWER

Test 5

Group: 1, 3

Verdict: WRONG ANSWER

Test 6

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 7

Group: 2, 3

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 2, 3

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 2, 3

Verdict: TIME LIMIT EXCEEDED

Test 11

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 2, 3

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 17

Group: 1, 3

Verdict: WRONG ANSWER

Test 18

Group: 1, 3

Verdict: WRONG ANSWER

Test 19

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 3

Verdict: WRONG ANSWER