Dijkstra's Algorithm C++ This is a basic implementation of Dijkstra's Shortest Path Algorithm for Graphs. I am looking for any kind of improvement.

/* 
    Author: Stevan Milic
    Date: 10.05.2018.
    Dijkstra's Shortest Path Algorithm
*/
#include &lt;stdio.h&gt; 
#include &lt;limits.h&gt; 
#include &lt;iostream&gt;

#define N 9 // Number of Nodes in the graph

int minDistance(int distance[], bool visitedSet[])
{
    int min = INT_MAX, min_index;

    for (int v = 0; v &lt; N; v++)
        if (visitedSet[v] == false &amp;&amp; distance[v] &lt;= min)
            min = distance[v], min_index = v;
    return min_index;
}

void displayPath(int parent[], int s)
{
    if (parent[s] == -1)
        return;
    displayPath(parent, parent[s]);

    printf("-&gt; %d ", s);
}

void display(int distance[], int n, int parent[])
{
    int start = 0;
    printf("Node\t     Distance\t         Path");
    for (int i = 1; i &lt; N; i++)
    {
        printf("\n%d -&gt; %d\t\t%d\t\t%d ", start, i, distance[i], start);
        displayPath(parent, i);
    }
}

void dijkstra(int graph[N][N], int start)
{
    int distance[N];

    bool visitedSet[N];

    int parent[N]; // For storing the shortest path tree

    for (int i = 0; i &lt; N; i++) // This will make all distances as infinite and all nodes as unvisited
    {
        parent[0] = -1;
        distance[i] = INT_MAX;
        visitedSet[i] = false;
    }
    distance[start] = 0;
    for (int count = 0; count &lt; N - 1; count++) // Finding the shortest path for all nodes
    {
        int u = minDistance(distance, visitedSet);

        visitedSet[u] = true;

        for (int n = 0; n &lt; N; n++)
            if (!visitedSet[n] &amp;&amp; graph[u][n] &amp;&amp; distance[u] + graph[u][n] &lt; distance[n])
            {
                parent[n] = u;
                distance[n] = distance[u] + graph[u][n];
            }
    }
    display(distance, N, parent);
}

int main()
{
    printf("***** Dijkstra's Shortest Path Algorithm ***** \n\n");
    int graph[N][N] = { {0, 4, 0, 0, 0, 0, 0, 8, 0 },
                        {4, 0, 8, 0, 0, 0, 0, 11, 0},
                        {0, 8, 0, 7, 0, 4, 0, 0, 2 },
                        {0, 0, 7, 0, 9, 14, 0, 0, 0},
                        {0, 0, 0, 9, 0, 10, 0, 0, 0},
                        {0, 0, 4, 0, 10, 0, 2, 0, 0},
                        {0, 0, 0, 14, 0, 2, 0, 1, 6},
                        {8, 11, 0, 0, 0, 0, 1, 0, 7},
                        {0, 0, 2, 0, 0, 0, 6, 7, 0 } 
                      };
    dijkstra(graph, 0);
    printf("\n\n");
    system("pause");
    return 0;
}
The &lt;iostream&gt; header is not used.

min_distance can theoretically return an uninitialized value if all elements of visited_set are nonzero.  This shouldn't happen here, but initializing min_index = 0 would remove a potential problem and compiler warning.

display assumes that node 0 is the start node, but that value is passed in to dijkstra.  It should be passed in as a parameter.

In dijkstra, the graph parameter could be const int graph[N][N], which would then allow the graph variable in main to also be const.  The parent[0] = -1 assignment seems to be a typo.  It should be parent[i] = -1; to initialize all elements of parent.  The for (int n = 0; n &lt; N; n++) loop should have curly brackets around its body.  While not currently necessary, having them in can avoid future problems when the code is modified and makes it clearer what is in the loop body rather than looking like a line with bad indentation.