I$\text{'}$m writing a call function for a C$++$ program, please read the requirements and help me complete the following call function, thanks:

TODO: Complete the missing blocks$/$lines in this recursive function find$\_$path$()$ that takes the following parameters:

stage: a $2$D array of C strings that represents the towers and floors. Each tower has at most $4$ floors, and each floor has a encounter in C string.

num$\_$tower: the number of towers.

current$\_$tower: the current tower number $($counts from $0).$

num$\_$floor: the number of floors in each tower.

explored$\_$floor$\_$count: the number of floors that have been explored in the current tower.

explored$\_$floor: an array of integers that contains the floor numbers of the explored floors in the current tower.

strength: the current strength.

floor$\_$path: an array of integers that you will write the best path for this tower given the floor you explored. Use it as pass$-$by$-$reference to return the path.

stage$\_$path: a $2$D array of integers that you will write the best path for this stage. Use it as pass$-$by$-$reference to return the best path. You may want to write it every time you finish a tower.

The function should return the highest strength that you can achieve in this stage, i$.$e$.,$ the strength after taking the best path.

int find$\_$path$($int tower$[][$MAX$\_$NUM$\_$FLOOR$],$ int floor$\_$explored$[],$ int floor$\_$path$[],$ int best$\_$floor$\_$path$[],$ int tower$\_$index$)\{$

if $($tower$\_$index $>=$ MAX$\_$NUM$\_$TOWER$)\{$

return $0$; $//$ No more towers to explore

$\}$

int highest$\_$strength $=0$;

for $($int i $=0$; i $<$ MAX$\_$NUM$\_$FLOOR; $++$i$)\{$

int recursion$\_$floor$\_$path$[$MAX$\_$NUM$\_$FLOOR$]$;

copy$\_$floor$($recursion$\_$floor$\_$path, floor$\_$path$)$;

$//$ Calculate strength for the current floor and call recursively for the next tower

int current$\_$strength $=$ tower$[$tower$\_$index$][$i$]$;

int recursion$\_$result $=$ current$\_$strength $+$ find$\_$path$($tower$,$ floor$\_$explored, recursion$\_$floor$\_$path, best$\_$floor$\_$path, tower$\_$index $+1)$;

if $($recursion$\_$result $>$ highest$\_$strength$)\{$

highest$\_$strength $=$ recursion$\_$result;

copy$\_$floor$($best$\_$floor$\_$path, recursion$\_$floor$\_$path$)$;

best$\_$floor$\_$path$[$tower$\_$index$]=$ i; $//$ Track the best floor for each tower

$\}$

$\}$

return highest$\_$strength;

$\}$