ACM-ICPC Live Archive 3645 Objective: Berlin（没通过）

网络流

UVA 1161 是相同的题目

这题网上找不到任何题解的，看上去是个最大流，但是最难搞的就是有时间限制，现在基本上能确定的就是要拆点，但是怎么拆不确定，我用了这种拆法就一直超时

超时的原因我总结一下有几个可能。1.构图的代码太烂，可能出了什么差错但是找不出来。2.数组开小了？开大了？3.和第1个原因，然后运行EK的时候掉进了死循环或者效率太慢。4.EK太慢，要用ISAP

 

超时的代码

/*

原本的点从0到n-1标号，但是每个点需要占用2880个空间，所以对于原来第u个顶点，怎么确定那个范围是它可以用的

就是[u*2880 , (u+1)*2880-1]

如果读入了点u，时间为t而且它是作为到达时间，那么实际对应的点为u*2880+t

如果读入了点u，时间为t而且它是作为出发时间，那么实际上对应的点为u*2880+1440+t

主要在时间转化上可能比较麻烦而且容易出错

*/

#include <cstdio>

#include <cstring>

#include <queue>

#include <algorithm>

using namespace std;

#define MAX 432000 //150*24*60*2=432000

#define L 2880 //每个点需要占用的空间

#define N 160

#define M 5010

#define INF 0x3f3f3f3f

#define min(a,b) a<b?a:b



char city[N][20];

int at[N][L],dt[N][L];

int first[10100]; //最多10000个点

int used[MAX+10];

int ne,nc,nv,n;

int source,target;

int LAST;

struct edge{

    int u,v,cap,flow,next;

}e[10000010];



void add(int u ,int v ,int cap)

{

    e[ne].u=u; e[ne].v=v; e[ne].cap=cap; e[ne].flow=0;

    e[ne].next=first[u]; first[u]=ne++;

    u=u^v; v=u^v; u=u^v;

    e[ne].u=u; e[ne].v=v; e[ne].cap=0; e[ne].flow=0;

    e[ne].next=first[u]; first[u]=ne++;

}



int search_city(char *s)

{

    for(int i=0; i<nc; i++)

        if(!strcmp(s,city[i]))

            return i;

    strcpy(city[nc++],s);

    return nc-1;

}



void input()

{

    char time[10],name[2][10];

    int hour,min,hh,mm,m;

    memset(used,-1,sizeof(used));

    memset(first,-1,sizeof(first));

    for(int i=0; i<n; i++) at[i][0]=dt[i][0]=0;

    scanf("%s%s",city[0],city[1]);

    scanf("%s",time);

    hour=(time[0]-'0')*10+(time[1]-'0');

    min=(time[2]-'0')*10+(time[3]-'0');

    LAST=hour*60+min; //按照分钟来保存时间



   /*

    struct vertex

    {

        int time,n;

    }vt[10100];

    */

    nc=2; ne=0; nv=0;

    scanf("%d",&m);

    while(m--)

    {

        int u,v,cap;

        int index,_index;

        scanf("%s%s%d",name[0],name[1],&cap);

        index=search_city(name[0]);

        _index=search_city(name[1]);



        scanf("%s",time);

        hour=(time[0]-'0')*10+(time[1]-'0');

        min=(time[2]-'0')*10+(time[3]-'0');

        u=index*2880+1440+hour*60+min; //出发点，加1440



        scanf("%s",time);

        hour=(time[0]-'0')*10+(time[1]-'0');

        min=(time[2]-'0')*10+(time[3]-'0');

        v=_index*2880+hour*60+min; //到达点，不加1440



        if(hour*60+min > LAST) continue; //直接抛弃的边



        if(used[u]==-1)

        {

            int t=++dt[index][0]; //出发的点;

            dt[index][t]=u; //出发的点

            used[u]=++nv; //之前没有这个点

//            vt[nv].time=u;

//            vt[nv].n=index;

        }

        if(used[v]==-1)

        {

            int t=++at[_index][0];

            at[_index][t]=v; //到达的点

            used[v]=++nv; //之前没有这个点

//            vt[nv].time=v;

//            vt[nv].n=_index;

        }

        //相当于一个映射，离散化，最后的点标号就是[0,nv-1]



        add(used[u] , used[v] , cap); //用离散化后的点建图

    }

    n=nc;

    for(int i=0; i<n; i++)

        for(int j=1; j<=at[i][0];j++)

            for(int k=1; k<=dt[i][0]; k++)

                if( at[i][j]+30 <= dt[i][k])

                    add(used[at[i][j]] , used[dt[i][k]] , INF);

    source=0; target=++nv;

    for(int i=1; i<=dt[0][0];i++)

        add(source, used[dt[0][i]], INF);

    for(int i=1; i<=at[1][0]; i++)

        add(used[at[1][i]], target, INF);

/*

    for(int i=1; i<=nv-1; i++)

        printf("%d: %d %d\n",i,vt[i].n,vt[i].time);



    for(int i=0; i<ne; i+=2)

    {

        printf("正边: %d %d cap=%d flow=%d\n",e[i].u,e[i].v,e[i].cap,e[i].flow);

        printf("反边: %d %d cap=%d flow=%d\n",e[i+1].u,e[i+1].v,e[i+1].cap,e[i+1].flow);

        printf("\n");

    }



    for(int i=0; i<n; i++)

    {

        printf("%s:\n",city[i]);

        printf("到达时间: ");

        for(int j=1; j<=at[i][0]; j++) printf("%d ",at[i][j]); printf("\n");

        printf("对应顶点: ");

        for(int j=1; j<=at[i][0]; j++) printf("%d ",used[ at[i][j] ]); printf("\n");

        printf("出发时间: ");

        for(int j=1; j<=at[i][0]; j++) printf("%d ",dt[i][j]); printf("\n");

        printf("对应顶点: ");

        for(int j=1; j<=at[i][0]; j++) printf("%d ",used[ dt[i][j] ]); printf("\n");

    }

*/

}



void EK()

{

    int FLOW=0;

    int s=source , t=target;

    while(1)

    {

        queue<int>q;

        int a[10100],p[10100];

        memset(a,0,sizeof(a)); a[s]=INF;

        memset(p,-1,sizeof(p));

        while(!q.empty()) q.pop();

        q.push(s);

        while(!q.empty())

        {

            int u,v,cap,flow;

            u=q.front(); q.pop();

            for(int k=first[u]; k!=-1; k=e[k].next)

            {

                v=e[k].v; cap=e[k].cap; flow=e[k].flow;

                if(!a[v] && cap>flow)

                {

                    a[v]=min(a[u],cap-flow);

                    p[v]=k;

                    q.push(v);

                }

            }

        }

        if(!a[t]) break;

        //printf("_____%d_____\n",a[t]);

        for(int k=p[t]; k!=-1; k=p[e[k].u])

        {

            e[k].flow += a[t];

            e[k^1].flow -= a[t];

        }

        FLOW += a[t];

    }

    //printf("MAX_FLOW=%d\n",FLOW);

    printf("%d\n",FLOW);

}





int main()

{

    while(scanf("%d",&n)!=EOF)

    {

        input();

        EK();

    }

    return 0;

}