bczhc · January 27, 2026 14:34
diff --git a/a.md b/a.md
diff --git a/main.rs b/main.rs
 use std::char;
 use std::env;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;

 fn make_polluted(text: &str) -> String {
    // 与你示例里相同的转换逻辑
    let bytes = zsh_metafied::metafy(text.as_bytes());
    let s = String::from_utf8_lossy(&bytes).to_string();
    s.replace(char::REPLACEMENT_CHARACTER, "?")
 }

 fn main() {
    // 加载目标 polluted（从文件读取，不写 literal）
    let target_polluted = include_str!("../../target-polluted.txt").trim().to_string();

    // 加载字表（请确认你本地的 charset 文件路径是否为 ../../charset.txt）
    // 如果你的字表与 target-polluted 在同一文件，请按需修改此处路径。
    let han_charset = include_str!("../../charset-chinese-1500.txt").trim();
    let mut chars = han_charset.chars().collect::<Vec<_>>();

    // 扩充一些常用符号
    chars.extend(['。', '，', '！', '？', '；', '：', ' ', '“', '”'].iter());

    // 可通过命令行参数传入已知的起始前缀，例如 `cargo run -- 从`
    let start_prefix = env::args().nth(1).unwrap_or_default();

    // 限制：为了避免无限增长，设定原文长度上限为 target_polluted.len() * 2（可调整）
    let max_original_len = (target_polluted.len().max(1)) * 2;

    println!("target_polluted (len={}):\n{}\n", target_polluted.len(), target_polluted);
    println!("starting prefix: {:?}", start_prefix);
    println!("charset size: {}", chars.len());
    println!("max original len: {}", max_original_len);

    // 计数器（可选，用于观察进度）
    let trials = Arc::new(AtomicUsize::new(0));
    let mut solutions: Vec<String> = Vec::new();

    // DFS 回溯闭包（递归）
    fn dfs(
        cur_text: String,
        chars: &Vec<char>,
        target: &str,
        max_len: usize,
        trials: Arc<AtomicUsize>,
        solutions: &mut Vec<String>,
    ) {
        // safety: stop if current text too long
        if cur_text.len() > max_len {
            return;
        }

        // 每次尝试前缀对应的 polluted
        let polluted = make_polluted(&cur_text);
        trials.fetch_add(1, Ordering::Relaxed);

        // 如果 polluted 不是 target 的前缀，则这个分支可以剪枝
        if !target.starts_with(&polluted) {
            return;
        }

        println!("{}", cur_text);

        // 如果恰好相等，记录为解（注意可能有多个）
        if polluted == target {
            solutions.push(cur_text.clone());
            // 继续搜索可能存在更长的原文也映射到相同 polluted（取决情况），可以选择返回或继续；
            // 这里继续探索以寻找所有可能。
        }

        // 继续扩展下一个字（回溯）
        if cur_text.len() < max_len {
            for &ch in chars.iter() {
                let mut next = cur_text.clone();
                next.push(ch);
                // 进一步递归
                dfs(next, chars, target, max_len, Arc::clone(&trials), solutions);
            }
        }
    }

    // 启动 DFS
    dfs(
        start_prefix.clone(),
        &chars,
        &target_polluted,
        max_original_len,
        Arc::clone(&trials),
        &mut solutions,
    );

    // 输出结果
    println!("\ntrials tried: {}", trials.load(Ordering::Relaxed));
    if solutions.is_empty() {
        println!("No solutions found within the max length ({}).", max_original_len);
    } else {
        println!("Found {} solution(s):", solutions.len());
        for (i, s) in solutions.iter().enumerate() {
            println!("{}: {:?}", i + 1, s);
            // 也打印对应的 polluted 以供核对
            println!("   polluted: {}", make_polluted(s));
        }
    }
 }
	use std::char;
	use std::env;
	use std::sync::atomic::{AtomicUsize, Ordering};
	use std::sync::Arc;

	fn make_polluted(text: &str) -> String {
	// 与你示例里相同的转换逻辑
	let bytes = zsh_metafied::metafy(text.as_bytes());
	let s = String::from_utf8_lossy(&bytes).to_string();
	s.replace(char::REPLACEMENT_CHARACTER, "?")
	}

	fn main() {
	// 加载目标 polluted（从文件读取，不写 literal）
	let target_polluted = include_str!("../../target-polluted.txt").trim().to_string();

	// 加载字表（请确认你本地的 charset 文件路径是否为 ../../charset.txt）
	// 如果你的字表与 target-polluted 在同一文件，请按需修改此处路径。
	let han_charset = include_str!("../../charset-chinese-1500.txt").trim();
	let mut chars = han_charset.chars().collect::<Vec<_>>();

	// 扩充一些常用符号
	chars.extend(['。', '，', '！', '？', '；', '：', ' ', '“', '”'].iter());

	// 可通过命令行参数传入已知的起始前缀，例如 `cargo run -- 从`
	let start_prefix = env::args().nth(1).unwrap_or_default();

	// 限制：为了避免无限增长，设定原文长度上限为 target_polluted.len() * 2（可调整）
	let max_original_len = (target_polluted.len().max(1)) * 2;

	println!("target_polluted (len={}):\n{}\n", target_polluted.len(), target_polluted);
	println!("starting prefix: {:?}", start_prefix);
	println!("charset size: {}", chars.len());
	println!("max original len: {}", max_original_len);

	// 计数器（可选，用于观察进度）
	let trials = Arc::new(AtomicUsize::new(0));
	let mut solutions: Vec<String> = Vec::new();

	// DFS 回溯闭包（递归）
	fn dfs(
	cur_text: String,
	chars: &Vec<char>,
	target: &str,
	max_len: usize,
	trials: Arc<AtomicUsize>,
	solutions: &mut Vec<String>,
	) {
	// safety: stop if current text too long
	if cur_text.len() > max_len {
	return;
	}

	// 每次尝试前缀对应的 polluted
	let polluted = make_polluted(&cur_text);
	trials.fetch_add(1, Ordering::Relaxed);

	// 如果 polluted 不是 target 的前缀，则这个分支可以剪枝
	if !target.starts_with(&polluted) {
	return;
	}

	println!("{}", cur_text);

	// 如果恰好相等，记录为解（注意可能有多个）
	if polluted == target {
	solutions.push(cur_text.clone());
	// 继续搜索可能存在更长的原文也映射到相同 polluted（取决情况），可以选择返回或继续；
	// 这里继续探索以寻找所有可能。
	}

	// 继续扩展下一个字（回溯）
	if cur_text.len() < max_len {
	for &ch in chars.iter() {
	let mut next = cur_text.clone();
	next.push(ch);
	// 进一步递归
	dfs(next, chars, target, max_len, Arc::clone(&trials), solutions);
	}
	}
	}

	// 启动 DFS
	dfs(
	start_prefix.clone(),
	&chars,
	&target_polluted,
	max_original_len,
	Arc::clone(&trials),
	&mut solutions,
	);

	// 输出结果
	println!("\ntrials tried: {}", trials.load(Ordering::Relaxed));
	if solutions.is_empty() {
	println!("No solutions found within the max length ({}).", max_original_len);
	} else {
	println!("Found {} solution(s):", solutions.len());
	for (i, s) in solutions.iter().enumerate() {
	println!("{}: {:?}", i + 1, s);
	// 也打印对应的 polluted 以供核对
	println!(" polluted: {}", make_polluted(s));
	}
	}
	}
No results found