Recursion differences in backtracking with a global value? - c

Question

Taking this as an example:
bool SolveSudoku(int grid[N][N])
{
int row, col;
// If there is no unassigned location, we are done
if (!FindUnassignedLocation(grid, row, col))
return true; // success!
// consider digits 1 to 9
for (int num = 1; num <= 9; num++)
{
// if looks promising
if (isSafe(grid, row, col, num))
{
// make tentative assignment
grid[row][col] = num;
// return, if success, yay!
if (SolveSudoku(grid))
return true;
// failure, unmake & try again
grid[row][col] = UNASSIGNED;
}
}
return false; // this triggers backtracking
}
The grid is always passed as a parameter to the recursive call, so there is a new copy of the grid in each iteration.
I can't seem to conceptualize if there is any difference on working with a global grid, using the same logic.
After a failure condition, the variable is set to "unmake & try again"- shouldn't this take care of any "undoing" in backtracking?
What difference would there be in this recursive backtracking if the grid was a global, why send and extra copy each time?

Answer 1

The grid is always passed as a parameter to the recursive call, so
there is a new copy of the grid in each iteration.
No, there is a new copy of the reference (pointer) to the grid in each iteration. The actual work is done on the same grid over and over.
Have a look at this code snap for example:
#include <stdlib.h>
#include <stdio.h>
void foo(int arr[], int n) {
arr[0] = 1;
}
int main() {
int myArray[5] = {0,0,0,0,0};
foo(myArray,5);
printf("%d",myArray[0]);
return 0;
}
Note that no copy was made, and a change to arr in foo() was reflected to myArray.
Once this is clear, I believe it automatically answers the rest of your questions (It is basically the same as working with global, but global variables are usually bad practice, sending the reference to the array is a better practice).

Answer 2

In C/C++ arrays are passed as pointers to the beginning of array. Take a look at this example:
#include <iostream>
static const int N = 10;
void test(int a[N][N])
{
std::cout << a << std::endl;
}
int main(int argc, char **argv)
{
int a[N][N];
std::cout << a << std::endl;
test(a);
return 0;
}
If you run it you will get the same value printed on stdout:
$ ./test
0x7fff0c669930
0x7fff0c669930
That's the value of a pointer to the beginning of the array, so the same pointer is used in main() and test().
This means you would not get any performance gain by letting the grid be a global variable. Instead you would loose modularity by introducing a global.