POJ1502: MPI Maelstrom

红果果的dijstra算法应用，这里采用邻接表存储图

小插曲：while(scanf("%d",&n)）提交时内存超限，改成while(scanf("%d",&n)！=EOF）就AC了，不知道为什么

dijstra算法应用：已知定点为输入，输入图中所有其他点到该定点的最短距离。

具体做法：

a.初始时，S只包含源点，即S＝{v}，v的距离为0。U包含除v外的其他顶点，即:U={其余顶点}，若v与U中顶点u有边，则<u,v>正常有权值，若u不是v的出边邻接点，则<u,v>权值为∞。

b.从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。

c.以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。

d.重复步骤b和c直到所有顶点都包含在S中。

 　　　　　　　　　　　　　　　　　　　　

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int max_size=101;
const int MAXINT=9999999;
typedef struct arcNode{
    int node;
    int len;
    arcNode *next;
}arcNode;
typedef struct headNode{
    arcNode *firstArc;
}adjList[max_size];
typedef struct cmap{
    adjList map;
    int nodeNum, arcNum;
}cmap;
int n;
int st,ed;
int dis[max_size];
bool vis[max_size];
void initiate(cmap *c){
    for(int i=1;i<=c->nodeNum;i++){
        c->map[i].firstArc=NULL;
    }
}
void addEdge(cmap *c,int from,int to,int len){
    if(from==to) return;
    arcNode *arc=(arcNode *)malloc(sizeof(arcNode));
    arc->node=to;
    arc->len=len;
    arc->next=c->map[from].firstArc;
    c->map[from].firstArc=arc;
    
    arcNode *arcc=(arcNode *)malloc(sizeof(arcNode));
    arcc->node=from;
    arcc->len=len;
    arcc->next=c->map[to].firstArc;
    c->map[to].firstArc=arcc;

}
/*
void print(cmap *c){
    for(int i=1;i<=c->nodeNum;i++){
        arcNode *p=c->map[i].firstArc;
        while(p){
            printf("(%d)%d ",p->len,p->node);
            p=p->next;    
        }
        printf("
");    
    }
}
*/
void dijstra(cmap *c){
    int ans=-1;
    arcNode *p=c->map[st].firstArc;
    memset(dis,MAXINT,sizeof(dis));
    memset(vis,false,sizeof(vis));
    while(p){
        dis[p->node]=p->len;
        p=p->next;
    }
    dis[st]=0;
    vis[st]=true;
    
    for(int i=1;i<=c->nodeNum-1;i++){
        int min_dist=9999999;
        int u;
        for(int j=1;j<=c->nodeNum;j++){
            if(!vis[j]&&dis[j]<min_dist){
                min_dist=dis[j];
                u=j;
            }
        }
        vis[u]=true;
        arcNode *p=c->map[u].firstArc;
        while(p){
            int len=p->len;
            int temp=p->node;
            if(!vis[temp]&&min_dist+len<dis[temp]){
                dis[temp]=min_dist+len;
            }
            p=p->next;
        }

    }
    for(int i=2;i<=c->nodeNum;i++){
        if(dis[i]>ans) ans=dis[i];
    }
    printf("%d
",ans);
}
int main(){
    while(scanf("%d",&n)!=EOF){
        cmap *c=(cmap *)malloc(sizeof(cmap));
        c->nodeNum=n; c->arcNum=n*n/2;
        initiate(c);
        st=1;
        char tmp[20];
        for(int i=1;i<=n-1;i++){
            for(int j=1;j<=i;j++){
                scanf("%s",tmp);
                if(tmp[0]=='x') addEdge(c,i+1,j,MAXINT);
                else addEdge(c,i+1,j,atoi(tmp));
            }
        }
        //print(c);    
        dijstra(c);
    }
    return 0;
}