I am coding a small tree like structure in Rust for Monte Carlo tree search. I need to backpropagate the result that has been produced at end of a roll out or payout. In order to do that i need to have reference of the parent with me.

My first thought was i will use Box smart pointer to store the resulting node on the heap and follow back by storing the parents reference in the node it self in an option.

If the node parent is None then its the root. But then i thought maybe i will use a Rc or RefCell smart pointers. All this confused me very much. Here what should i do i want to store parents reference in the childnode.

if you see the below expand fucntion. There the parent node produces childnodes. now after that the childnode should take reference to the parent node in their constructor or new fuction. since i used Rc or Refcell in the node i tried to clone the parent and store it in Rc<RefCell<>> but now if i clone then it is not the original parent anymore to back propagate the result. So after all this i was confused very much.

I did some smart pointer stuff in C++ before but not a lot. Any Rust expert can tell me How to exactly simulate this particular parent child stuff.

pub struct Node {
    board: Board,
    parent: Option<Rc<RefCell<Node>>>,
    children: Vec<Rc<RefCell<MCTSNode>>>,
}

So as you have seen this is the struct but I am not sure how to build a recursive tree here.
Later on I wrote a function called expand:

impl Node {
    fn expand(&mut self) {
        let possible_moves = self.board.getpossible_moves(self.player);
        for mv in possible_moves {
            let possible_end = self.board.getmoves(self.player, &mv);
            for j in possible_end {
                let mut next_state = self.board.clone();
                next_state.move_piece(&mv, &j);
                let child_node = Node::new(next_state, opp, Some(Rc::new(RefCell::new(self))));
                self.children.push(child_node);
            }
        }
    }
}

When I expand the tree adding children each children should store reference of the parent to send in the back propagated result back to the root.