rust N-Queens Algorithm

N皇后 rust-algorithm

use std::rc::Rc;
use std::cell::RefCell;
struct Queens {
    target:i32,
    results:Rc<RefCell<Vec<Vec<i32>>>>,
}
impl Queens {
    pub fn new() -> Queens {
        let queen = Queens {
            target:8i32,
            results:Rc::new(RefCell::new(vec![])),
        };
        queen.find_result(vec![]);
        return queen;     
    }
    fn find_result(&self,result:Vec<i32>) -> bool {
        if result.len() == self.target as usize {
            self.results.borrow_mut().push(result);
            return true;
        }
        let current_row = result.len();
        for i in 0 .. self.target {
            if self.is_valid(current_row as i32,i,&result) {
                let mut new_result = result.clone();
                new_result.push(i);
                self.find_result(new_result);
            }
        }
        return false;
    }
    fn is_valid(&self,r:i32,c:i32,result:&Vec<i32>) -> bool {
        for (index,&value) in result.iter().enumerate() {
            if r == index as i32 || c == value || (c - value).abs() == (r - index as i32).abs() {
                return false;
            }
        }
        return true;
    }
    fn output_results(&self) {
        for result in &(*self.results.borrow()) {
            let mut line = result.iter().fold(String::from("["),|mut acc,elem| -> String {
                acc = format!("{}{} ",acc,elem);
                return acc;
            });
            line.pop();
            line.push(']');
            println!("{}",line);
        }
    }
    pub fn set_target(&mut self,t:i32) {
        self.target = t;
        self.find_result(vec![]);
    }
    pub fn results_len(&self) -> usize {
        return self.results.borrow().len();
    }
}
fn main() {
    let mut queen = Queens::new();
    queen.results_len();
    queen.output_results();
    queen.set_target(12);
    queen.output_results();
}