阿里秋招C/C++编程题

题目：
服务器都有上下游依赖关系，输入第一行表示服务器的数量，和依赖关系的个数。如下表示有5台服务器，4个依赖关系。
接下来的5行是每台服务器的启动延迟（单位ms），最后四行是服务器之间的依赖关系（5台服务器用数字0-4表示）。
不考虑存在环。
输出要求：延迟最高的路径的延迟时间和此路径的服务器数

输入样例：
5 4
3
5
12
6
4
0 1
0 2
2 3
3 4

输出：
25 4

#include <stdio.h>

struct linkTime
{
    int count;
    int latency;
//  int node[100];  //存储每条路径所包含的节点
};
/*存储每条可能的路径的节点数和总延迟，可以直接使用二维数组，
**但我更喜欢这样的自定义数据结构，让我思考解题方法时思路更清晰，并且更加容易扩展。
*/

void LinkTime(int node, int sociate);

int main()
{
    int node;
    int sociate;
    scanf("%d%d", &node, &sociate);
    LinkTime(node, sociate);

    return 0;
}

void LinkTime(int node, int sociate)
{
    int time[node];
    int soc[sociate][2];
    struct linkTime lt[node];   
    /*如果在vc++6.0里编译，则这三句无法通过。
    **因为vc++6.0里不允许用变量名作为数组的大小初始化数组，即使该变量已经赋值
    */
    int linkCount = 0;
    int count, latency;
    int flag[sociate];  //标识每条边是否可作为路径的进入边，0为是，1为否
    int preNode;
    int maxLatency;
    int i, j;
    for(i=0; i<node; i++)
        scanf("%d", &time[i]);
    for(i=0; i<sociate; i++)
        scanf("%d%d", &soc[i][0], &soc[i][1]);

    for(i=0; i<sociate; i++)
    {
        if(flag[i] == 1)
            continue;

        count = 2;
        latency = time[soc[i][0]] +time[soc[i][1]];
        preNode = soc[i][1];
        for(j=i+1; j<sociate; j++)
        {
            if(soc[j][0] == preNode)
            {
                flag[j] =1;
                count ++;
                latency = latency + time[soc[j][1]];
                preNode = soc[j][1];
            }
            }
        lt[linkCount].count = count;
        lt[linkCount].latency = latency;
        linkCount ++;
    }

    maxLatency = lt[0].latency;
    count = lt[0].count;
    for(i=1; i<linkCount; i++)
    {
        if(lt[i].latency > maxLatency)
        {
            maxLatency = lt[i].latency;
            count = lt[i].count;
        }
    }
    printf("%d %d\n", maxLatency, count);
}

/*****************************************
Date:2018/7/18
Author：ZNM
*****************************************/