Question

I am reading a book by Robert Sedwick Algorithms in C++. Following is example given in book regarding compound data structures.

Problem statement:
Given “d”, we want to know how many pairs from a set of N points in the unit square can be connected by a straight line of length less than “d”.

Following program using the logic divides the unit squre into a grid, and maintains a two dimensional array of linked lists, with one list corresponding to each grid square. The grid is chosen to be sufficiently fine that all points within distance “d” are either in the same grid square or an adjacent one.

My questions are

1. Why author is allocating G+2 in malloc2d(G+2, G+2) ?
2. In gridinsert function why author is performing following statement int X = x*G+1; int Y = y*G+1; ?
3. In for loop why we are having i intialiazed to X-1 and j initialized to Y-1?
4. Where in code we are maintaining points within distance d in same grid square or an adjacent one?

Request your help with simple example in understanding the following progam.

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
using namespace std;


float randFloat() {
    return 1.0*rand()/RAND_MAX;
}


struct myPoint {
    float x;
    float y;
};

float myDistance(myPoint a, myPoint b) {
    float dx = a.x - b.x, dy = a.y - b.y;
    return sqrt(dx*dx + dy*dy);
}

struct node {
    myPoint p; node *next; 
    node(myPoint pt, node* t) {
        p = pt; next = t;
    }
};

typedef node *link;
static link **grid = NULL; 

link **malloc2d(int r, int c) {
    link **t = new link*[r];
    for (int i = 0; i < r; i++) {
      t[i] = new link[c];
    }
    return t;
 }

static int G, cnt = 0; 
static float d;

void gridinsert(float x, float y) {
    int X = x*G+1;
    int Y = y*G+1;
    myPoint p;
    p.x = x; p.y = y;
    link s, t = new node(p, grid[X][Y]);
    for (int i = X-1; i <= X+1; i++)
      for (int j = Y-1; j <= Y+1; j++)
        for (s = grid[i][j]; s != 0; s = s->next)
           if (myDistance(s->p, t->p) < d) cnt++; 

    grid[X][Y] = t;
 }

int main(int argc, char *argv[]) { 

    int i; 
    int N = 10;
    d = 0.25;
    G = 1/d;

    grid = malloc2d(G+2, G+2);
    for (i = 0; i < G+2; i++)
        for (int j = 0; j < G+2; j++)
            grid[i][j] = 0;

    for (i = 0; i < N; i++)
        gridinsert(randFloat(), randFloat());

    cout << cnt << " pairs within " << d << endl;

   return 0;
 }

Answer 1

1. The idea is to check all adjacent cells of grid. But border cells don’t have adjacents. So to avoid tricky bounds checking we extend grid by 2 extra cells – before first cell and after last one. These cells are “dummy” and will never contain any points – they are required just to simplify algorithm and provide adjacents for border cells.

2. (X,Y) – coordinates (indexes) of cell in grid containing this point. According to p.1 we have to start placing points from cell (1,1), not (0,0). (0,0) and any other border point is dummy.

3. Because we check all adjacent cells of grid. Adjacent cells for (X,Y) are (X-1,Y-1), (X, Y-1), (X+1, Y-1) etc to (X+1,Y+1). That’s why we have loops from X-1 to X+1 and Y-1 to Y+1.

4. We don’t maintain them, just checking any input point vs existing set and increment counter cnt each time it matches the distance. Keeping the list of such pairs is not required by problem conditions. If you need to keep the list of points, you shall modify gridinsert() and e.g. place (s->p, t->p) to some container inside the loops instead of increment cnt++.