#include "stdafx.h"
#include <iostream>
using namespace std;
#define maxchild 7
#define maxsize 8

class Node {
    int count;
    int child[maxchild];
    bool visited;
    int parent;
    int duration;
    Node();
    ~Node();
};

Node::Node() {
    count = 0;
    visited = 0;
    parent = 0;
    duration = 0;
}

Node :: ~Node() {
}

void read(Node * G[], FILE * fp , char s [20]) {
    fp = fopen("s", "r");
    int index;
    for (int i = 0; i < maxsize; i++) {
        G[i] = new Node;
    }
    for (int i = 0; i < maxsize; i++) {
        fscanf(fp, "%d" , &index);
        fscanf(fp, "%d", &G[index]->count);
        for (int i = 0; i < G[index]->count; i++) {
            fscanf(fp, "%d", &G[index]->child[i]);
        }
        fscanf(fp, "%d", &G[index]->duration);
        fscanf(fp, "%d", &G[index]->visited);
    }
}

void initialization(Node * G[], int start, int size) {

    for (int i = 0; i < size; i++) {
        G[i]->duration = 0;
        G[i]->parent = -1;
    }
    G[start]-> duration = 4;
    longestpath(G, start, size);
}



void longestpath(Node * G[], int start, int size) {
    bool found;
    int w, sum, ed , min , index;
    G[start]->visited = true;
    for (int i = 0; i < G[start]->count; i++) {
        w = G[start]->child[i];
        ed = G[start]->duration;
        sum = ed + G[start]->duration;
        if (sum < G[w]->duration) {
            G[w]->duration = sum;
            G[w]->parent = start;
        }
    }

    found = false;
    min = 100000;
    for (int i = 0; i < size; i++) {
        if (G[i]->visited = false) {
            if (G[i]->duration < min) {
                found = true;
                min = G[i]->duration;
                index = i;
            }
        }
    }
    if (found) {
        longestpath(G, index, size);
}
}

void print(Node * G[], int start, int end) {
    if (G[end]->parent == start)
        cout << start << "=>" << endl;
    else {
        print(G, start, G[end] -> parent);
        cout << "=>" << endl;
    }
}

int main()
{
}