UVA 140 bandwidth 一直RE,求助大家

[gdsjyskhz]

题目来源：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=76

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define VISITED 1
#define UNVISITED 0
#define SOLVED 1
#define UNSOLVED 0
#define INT_MAX 2147483647
#define DEQ(a,b) (fabs((a)-(b))<=0.00001)
typedef int Status;
typedef struct ArcNode
{
    int adjvex;
    struct ArcNode *next;
} ArcNode;
typedef struct
{
    char ch;
    ArcNode *FirstArc;
} VertexType;
typedef struct
{
    VertexType vexs[20];
    int vexnum;
} Graph;
Status CreateUDG(Graph *G,char *str);
Status BandWidthProblem(Graph *G);
Status BWP(Graph *G,int *A,int cur,int *bandwidth,int *vis,int *pos,int *k,int *path);//A为临时路径记录，cur为指示，bandwidth为结点带宽记录，vis
//为访问标志，pos为位置记录（方便计算带宽），k为当前最小带宽，path为最小带宽路径记录
Status DelectGraph(Graph *G);
int main()
{
    char str[3000];
    Graph G;
    while(scanf("%s",str)>0&&str[0]!='#')
    {
        CreateUDG(&G,str);
        BandWidthProblem(&G);
        DelectGraph(&G);
    }
    return 0;
}

Status BandWidthProblem(Graph *G)
{
    int bandwidth[100];
    int vis[100];
    int pos[100];
    int A[100];
    int i;
    int path[100];
    int k=INT_MAX;
    for(i=0; i<=G->vexnum-1; i++)
    {
        bandwidth[i]=0;
        vis[i]=UNVISITED;
    }
    BWP(G,A,0,bandwidth,vis,pos,&k,path);
    for(i=0;i<=G->vexnum-1;i++)
    {
        printf("%c ",(char)('A'+path[i]));
    }
    printf("-> %d\n",k);
    return OK;
}

Status BWP(Graph *G,int *A,int cur,int *bandwidth,int *vis,int *pos,int *k,int *path)//A为临时路径记录，cur为指示，bandwidth为结点带宽记录，vis
//为访问标志，pos为位置记录（方便计算带宽），k为当前最小带宽，path为最小带宽路径记录
{
    int i,t;
    int ok;
    int bandwidthTemp[8];
    int j,h;
    int max;
    ArcNode *p;
    if(cur==G->vexnum)
    {
        max=bandwidth[0];
        for(i=1; i<=G->vexnum-1; i++) //找出当前路径的图的带宽
        {
            if(bandwidth[i]>max)
            {
                max=bandwidth[i];
            }
        }
        if(max<*k)
        {
            *k=max;
            for(i=0; i<=G->vexnum-1; i++)
            {
                path[i]=A[i];
            }
        }
        return OK;
    }


    for(i=0; i<=G->vexnum-1; i++)
    {
        if(vis[i]==UNVISITED)  //如果该结点没有被访问过
        {
            ok=1;
            j=0;
            bandwidthTemp[j++]=bandwidth[i];
            pos[i]=cur; //记录位置
            A[cur]=i;

            for(p=G->vexs[i].FirstArc; p!=NULL; p=p->next) //处理带宽
            {
                if( vis[p->adjvex]==VISITED ) //如果该邻接点已被访问
                {
                    t=pos[i]-pos[p->adjvex];//它俩的临时带宽

                    if(t>*k)  //如果该临时带宽大于已知最优解
                    {
                        ok=0;
                        break;
                    }

                    bandwidthTemp[j++]=bandwidth[p->adjvex];

                    if(t>bandwidth[p->adjvex])
                    {
                        bandwidth[p->adjvex]=t;
                    }
                    if(t>bandwidth[i])
                    {
                        bandwidth[i]=t;
                    }
                }
            }
            if(ok==1)
            {
                vis[i]=VISITED; //做标记
                BWP(G,A,cur+1,bandwidth,vis,pos,k,path);
            }


            vis[i]=UNVISITED;  //还原标记
            //还原带宽
            h=0;
            bandwidth[i]=bandwidthTemp[h++];
            for(p=G->vexs[i].FirstArc; p!=NULL&&h<=j-1; p=p->next)
            {
                if( vis[p->adjvex]==VISITED )
                {
                    bandwidth[p->adjvex]=bandwidthTemp[h++];
                }
            }

        }
    }
    return OK;
}

Status CreateUDG(Graph *G,char *str)
{
    int i;
    int tag;
    int edgehead,edgetail;
    int n=0;
    char ch;
    ArcNode *p,*p2;
    for(ch='A'; ch<='Z'; ch++) //处理结点数
    {
        for(i=0; str[i]!='\0'; i++)
        {
            if(str[i]==ch)
            {
                n++;
                break;
            }
        }
    }
    G->vexnum=n;
    for(i=0; i<=G->vexnum-1; i++)
    {
        G->vexs[i].FirstArc=NULL;
    }
    for(i=0; str[i]!='\0'; i++) //处理边
    {
        if(str[i+1]==':')
        {
            edgehead=str[i]-'A';
            for(i=i+2;; i++)
            {
                if(str[i]==';'||str[i]=='\0')
                {
                    break;
                }
                edgetail=str[i]-'A' ;
                tag=1;
                for(p2=G->vexs[edgetail].FirstArc;p2!=NULL;p2=p2->next)  //判断该边是否已经加入过了
                {
                    if(p2->adjvex==edgehead)
                    {
                        tag=0;
                        break;
                    }
                }
                if(tag==1)
                {
                p=(ArcNode *)malloc(sizeof(ArcNode));
                p->adjvex=edgetail;
                p->next=G->vexs[edgehead].FirstArc;
                G->vexs[edgehead].FirstArc=p;

                p=(ArcNode *)malloc(sizeof(ArcNode));
                p->adjvex=edgehead;
                p->next=G->vexs[edgetail].FirstArc;
                G->vexs[edgetail].FirstArc=p;
                }
            }
        }
    }
    return OK;
}
Status DelectGraph(Graph *G)
{
    int i;
    ArcNode *p,*t;
    for(i=0;i<=G->vexnum-1;i++)
    {
        for(p=G->vexs[i].FirstArc;p!=NULL;)
        {
            t=p->next;
            free(p);
            p=t;
        }
    }
    return OK;
}