#include<iostream>
using namespace std;
const int maxSize = 99999;
int v[maxSize];

int main()
{
    return 0;
}


/*
圖的儲存結構的定義
float MGraph[5][5];
for (int i = 0; i < 5;++i)
    for (int j = 0; j < 5; ++j)
        MGraph[i][j] = MAX;*/

//圖的鏈式儲存結構的結構體定義
typedef struct ArcNode
{
    int adjV;    //頂點
    struct ArcNode* next;
}ArcNode;    //分支結構體
typedef struct
{
    int data;
    int count;
    ArcNode* first;
}VNode;        //頂點
typedef struct
{
    VNode adjList[maxSize];
    int n, e;
}AGraph;    //圖,兩個變量表示邊和頂點的個數


//圖的深度優先遍歷演算法
void Visit(int a)
{
    cout << endl;
}
void DFS(int v, AGraph *G)
{
    //圖的標誌陣列,初值為全0,當被訪問過一次就置為1
    int visit[maxSize];
    visit[v] = 1;
    Visit(v);
    //取與所選頂點相關的第一條邊
    ArcNode *q = G->adjList[v].first;
    while (q != NULL)
    {
        //判斷q所指的邊的另一邊頂點是否被訪問過
        if (visit[q->adjV] == 0)
            DFS(q->adjV, G);
        q = q->next;
    }    
}

//圖的廣度優先遍歷演算法
void BFS(AGraph *G, int v, int visit[maxSize])
{
    ArcNode *p;
    int que[maxSize], front = 0, rear = 0;
    int j;
    visit[v] = 1;
    Visit(v);
    rear = (rear + 1) % maxSize;
    //以頂點的陣列下標代替頂點資訊,下標入隊,則相當於對應的頂點入隊
    que[rear] = v;
    //隊不空,則一直進行迴圈
    while (front != rear)
    {
        front = (front + 1) % maxSize;
        j = que[front];
        //p定義為a[v]所相鄰的第一條邊
        p = G->adjList[j].first;
        while (p!=NULL)
        {
            //檢測邊另一端的頂點是否訪問過
            if (visit[p->adjV] == 0)
            {
                Visit(p->adjV);
                visit[p->adjV] = 1;
                rear = (rear + 1) % maxSize;
                que[rear] = p->adjV;
            }
            p = p->next;
        }
    }
}

//Prim演算法求最小權值和
//引數分別為頂點個數,圖(應該是[n][n].但編譯器不允許使用引數,先用整數代替,起始頂點,權值和)
void Prim( int n, float MGraph[][50], int v0, float &sum)
{
    //同樣應該引數是n和n,編譯器不允許使用變數,先用常量代替
    //lowCost代表當前頂點到其他邊的權值,vSet表示已經選中的頂點
    int lowCost[50], vSet[50];
    int v, k, min;
    //陣列初始化
    for (int i = 0; i < n; i++)
    {
        lowCost[i] = MGraph[v0][i];
        vSet[i] = 0;
    }
    v = v0;
    vSet[v] = 1;
    sum = 0;

    for (int i = 0; i < n-1; i++)
    {
        //min初值設定為無窮大
        min = INFINITY;
        for (int j = 0; j < n; j++)
        {
            if (vSet[j] == 0 && lowCost[j] < min)
            {
                min = lowCost[j];
                k = j;
            }
        }
        vSet[k] = 1;
        v = k;
        sum += min;
        //新併入了頂點,需要更新每個頂點到其他頂點的lowCost值
        for (int j = 0; j < n;++j)
        if (vSet[j] == 0 && MGraph[v][j] < lowCost[j])
            lowCost[j] = MGraph[v][j];
    }
}

//Kruscal演算法求最小生成樹

//結構體定義
typedef struct
{
    int a, b;
    int w;
}Road;
Road road[maxSize];
//通過並查集陣列找根結點

int getRoot(int p) //並查集為v[]
{
    while (p != v[p])
        p = v[p];
    return p;
}
void sort(Road road[], int e)
{
    //代表road函式按照e排序
    cout << endl;
}
void Kruscal(Road road[], int n, int e, int &sum)
{
    int a, b;
    sum = 0;
    for (int i = 0; i < n; ++i)
        v[i] = i;
    //把邊陣列按照權值排序
    sort(road, e);
    for (int i = 0; i < e; ++i)
    {
        a = getRoot(road[i].a);
        b = getRoot(road[i].b);
        if (a!=b)
        {
            v[a] = b;
            sum += road[i].w;
        }

    }
}

//Dijkstra最短路徑
void Dijkstra(int n, float MGraph[][50], int v0, int dist[], int path[])
{
    //初始化
    int set[maxSize];
    int min, v;
    for (int i = 0; i < n; i++)
    {
        dist[i] = MGraph[v0][i];
        set[i] = 0;
        if (MGraph[v0][i] < INFINITY)
            path[i] = v0;
        else
            path[i] = -1;
    }
    set[v0] = 1; path[v0] = -1;
    //對剩餘頂點進行處理
    for (int i = 0; i < n-1; i++)
    {
        //挑選距離最近的頂點,set值設定為1
        min = INFINITY;
        for (int j = 0; j < n;++j)
        if (set[j] == 0 && dist[j] < min)
        {
            v = j;
            min = dist[j];
        }
        set[v] = 1;
        //更新dist和path陣列
        for (int j = 0; j < n; ++j)
        {
            if (set[j] == 0 && dist[v] + MGraph[v][j] < dist[j])
            {
                dist[j] = dist[v] + MGraph[v][j];
                path[j] = v;
            }
        }
    }
}

//Floyd最短路徑
//求A和Path陣列的程式碼
void Floyd(int n, float MGraph[][50], int Path[][50])
{
    int i, j, v;
    int A[50][50];
    for ( i = 0; i < n; i++)
    {
        for ( j = 0; j < n; j++)
        {
            A[i][j] = MGraph[i][j];
            Path[i][j] = -1;
        }
    }
    for ( v = 0; v < n; v++)
        for ( i = 0; i < n; i++)
            for ( j = 0; j < n; j++)
                if (A[i][j]>A[i][v]+A[v][j])
                {
                    A[i][j] = A[i][v] + A[v][j];
                    Path[i][j] = v;
                }    
}
//根據已定義的path陣列尋找最短路徑
//u為路徑起點,v為路徑終點
void printPath(int u, int v, int path[][maxSize])
{
    if (path[u][v] == -1)
        //直接輸出
        cout << endl;
    else
    {
        int mid = path[u][v];
        printPath(u, mid, path);
        printPath(mid, v, path);
    }
}

//拓撲排序演算法

int TopSort(AGraph *G)
{
    int i, j, n = 0;
    int stack[maxSize], top = -1;
    ArcNode *p;

    for ( i = 0; i < G->n; i++)
    {
        if (G->adjList[i].count == 0)
            stack[++top] = i;
    }

    while (top != -1)
    {
        i = stack[top--];
        ++n;
        std::cout << i << " ";
        
        p = G->adjList[j].first;
        while (p != NULL)
        {
            j = p->adjV;
            --(G->adjList[j].count);
            if (G->adjList[j].count == 0)
                stack[++top] = j;
            p = p->next;
        }
    }

    if (n == G->n)
        return 1;
    else
        return 0;
}