Finding the closest pair of points

Write code in C/C++ to generate a set of random points in 2D and find the closest pair of points. You'll implement two approaches:

1. First, the naive, quadratic algorithm discussed in class.
2. Second, a gridded approach to bucket the points into grid cells and then use the grid to help speed the search of closest pair (see last problem in closest pair class worksheet).

Perform an experimental analysis of both methods to see how their performance compares in practice. Time both methods separately and run on increasingly large values of the number of points, until the difference in running times is signifiacnt. Create a table of the running times.

This is a warm-up assignment to get everyone comfortable with C/C++ and an opportunity to learn what quadratic complexity means in practice.

Comments

• The points have real coordinates, and are generated randomly. For consistency, assume the range of the coordinates is [0; 1,000,000].

• The number of points, n, should be read as a command line argument. For example,

  [ltoma@lobster] ./closest 100
  

  means that it will generate and compute on 100 points.

• Implement the functions that compute the closest pair as two separate functions, one corresponding to the naive algorithm and one to the improved, gridded algorithm. For example,

  //compute and print the closest pair in P using the naive algorithm 
  void closest_naive( array of points P)
  
  
  //compute and print the closest pair in P using a gridded approach
  void closest_grid( array of points P)
  
  

• Make each function print the points that are closest so that it's easy to check that the two functions actually find the same pair.

• For the gridded approach, use a grid of k-by-k cells. You'll set the value of k in order to make the algorithm efficient. Because the points are uniformly distributed, you can estimate for e.g. how many points do you expect to fall in each cell. Think of how you would go about finding the closest pair, and how the number of points per cell may influence it. Using this insight, what value of k do you pick?

  The details of this approach are intentionally left open-ended so that you can develop and implement your own ideas.

Arrays and vectors in c++

Arrays of integers, C style

  int *a; 
  
  /*  DON'T DO THIS: 
  
      int a[n]; 
  
      It's wrong and you're sure to get segfaults for larger values of
      n. YOU NEED TO ALLOCATE  dynamically using malloc() because you
      don't know n at compile time.
  */ 
  
  //allocate the space  dynamically
  a =(int*)malloc(n * sizeof(int)); 
  
  //put some data in it 
  for (i=0; i < n; i++) 
    a[i] = 1; 

  //compute something 
  sum=0; 
  for (i=0;i< n;i++)
    sum += a[i]; 

  //free the space 
  free(a); 

Array of integers, C++ style

 //an array of n ints, C++ style 
  int *b; 
  
  /*  DON'T DO THIS: 
      
      int b[n]; 
      
      It's wrong and you're sure to get segfaults for larger values of
      n. YOU NEED TO ALLOCATE  dynamically using new because you
      don't know n at compile time.
  */ 
    

  //allocate the space  dynamically
  b = new int[n]; 

  //put some data in it 
  for (i=0; i < n; i++) 
    b[i] = 1; 

  //compute something 
  sum=0; 
  for (i=0;i < n;i++)
    sum += b[i]; 

  //free the space 
  delete [] b; 

Array of vector< int >

 //an array of Vectors, C++ style 
  vector< int > *d; 

 /*  DON'T DO THIS: 
      
      vector< int > d[n]; 
      
      It's wrong and you're sure to get segfaults for larger values of
      n. YOU NEED TO ALLOCATE  dynamically using new because you
      don't know n at compile time.
  */ 

  //allocate the space  dynamically
  d = new vector< int > [n]; 
  //NOTE: we assume that c++ calls the constructor to create a new Vector at each d[i]
  
  //put some data in it 
  for (i=0; i< n; i++) 
    //d[i] is a Vector, so we push 1 into it 
    d[i].push_back(1); 

  //compute something 
  sum=0; 
  for (i=0;i< n;i++)
    sum += d[i][0]; 

  //free the space 
  delete [] d; 

  printf("test4: sum=%f\n", sum); 

2D-array of vector< point >

//a structure for a point in 2D
typedef struct _point2d {
  double x, y; 
} point2d; 


//a 2D array of Vectors of points 
  vector< point2d > **grid; 
  
  /*  DON'T DO THIS: 

     vector< point2d > grid [n][n] 

     It's wrong and you're sure to get segfaults for larger values of
     n. YOU NEED TO ALLOCATE  dynamically using new because you
     don't know n at compile time.
  */ 

  //allocate first an array of vector*
  grid = new vector< point2d >* [n]; 
  for (i=0; i < n;i++) {
    //grid[i] is a vector*, that is, an array (of vectors); we allocate it 
    grid[i] = new vector< point2d > [n]; 
  }

  //put some data in it 
  for (i=0; i < n; i++) {
    for (j=0; j < n; j++) {
      //grid[i][j] is a Vector, so we push 1 into it 
      assert(grid[i][j].size()==0); 
      point2d p = {1.0, 1.0};
      grid[i][j].push_back(p); 
      assert(grid[i][j].size()==1); 
    }
  }
 
  //compute something 
  sum=0; 
  for (i=0; i < n; i++) {
    for (j=0; j < n; j++) {
      // grid[i] is a vector;grid[i][j][0] is the first point in that vector
      sum += grid[i][j][0].x;
    } 
  }
  //free the space 
  delete [] e;  

What and how to turn in

In addition to GitHub, please bring a hard copy of your code and of the README to class.

Enjoy!