AD        
AE
CE      
CF
ED
GF
BG
HB
GH
**

#include <stdio.h>
#include <stdlib.h>

#define START_POINT 'A'
#define END_POINT 'B'

#define DATA_FILE "bomb.in"

void bombRoad(int *roads, int road, int *result, int size)
{
    // remove a road from roads
    int i;

    for (i=0; i < road; i++)
        *(result+i) = *(roads+i);
    
    for (i; *(roads+i+1); i++)
        *(result+i) = *(roads+i+1);
    
    for (i; i<size; i++)   
        *(result+i) = 0;
}

void checkRoad(int *roads, char at, int size, int *continuous)
{
    // recursively check to see if the road we destroyed made it discontinuous
    printf("."); // to see the cycles
    
    /* it's not returning int, because it needs to recurse an unknown
    number of times for each depth of recursion.
     
    so we don't return the result of recursion, we just keep spawning 
    child recurses instead. */
    
    /* roads (what used to be result in the parent function), is never
    modified. It's the newly allocated memory, result that is modified.
    
    so we don't need to worry about giving a copy of result to
    the child recurse, since it's not going to be fiddled with */
    
    int road, point, temp;
    // need to start a new var for the next recurse
    int *result;
    result = malloc(size*sizeof(int)); // allocate to _size_
        
    for (road=0; *(roads+road); road++)
    {
        for (point=0; point<2; point++) // check both points for _at_
        {
            temp = point ? *(roads+road)%256 : *(roads+road)/256; // extract the appropriate component, according to the iterator of the loop
                
            if (temp == at)
            {
                if (temp == START_POINT)
                {
                    *continuous = 1; // there was a path to the end
                    free(result);
                    return;
                }
                else
                {
                    // bomb the road
                    bombRoad(roads, road, result, size);
                    
                    // check to see if the road still works
                    checkRoad(result, point ? *(roads+road)/256 : *(roads+road)%256, size, continuous); // take the compliment of _at_
                    
                    if (*continuous) // if the apex of recursion found continuity
                      break; // we can now exit, don't bother starting any more child functions
                }
            }
        }
        if (*continuous)
          break; // exit the nested loop to follow the intent of prior-mentioned break statement
    }
    
    free(result); // out of roads to travel down, we can now free up memory
}

void bomb(int *roads, int size)
{
    int *result;
    int road, continuous;
    
    for (road = 0; *(roads+road); road++)
    {
        printf("%c%c ", *(roads+road)/256, *(roads+road)%256);
        
        result = malloc(size*sizeof(int)); // allocate to _size_
        
        // bomb the road 
        bombRoad(roads, road, result, size);
        
        // check to see if the road still works
        continuous = 0;
        checkRoad(result, END_POINT, size, &continuous);
        if (continuous)
            printf(" No\n");
        else
            printf(" Will break continuity!\n");
            
        free(result); // it is done being used, so free it
        // don't free roads, it's being freed in the parent function
    }   
    printf("\n");
}

int main()
{
    printf(""); // I sometimes need to clear the output stream
    
    char buf[2]; // one for one character, one for the null terminator fgets adds
    int size;
    int *roads;
    FILE *stream;
    
    roads = malloc(sizeof(int));
    stream = fopen(DATA_FILE, "r");
    
    size = 0;
    while (1) 
    {
        fgets(buf,sizeof(buf),stream);
        *(roads+size) = buf[0]*256;     // store in hex to make memory managing more simple

        fgets(buf,sizeof(buf),stream);  // ...manage only one chunk, instead of a struct, or array
        *(roads+size) += buf[0];
        
        if (*(roads+size) == 10794) // two asterisks, 42*256 + 42
            break;
        else
        {
            while (buf[0] != '\n') fgets(buf,sizeof(buf),stream); // find the next line

            size ++;
            roads = realloc(roads, (size+1)*sizeof(int)); // reallocate one ahead to avoid over-writing previously declared data
        }
    }
    fclose(stream);
    *(roads+size) = 0; // over-write the two asterisks with a 0
    
    bomb(roads, size);
    free(roads);

    system("PAUSE");
    return 0;
}

        fgets(buf,sizeof(buf),stream);   // Why not read the line at once? Besides that, if you are reading one character at a time I would personally use getchar.
        *(roads+size) = buf[0]*256;     // A structure would be easier.

        fgets(buf,sizeof(buf),stream);  // 
        *(roads+size) += buf[0]; //
        
        if (*(roads+size) == 10794) // two asterisks, 42*256 + 42 <- An unreliable comparison, buf[0] could always contain some weird values which happen to equal your comparison value.
            break;
        else
        {
            while (buf[0] != '\n')
              fgets(buf,sizeof(buf),stream); // find the next line

            size ++;
            roads = realloc(roads, (size+1)*sizeof(int)); // OK, realloc thing I mentioned earlier
        }

        // You never check for the end of file - what if the file doesn't end with two asterixes?

    define struct {
        char a,
        char b
    } vector;

    char buf[16];
    vector *roads = malloc(16 * sizeof(vector);
    int size = 0;

    while (!feof(stream)) {
        fgets(buf, sizeof(buf), stream); // Get a whole line from the file

        if(strncmp(buf, "**", 2) == 0)
            break;

        roads[size].a = buf[0];
        roads[size].b = buf[1];
        
        size++;
        if((size & 0xF) == 0) {
            roads = realloc(roads, (size + 0xF) * sizeof(vector));
        }
    }

temp = point ? *(roads+road)%256 : *(roads+road)/256; // extract the appropriate component, according to the iterator of the loop

temp = point ? roads[road] & 0xFF : roads[road] >> 8;

temp = point ? roads[road].a : roads[road].b;