Lista

use std::io::{stdin, BufRead, BufReader};

fn main() {
    let mut stdin = BufReader::new(stdin());
    let mut cur_line = String::new();

    stdin.read_line(&mut cur_line).unwrap();
    let n = cur_line.trim().parse::<usize>().unwrap();

    let mut res = Vec::new();

    cur_line.clear();
    stdin.read_line(&mut cur_line).unwrap();
    let x = cur_line.trim();
    res.push(to_min_int_s(x));

    for i in 1..n {
        cur_line.clear();
        stdin.read_line(&mut cur_line).unwrap();
        let x = cur_line.trim();

        if let Some(next) = min_greater(res[i - 1], x) {
            res.push(next);
        } else {
            println!("IMPOSSIBLE");
            std::process::exit(0);
        }
    }

    for v in res {
        println!("{}", v);
    }
}

fn min_greater(x: i64, digs: &str) -> Option<i64> {
    if to_min_int(digs) > x {
        return Some(to_min_int(digs));
    }

    let k = 10i64.pow(digs.len() as u32 - 1);
    let d = digs.chars().next()?;
    if d == '?' {
        for v in 1..=9 {
            if let Some(r) = min_greater_inner(x - v * k, &digs[1..]) {
                return Some(v * k + r);
            }
        }
    } else {
        let v = (d as u32 - b'0' as u32) as i64;
        if let Some(r) = min_greater_inner(x - v * k, &digs[1..]) {
            return Some(v * k + r);
        }
    }

    None
}

fn min_greater_inner(x: i64, digs: &str) -> Option<i64> {
    if to_min_int(digs) > x {
        return Some(to_min_int(digs));
    }

    let k = 10i64.pow(digs.len() as u32 - 1);
    let d = digs.chars().next()?;
    if d == '?' {
        for v in 0..=9 {
            if (v + 1) * k >= x {
                if let Some(r) = min_greater_inner(x - v * k, &digs[1..]) {
                    return Some(v * k + r);
                }
            }
        }
    } else {
        let v = (d as u32 - b'0' as u32) as i64;
        if let Some(r) = min_greater_inner(x - v * k, &digs[1..]) {
            return Some(v * k + r);
        }
    }

    None
}

fn to_min_int(digs: &str) -> i64 {
    let mut n = 0;
    for d in digs.chars() {
        match d {
            '?' => n *= 10,
            c @ '0'..='9' => n = 10 * n + (c as u32 - b'0' as u32) as i64,
            _ => (),
        }
    }
    n
}

fn to_min_int_s(digs: &str) -> i64 {
    let mut n = match digs.chars().next().unwrap() {
        '?' => 1,
        c @ '0'..='9' => (c as u32 - b'0' as u32) as i64,
        _ => panic!(),
    };
    for d in digs.chars().skip(1) {
        match d {
            '?' => n *= 10,
            c @ '0'..='9' => n = 10 * n + (c as u32 - b'0' as u32) as i64,
            _ => (),
        }
    }
    n
}

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2

Group: 2, 3

Verdict: ACCEPTED

Test 3

Group: 3

Verdict: ACCEPTED

Test 4

Group: 1, 2, 3

Verdict: ACCEPTED

Test 5

Group: 1, 2, 3

Verdict: ACCEPTED

Test 6

Group: 1, 2, 3

Verdict: ACCEPTED

Test 7

Group: 1, 2, 3

Verdict: ACCEPTED

Test 8

Group: 3

Verdict: ACCEPTED

Test 9

Group: 3

Verdict: ACCEPTED

Test 10

Group: 3

Verdict: ACCEPTED