Алгоритм Флойда, матрица предков

#include "stdafx.h"
 
#define INF 10000
 
using namespace std;
 
vector<string> splitStringByChar(string str, char delimiter, int* arrPtr) {
    vector<string> internal;
    stringstream ss(str);
    string tok;
 
    for (int i = 0; getline(ss, tok, delimiter); ++i) {
        internal.push_back(tok);
        if (atoi(tok.c_str()) != -1) {
            arrPtr[i] = atoi(tok.c_str());
        }
        else {
            arrPtr[i] = INF;
        }
    }
    return internal;
}
 
int countLinesInFile(string fileName) {
    int count = 0;
    ifstream inp(fileName);
    if (!inp) {
        cout << "Error!" << endl;
    }
    else
    {
        while (inp.ignore(numeric_limits<streamsize>::max(), '\n'))
        {
            if (!inp.eof())
                count++;
        }
    }
    return count + 1;
}
 
void show2dArray(int** dataArray, int size) {
    for (int i = 0; i < size; ++i) {
        for (int n = 0; n < size; ++n) {
            if (n == 0) {
                if (dataArray[i][n] != INF) {
                    cout << dataArray[i][n];
                }
                else {
                    cout << 0;
                }
            }
            else {
                if (dataArray[i][n] != INF) {
                    cout << '\t' << dataArray[i][n];
                }
                else {
                    cout << '\t' << 0;
                }
                
            }
        }
        cout << endl;
    }
    cout << endl;
}
 
void floyd(int** dataArray, int** parentArray, int size) {
    for (int k = 0; k < size; ++k) {
        show2dArray(dataArray, size);
        for (int i = 0; i < size; ++i) {
            for (int j = 0; j < size; ++j) {
                if (dataArray[i][k] + dataArray[k][j] < dataArray[i][j]) {
                    dataArray[i][j] = dataArray[i][k] + dataArray[k][j];
                    
                    parentArray[i][j] = k+1;
                }
//              dataArray[i][j] = min(dataArray[i][j], dataArray[i][k] + dataArray[k][j]);
            }
        }
    }
}
 
int** create2DArray(int arrSize) {
    int **Array2d = (int **)malloc(arrSize * sizeof(int *));
    for (int i = 0; i < arrSize; ++i) {
        Array2d[i] = (int *)malloc(arrSize * sizeof(int));
    } 
 
    return Array2d;
}
 
void fillArrayFromFile(int** dataArray, int arrSize, string fileName) {
    string dataString;
    fstream dataStream(fileName);
    if (dataStream.is_open()) {
        for (int i = 0; i < arrSize; ++i) {
            getline(dataStream, dataString);
            splitStringByChar(dataString, ' ', dataArray[i]);
        }
        dataStream.close();
    }
}
 
void trace(int** parentArray, int start, int end){
    cout << start << " -> ";
 
    if (parentArray[start-1][end-1] == end) {
        cout << end << endl;
        return;
    }
    else {
        trace(parentArray, parentArray[start-1][end-1], end);
    }
}
 
void fullTrace(int** parentArray, int arrSize) {
    cout << "Все возможные пути графа:" << endl;
    for (int i = 0; i < arrSize; ++i) {
        for (int j = 0; j < arrSize; ++j) {
            if (i != j) {
                trace(parentArray, i + 1, j + 1);
            }
        }
    }
}
 
void fillParentArray(int** parentArray, int arrSize) {
    for (int i = 0; i < arrSize; ++i) {
        for (int j = 0; j < arrSize; ++j) {
            parentArray[j][i] = i + 1;
        }
    }
}
 
int main() {
    setlocale(LC_ALL, "Russian");
 
    string fileName = "data.txt";
    int arrSize = countLinesInFile(fileName);
 
    int **startArray = create2DArray(arrSize);
    int **dataArray = create2DArray(arrSize);
    int **parentArray = create2DArray(arrSize);
 
    fillParentArray(parentArray, arrSize);
    fillArrayFromFile(startArray, arrSize, fileName);
    fillArrayFromFile(dataArray, arrSize, fileName);
 
    cout << "Шаги алгоритма:" << endl;
    floyd(dataArray, parentArray, arrSize);
 
    cout << "Конечная матрица смежности (D" << arrSize << "):" << endl;
    show2dArray(dataArray, arrSize);
 
    cout << "Матрица предков (S" << arrSize << "):" << endl;
    show2dArray(parentArray, arrSize);
 
//  fullTrace(parentArray, arrSize);
 
    system("pause");
    return 0;
}

#pragma once
 
#include "targetver.h"
 
#include <fstream>
#include <string>
#include <iostream>
#include <vector>
#include <sstream>
#include <algorithm>