Алгоритм крускала, реализованный в кодеблоке, не запускается в студии

#include "stdafx.h"
#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <fstream>
#include <ctype.h>
#include <string.h>
 
using namespace std;
 
// Имя входного файла
char name_input[] = "input";
 
// Имя выходного файла
char name_output[] = "output";
 
// Число ребер графа
int cnt3;
 
// Число вершин графа
int n;
 
// Вершины графа.  Значение - "верхняя вершина"
int *nodes;
int last_n;
 
// Ребро со стоимостью
struct edge_t
{
    int n1, n2;  // Ребро
    int w;       // Стоимость
};
 
// Массив ребер со стоимостями
edge_t *edges;
 
const int SIZE_INPUT = 1024;
 
// Сортировка ребер по возрастанию
// расстояний методом пузырька
void bubbleSort(void)
{
    int    i, j;
    edge_t x;
 
    for (i = 0; i < cnt3; ++i)
    {
        for (j = cnt3 - 1; j > i; --j)
        {
            if (edges[j - 1].w > edges[j].w)
            {
                x = edges[j - 1];
                edges[j - 1] = edges[j];
                edges[j] = x;
            }
        }
    }
}
 
// Ввод конфигурации графа
void config(void)
{
    // Матрица расстояний графа
    int **mat;
 
    int    i, j, k, v;
    char   txt[SIZE_INPUT + 1], *s, c;
    FILE   *f;
 
    // Открытие входного файла, ошибки не обрабатываем
    f = fopen(name_input, "r");
 
    // Ввод числа вершин
    fgets(txt, SIZE_INPUT, f);
    n = atoi(txt);
 
    // Формируем динамическую матрицу расстояний графа
    mat = new int *[n];
    for (i = 0; i < n; ++i)
        mat[i] = new int[n];
 
    // Вводим значения матрицы расстояний графа
    cnt3 = 0;
    for (i = 0; i < n; ++i)
    {
        // Очередная строка матрицы
        fgets(s = txt, SIZE_INPUT, f);
 
        // Получение значений очередной строки
        for (j = 0; j < n; ++j)
        {
            // Игнорируем пустые символы перед очередным значением
            while ((c = *s) == ' ' || c == '\t' || c == '\n')
                ++s;
 
            // Ожидается цифра или символ '~'
            if (c == '~')
            {
                ++s;
                mat[i][j] = 0;
                continue;
            }
 
            // Собираем очередное число
            for (v = 0; isdigit(*s); v = v * 10 + *s++ - '0')
                ;
            mat[i][j] = v;
 
            // Подсчитываем ребра
            ++cnt3;
        }
    }
 
    fclose(f);
 
    // Получаем реальное число ребер (во время ввода матрицы расстояний ребра учитывались дважды)
    cnt3 >>= 1;
 
    // Создаем динамический массив ребер с расстояниями
    edges = new edge_t[cnt3];
 
    // Заполняем массив ребер
    for (i = k = 0; i < n; ++i)
    {
        for (j = i + 1; j < n; ++j)
        {
            if (mat[i][j])
            {
                edges[k].n1 = i;
                edges[k].n2 = j;
                edges[k].w = mat[i][j];
                ++k;
            }
        }
    }
 
    // Удаляем матрицу расстояний
    for (i = 0; i < n; ++i)
        delete mat[i];
    delete mat;
 
    // Сортируем список ребер по возрастанию расстояний
    bubbleSort();
}
 
// Функция получает цвет вершины k-й по порядку.
// если nodes[k] < 0, то вершина k имеет цвет nodes[k]
// если nodes[k] >= 0, то вершина k имеет цвет такой же,
// как и вершина с номером nodes[k]
int getColor(int k)
{
    int c;
 
    if (nodes[k] < 0)
        return nodes[last_n = k];
    c = getColor(nodes[k]);
    nodes[k] = last_n;
    return c;
}
 
// Алгоритм Краскала
void Kruskal(void)
{
    int  c2, i, j, summa, cnt2;
    FILE *f;
 
    // Номера ребер минимального остовного дерева
    int *mst;
 
    // Первоначальная раскраска вершин
    nodes = new int[n];
    for (i = 0; i < n; ++i)
        nodes[i] = -1 - i;
 
    // Массив номеров ребер остовного дерева
    mst = new int[cnt3];
 
    // Пока не прошли все ребра
    for (i = cnt2 = summa = 0; i < cnt3; ++i)
    {
        c2 = getColor(edges[i].n2);
        if (getColor(edges[i].n1) != c2)
        {
            // Если ребро соединяет вершины различных цветов,
            // добавляем его и перекрашиваем вершины
            nodes[last_n] = edges[i].n2;
            mst[cnt2++] = i;
            summa += edges[i].w;
        }
    }
 
    // Файл результата
    f = fopen(name_output, "w");
 
    // Стоимость
    fprintf(f, "%d\n", summa);
 
    // Ребра остовного дерева
    for (i = 0; i < cnt2; ++i)
    {
        j = mst[i];
        fprintf(f, "%d-%d%c", edges[j].n1 + 1, edges[j].n2 + 1, i + 1 == cnt2 ? '\n' : ' ');
    }
    fclose(f);
 
    // Освобождаем занятую память
    delete mst;
    delete nodes;
    delete edges;
}
 
int main()
{
    // Ввод описания графа
    config();
 
    // Построение минимального остовного дерева
    Kruskal();
 
    return 0;
}