Access Violation at address in module read of address

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <StrUtils.hpp>
#include <stdio.h>
#include "Main.h"
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TMainForm *MainForm;
TForm1 *Form1;
 
int n = 4;          // начальное количество вершин
 
int MAX = 999999;   // это должно быть больше чем
                    // значение любого ребра в граафе
 
 
// проверка на вхождение числа j в одномерный массив a
bool in_arr(int j, int *a) {
    bool r = false;
    for (int i = 0; i < n - 1; i++) {
        if (a[i] == j) {
            r = true;
            break;
        }
    }
    return r;
}
 
// функция для вывода маршрутов в текстовое поле основываясь на массивах D и P
 
void swDxtra(int **C, int *P, int *D, int a) {
    int prom;
    AnsiString str;
    for (int i = 0; i < n; i++) {
        if (i != a && C[P[i]][i] != NULL) {
            str = AnsiString(i + 1);
            prom = P[i];
            do {
                if (str != AnsiString(i + 1)) prom = P[prom];
                str =str +"<-" + AnsiString(prom + 1);
            } while (prom != a);
            MainForm->Memo1->Lines->Add(str + " = " + AnsiString(D[i]));
        }
    }
}
 
// функция расчета кратчайших путей с помощью алгоритма Дейкстры
 
void Dijkstra(int **C, int a) {
    int *S = new int[n - 1],        // массив пройденых вершин
        *D = new int[n],            // конечная стоимость маршрута
        *P = new int[n],            // промежуточные маршруты
        w,
        min;
    for (int k = 0; k < n - 1; k++) {
        S[k] = -1;                  // инициализируем массив
    }
    S[0] = a;                       // исходная вершина будет первой пройденой
    for (int i = 0; i < n; i++) {
        D[i] = (C[a][i] == NULL) ? MAX : C[a][i];    // заполняем конечные стоимости
        P[i] = a;                                    // исходя из матрицы стоимости
    }
    for (int i = 1; i < n - 1; i++) {                // считаем...
        min = MAX;
        for (int k = 0; k < n; k++) {
            if (D[k] < min && !in_arr(k, S) && k != a) {
                w = k;
                min = D[k];
            }
        }
        if (min == MAX) break;
        S[i] = w;
        for (int j = 0; j < n; j++) {
            if (!in_arr(j, S) && C[w][j] != NULL && (D[w] + C[w][j]) <= D[j]) {
                P[j] = w;
                D[j] = D[w] + C[w][j];
            }
        }
    }
    swDxtra(C, P, D, a);            // выводим результат
}
 
//---------------------------------------------------------------------------
__fastcall TMainForm::TMainForm(TComponent* Owner)
    : TForm(Owner)
{
}
//----------------------------------------------------------------------------
 
void __fastcall TMainForm::Edit1Change(TObject *Sender)
{
if (Edit1->Text != "") {
 
        // узнаем количество вершин
 
        n = StrToInt(Edit1->Text);
 
        // сделаем стринггрид
 
        StringGrid1->ColCount = n + 1;
        StringGrid1->RowCount = n + 1;
        StringGrid1->Width = (n + 1) * 65 + 3;
        StringGrid1->Height = (n + 1) * 25;
        for (int i = 0; i < n; i++) {
            StringGrid1->Cells[0][i + 1] = i + 1;
            StringGrid1->Cells[i + 1][0] = i + 1;
        }
    }                
}
//---------------------------------------------------------------------------
 
void __fastcall TMainForm::Button1Click(TObject *Sender)
{
Label2->Caption="Ошибка, начальная вершина\nбольше конечной";
Memo1->Clear();
        if (Edit3->Text=="")
                Edit3->Text=Edit1->Text;
        n=StrToInt(Edit3->Text);
        if (StrToInt(Edit2->Text)>StrToInt(Edit3->Text))
                Label2->Visible=true;
        else
        {
         Label2->Visible=false;
    // создадим матрицу стоимости
 
    int **C = new int*[n];
    for (int i = 0; i < n; i++) {
        C[i] = new int[n];
    }
 
    // заполним матрицу стоимостей данными из стринггрида
 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (TryStrToInt(StringGrid1->Cells[j + 1][i + 1], C[i][j])) {
                C[i][j] = StrToInt(StringGrid1->Cells[j + 1][i + 1]);
            } else {
                C[i][j] = NULL;
            }
        }
    }
 
    // запускаем алгоритм дейкстры, например, для нулевой вершины;
    // передаем в функцию матрицу стоимостей и индекс вершины-источника
    // из которого будем искать маршруты ко всем остальным вершинам
        int p=StrToInt(Edit2->Text)-1;
    Dijkstra(C, p);
}        
}
//---------------------------------------------------------------------------
 
void __fastcall TMainForm::N2Click(TObject *Sender)
{
// заполняем пример из файла
int n=13,i,j,k;
        Edit2->Text="1";
        Edit3->Text="13";
        Edit1->Text=IntToStr(n);
            StringGrid1->ColCount = n + 1;
        StringGrid1->RowCount = n + 1;
        StringGrid1->Width = (n + 1) * 65 + 3;
        StringGrid1->Height = (n + 1) * 25;
        FILE *f=fopen("exampler.pn","rb");
 
        for (i=1; i<=13; i++)
          for (j=1; j<=13; j++)
          {
             fread(&k,4,1,f);
             StringGrid1->Cells[j][i]=k;
          }
        fclose(f);
}
//---------------------------------------------------------------------------
 
void __fastcall TMainForm::N3Click(TObject *Sender)
{
        Memo1->Clear();
        Edit1->Text="1";
        Edit2->Text="1";
        Edit3->Text="1";
         for (int i=1; i<=13; i++)
          for (int j=1; j<=13; j++)
            StringGrid1->Cells[i][j]="";
}
//---------------------------------------------------------------------------
 
void __fastcall TMainForm::N6Click(TObject *Sender)
{
        Form1->Show();        
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::FormCreate(TObject *Sender)
{
 
}
//---------------------------------------------------------------------------

FILE *f=fopen("exampler.pn","rb");

void __fastcall TMAIN::FormCreate(TObject *Sender)
{
INFO->Show();
}