一道ACM的题目:计算A地到B地的最大人流量

题目如下：

Problem D Berlin[/b]

[/b]

The
administration of a well-known football team has made a study about the lack of
support in international away games. This
study has concluded that the only
reason for this lack of support is the difficulty in organizing the travel
arrangements. To help solving this problem,
the administration has
asked you to
build a program
that computes the maximum
number of people
that can fly
from a departure
city to a destination
city, using the available
places in regular
flights in a
given day, and arriving at or before a given time. When
traveling from one city to another, a person may make
multiple transfers. Each
transfer is, at
least, 30 minutes
long, i.e., the departure
time should be,
at least 30
minutes after the
arrival time. Given
a set of flights for a single day and the latest
arrival time, your program should compute the maximum number of persons that
can fly, directly or indirectly, from a departure city to a destination city,
arriving at or before the latest arrival time. [/b]

Input [/b]

The
first line contains an integer (smaller or equal to 150) indicating the number
of cities that have flight connections. The second line contains a string
indicating the city of departure. The third line contains a string indicating
the destination city. The fourth line contains the latest arrival time, in the
format HHMM, where HH is the hour in the day (from 00 to 23) and MM is the
minute in the hour (from 00 to 59). The fifth line contains an integer N
(smaller or equal to 5000), with the number of existing flights. Each of the
following N lines contains the info for each flight. Each such line contains
two strings and three integers, separated by blank spaces, O E C D A, where O
and E are, respectively, the origin and destination of a flight, C is the
number of available places in the flight (from 0 to 300), and D and A are the
departure and arrival times in the previously defined format HHMM. All flights
start and end in the same day. City names may have up to 8 characters. [/b]

Output [/b]

The
output consists of one single line with an integer stating the maximum number
of people that can fly from the origin to the destination city, using the given
flights and arriving at or before the given latest arrival time. [/b]

Sample Input [/b]

4 [/b]

lisbon[/b] [/b]

berlin
[/b]

1500
[/b]

9 [/b]

lisbon[/b] london
6 1000 1100 [/b]

london[/b] lisbon 6 1130 1230 [/b]

lisbon[/b] paris
5 1000 1100 [/b]

paris[/b] lisbon 4 1130 1230 [/b]

london[/b] paris 1 1130 1300 [/b]

london[/b] berlin 2 1340 1510 [/b]

berlin
london 2 1300
1430 [/b]

paris[/b] berlin 10 1330 1500 [/b]

berlin
paris 9 1300
1430 [/b]

Sample
Output[/b]

6[/b]

[/b]

大意：

一个有名的足球队部门作了一项有关于国际运动缺乏支持的研究。研究表明这种缺乏支持的唯一原因是组织行程安排上的困难。为了解决这个问题，该部门要你建立一个计算从起发城市到指定城市最大人流量的程序，在给定的某天，正常的航班，选择可到达的城市，正常到达或者提前到达。当从一个城市到另一个城市，某人可能选择多种行程；每一种行程都至少需要30分钟，也就是说，至少得到达30分钟之后才能重新启程。在某天设置一个航班和最迟可到达的时间，你的程序要计算所飞的最大人数，直接或间接地到达目的地，正常到达或提前到达。

输入：

第一行包含一个整数（小于等于150）表示相互可到达的城市数目，

第二行包含一个字符表示起程地，

第三行包含一个字符表示目的地，

第四行包含最迟可到时间，以HHMM的格式，HH是一天的时间（从00到23），MM是一个小时的分钟数（从00到59）。

第五行包含一个整数N（小于等于5000），可用的航班的数目，包含每一种航班的信息。每一个这种形式的路线包含两个字符和三个整数，由空白空间分隔，O E C D A，O和E代表航班的起发地和目的地，C代表飞机中可用的座位（从0到300），D和A代表先前已定好的离开和到达的时间。所有的航班在同一天起飞和结束。城市名字可达到8个字符。

输出：

要求输出结果中只输出一个整数标明从起发地到目的地的最大人流量，用给定的航班，预期到达或先于最迟到达时间到达。

由于测试时每次输入数据很麻烦，我直接从文件读取了。
程序如下：
// ACM.c : main file
// (c) 2009 wang.xw

#include "acm.h"

int main(int argc, char* argv[])
{
// initialize linked list
pgCityHead = Init();
if (!pgCityHead)
{
printf("Memory error./n");
return 0;
}

// get information
if (!getinfo())
{
printf("Input error./n");
return 0;
}

Request();

if (giShowCitysinfo)
{
PrintCity();
printf("-----------------------------------------------------/n");
}

// recursive function
MoveToDest(gcStartCity, 0, MAXPEOPLENUM);

// print result
printf("MAX Number: %d./n", giResultNum);

// free memory
FreeCity(pgCityHead);
printf("Press any key to exit.");
getchar();
return 0;
}

pCityNode Init()
{
pCityNode pMyCityNode;
pMyCityNode = (pCityNode)malloc(sizeof(CityNode));
if (pMyCityNode)
{
strcpy(pMyCityNode->cCityName, "City");
pMyCityNode->next = NULL;
pMyCityNode->TravelInfo = NULL;
}
return pMyCityNode;
}

void FreeCity(pCityNode pMyCityNode)
{
pCityNode pTmpCityNode;

if (!pMyCityNode)
{
return;
}
FreeTravel(pMyCityNode->TravelInfo);

pTmpCityNode = pMyCityNode->next;

free(pMyCityNode);
pMyCityNode = NULL;

if (pTmpCityNode)
{
FreeCity(pTmpCityNode);
}

return;
}

void FreeTravel(pTravelInfoNode pMyTravelInfoNode)
{
pTravelInfoNode pTmpTIN;

if (!pMyTravelInfoNode)
{
return;
}
pTmpTIN = pMyTravelInfoNode->next;

free(pMyTravelInfoNode);
pMyTravelInfoNode = NULL;

if (pTmpTIN)
{
FreeTravel(pTmpTIN);
}

return;
}

void Request()
{
char cTmp;
printf("To Show Information of the Citys and Flights (Y/N) ?");
scanf("%c", &cTmp);
if (cTmp == 'Y' || cTmp == 'y')
{
giShowCitysinfo = 1;
}
fflush(stdin);

printf("To Show Information of How to Fly (Y/N) ?");
scanf("%c", &cTmp);
if (cTmp == 'Y' || cTmp == 'y')
{
giShowHowToFly = 1;
}
fflush(stdin);

system("cls");
return;
}

// end of ACM.c
// ACM.H : main head file
// (c) 2009 wang.xw

#ifndef _ACM_H_
#define _ACM_H_

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>

#define MAXNAMENUM 10
#define MAXPEOPLENUM 32766

typedef struct tagTravelInfoNode
{
char cDestCity[8];
int iStartTime;
int iEndTime;
int iCapacity;
struct tagTravelInfoNode *next;
}TravelInfoNode, *pTravelInfoNode;

typedef struct tagInputInfo
{
char cFirstCity[8];
char cSecondCity[8];
int iPeopleNum;
int iStartTime;
int iEndTime;
}InputInfo, *pInputInfo;

typedef struct tagCityNode
{
char cCityName[8];
struct tagTravelInfoNode *TravelInfo;
struct tagCityNode *next;
}CityNode, *pCityNode;

pCityNode pgCityHead;
char gcStartCity[MAXNAMENUM];
char gcEndCity[MAXNAMENUM];
int giLatestTime;
int giCityNum;
int giResultNum;
int giShowCitysinfo;
int giShowHowToFly;

#include "getinfo.h"
#include "deal.h"

void Request();
pCityNode Init();
void FreeCity(pCityNode);
void FreeTravel(pTravelInfoNode);

#endif

// end of ACM.H

// deal.c : make city link list,show how to fly
// (c) 2009 wang.xw

#include "deal.h"

int InsertCity(pInputInfo pMyInputInfo)
{
pCityNode pTmpCityNode;
pTmpCityNode = pgCityHead->next;
while (pTmpCityNode)
{
if (!strcmp(pTmpCityNode->cCityName, pMyInputInfo->cFirstCity))
{
return InsertTravel(pTmpCityNode, pMyInputInfo);
}
pTmpCityNode = pTmpCityNode->next;
}

pTmpCityNode = (pCityNode)malloc(sizeof(CityNode));
--giCityNum;
if (!pTmpCityNode)
{
printf("Memory error./n");
return 0;
}
else
{
strcpy(pTmpCityNode->cCityName, pMyInputInfo->cFirstCity);
pTmpCityNode->TravelInfo = NULL;
pTmpCityNode->next = pgCityHead->next;
pgCityHead->next = pTmpCityNode;
return InsertTravel(pTmpCityNode, pMyInputInfo);
}
}

int InsertTravel(pCityNode pMyCityNode, pInputInfo pMyInputInfo)
{
int iCnt = 0;
pTravelInfoNode pMyTravelInfoNode;
pTravelInfoNode pTmpTIN;
pTravelInfoNode pPreTIN;

pMyTravelInfoNode = (pTravelInfoNode)malloc(sizeof(TravelInfoNode));
if (!pMyTravelInfoNode)
{
printf("Memory error./n");
return 0;
}

strcpy(pMyTravelInfoNode->cDestCity, pMyInputInfo->cSecondCity);
pMyTravelInfoNode->iStartTime = pMyInputInfo->iStartTime;
pMyTravelInfoNode->iEndTime = pMyInputInfo->iEndTime;
pMyTravelInfoNode->iCapacity = pMyInputInfo->iPeopleNum;

if (!pMyCityNode->TravelInfo)
{
pMyTravelInfoNode->next = NULL;
pMyCityNode->TravelInfo = pMyTravelInfoNode;
}
else
{
pTmpTIN = pMyCityNode->TravelInfo;
pPreTIN = pTmpTIN;
while (pTmpTIN && pTmpTIN->iStartTime < pMyTravelInfoNode->iStartTime)
{
++iCnt;
pPreTIN = pTmpTIN;
pTmpTIN = pTmpTIN->next;
}
if (!iCnt)
{
pMyTravelInfoNode->next = pMyCityNode->TravelInfo;
pMyCityNode->TravelInfo = pMyTravelInfoNode;
}
else
{
pMyTravelInfoNode->next = pPreTIN->next;
pPreTIN->next = pMyTravelInfoNode;
}
}
return 1;
}

int MoveToDest(char *Local, int iStartTime, int iPeopleNum)
{
pCityNode pMyCityNode;
pTravelInfoNode pMyTravelInfoNode;
int iStartTimeNew;
int iPeopleNumNew;
int iResult = 0;

if (!strcmp(Local, gcEndCity))
{
iResult = iPeopleNum;
giResultNum += iResult;
return iResult;
}

pMyCityNode = FindCity(Local);
if (!pMyCityNode)
{
printf("City Name error./n");
exit(0);
}
pMyTravelInfoNode = pMyCityNode->TravelInfo;

if (!iStartTime)
{
iStartTimeNew = iStartTime;
}
else
{
if (((iStartTime + 30) % 100) >= 60)
{
iStartTimeNew = iStartTime + 70;
}
else
{
iStartTimeNew = iStartTime + 30;
}

}

while (pMyTravelInfoNode && pMyTravelInfoNode->iCapacity > 0)
{

if (iPeopleNum > pMyTravelInfoNode->iCapacity)
{
iPeopleNumNew = pMyTravelInfoNode->iCapacity;
}
else
{
iPeopleNumNew = iPeopleNum;
}

if (pMyTravelInfoNode->iStartTime >= iStartTimeNew &&
pMyTravelInfoNode->iEndTime <= giLatestTime &&
strcmp(pMyTravelInfoNode->cDestCity, gcStartCity))
{
iResult = MoveToDest(pMyTravelInfoNode->cDestCity,
pMyTravelInfoNode->iEndTime,
iPeopleNumNew);
if (iResult)
{
if (giShowHowToFly)
{
printf("From %-8s to %-8s start %-3d end %-3d num %3d /n",
Local,
pMyTravelInfoNode->cDestCity,
pMyTravelInfoNode->iStartTime,
pMyTravelInfoNode->iEndTime,
iPeopleNumNew);
if (!strcmp(Local, gcStartCity))
{
printf("-----------------------------------------------------/n");
}
}
pMyTravelInfoNode->iCapacity -= iResult;
iPeopleNum -= iResult;
}
}
pMyTravelInfoNode = pMyTravelInfoNode->next;
}
return iResult;
}

pCityNode FindCity(char *Local)
{
pCityNode pMyCityNode;
pMyCityNode = pgCityHead->next;
while (pMyCityNode)
{
if (!strcmp(pMyCityNode->cCityName, Local))
{
break;
}
pMyCityNode = pMyCityNode->next;
}
return pMyCityNode;
}

// end of deal.c

// deal.h
// (c) 2009 wang.xw

#ifndef _DEAL_H_
#define _DEAL_H_

#include "acm.h"

int InsertCity(pInputInfo);
int InsertTravel(pCityNode, pInputInfo);
int MoveToDest(char *Local, int iStartTime, int iPeopleNum);
pCityNode FindCity(char *Local);

#endif

// end of deal.h

// getinfo.c : obtain information from user
// (c) 2009 wang.xw

#include "getinfo.h"

int getinfo()
{
int iLatestHour;
int iLatestMinute;
int iFlightNum;
int iCnt;
int iAbortNum = 0;
pInputInfo pMyInputInfo;
FILE *pInput;

pInput = fopen("input.txt", "r");
if (!pInput)
{
printf("File error./n");
exit(0);
}

fscanf(pInput, "%d", &giCityNum);
fscanf(pInput, "%s", gcStartCity);
fscanf(pInput, "%s", gcEndCity);
fscanf(pInput, "%d", &giLatestTime);
fscanf(pInput, "%d", &iFlightNum);

iLatestHour = giLatestTime / 100;
iLatestMinute = giLatestTime % 100;

if (giCityNum > 150 || giCityNum <= 0)
{
printf("City Number error./n");
return 0;
}
if (strlen(gcStartCity) > 8 || strlen(gcEndCity) > 8)
{
printf("City Name length error./n");
return 0;
}
if (!(iLatestHour >= 0 && iLatestHour <= 23) || !(iLatestMinute >= 0 && iLatestMinute <= 59))
{
printf("Latest Time error./n");
return 0;
}
if (iFlightNum > 5000 || iFlightNum <= 0)
{
printf("Flight Number error./n");
return 0;
}

pMyInputInfo = (pInputInfo)malloc(sizeof(InputInfo));
if (!pMyInputInfo)
{
printf("Memory error./n");
return 0;
}

for (iCnt = 0; iCnt < iFlightNum; ++iCnt)
{
fscanf(pInput, "%s%s%d%d%d", pMyInputInfo->cFirstCity,
pMyInputInfo->cSecondCity,
&pMyInputInfo->iPeopleNum,
&pMyInputInfo->iStartTime,
&pMyInputInfo->iEndTime);

if (pMyInputInfo->iPeopleNum > 0 && pMyInputInfo->iPeopleNum <= 300
&& (pMyInputInfo->iStartTime / 100 >= 0 && pMyInputInfo->iStartTime / 100 < 24)
&& (pMyInputInfo->iStartTime % 100 >= 0 && pMyInputInfo->iStartTime % 100 < 60)
&& (pMyInputInfo->iEndTime / 100 >= 0 && pMyInputInfo->iEndTime / 100 < 24)
&& (pMyInputInfo->iEndTime % 100 >= 0 && pMyInputInfo->iEndTime % 100 < 60)
&& pMyInputInfo->iStartTime < pMyInputInfo->iEndTime)
{
InsertCity(pMyInputInfo);
}
else
{
++iAbortNum;
}
}

if (iAbortNum)
{
printf("Abort %d record(s)/n", iAbortNum);
}
free(pMyInputInfo);
pMyInputInfo = NULL;
fclose(pInput);
if (giCityNum < 0)
{
printf("City Number error./n");
return 0;
}
return 1;
}

void PrintCity()
{
pCityNode pMyCityNode;
pMyCityNode = pgCityHead->next;
while (pMyCityNode)
{
printf("City Name : %-8s/n",
pMyCityNode->cCityName);
PrintTravel(pMyCityNode->cCityName, pMyCityNode->TravelInfo);
pMyCityNode = pMyCityNode->next;
}
return;
}

void PrintTravel(char *Local, pTravelInfoNode pMyTravelInfoNode)
{
pTravelInfoNode pTemTravelInfoNode;
pTemTravelInfoNode = pMyTravelInfoNode;
while (pTemTravelInfoNode)
{
printf("%-8s %-8s %-3d %-3d %-6d /n",
Local,
pTemTravelInfoNode->cDestCity,
pTemTravelInfoNode->iStartTime,
pTemTravelInfoNode->iEndTime,
pTemTravelInfoNode->iCapacity);
pTemTravelInfoNode = pTemTravelInfoNode->next;
}
return;
}

// end of getinfo.c

// getinfo.H
// (c) 2009 wang.xw

#ifndef _GETINFO_H_
#define _GETINFO_H_

#include "acm.h"

int getinfo();
void PrintCity();
void PrintTravel(char *, pTravelInfoNode);

#endif

// end of getinfo.H

[/b]

大半天的时间作出来的，很可能有问题，欢迎指出。