【图论】bfs，迪杰斯特拉，最小生成树

1.2139 数据结构实验之图论五：从起始点到目标点的最短步数（BFS）

单向，输出最小需要步数

#include 
#include 
#include 
int a[1003][1003],v[1003],n;
struct node
{
    int data;
    int step;
}x,t;
void bfs(int n)
{
    int i,in=0,out=0;
    struct node q[1003];
    v[n]=1;
    t.data=n;
    t.step=0;
    q[in++]=t;
    while(in>out)
    {
        x=q[out++];
        if(x.data==1)
        {
            printf("%d\n",x.step);
            return ;
        }
        for(i=1;i<=n;i++)
        {
            if(a[x.data][i]==1&&v[i]==0)
            {
                t.data=i;
                t.step=x.step+1;
                q[in++]=t;
                v[i]=1;
            }
        }
    }
    printf("NO\n");
    return ;
}
int main()
{
    int t,m,x,y,s;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(a,0,sizeof(a));
        memset(v,0,sizeof(v));
        while(m--)
        {
            scanf("%d%d",&x,&y);
            a[x][y]=1;
        }
        bfs(n);
    }
    return 0;
}

2.3363 数据结构实验之图论七：驴友计划

迪杰斯特拉

#include 
#include 
#include 
#define MAX 0x3f3f3f3f
int map[505][505],money[505][505],v[505],d[505],mon[505];
void dij(int n,int s)
{
    int j,k,i,min;
    for(i=1;i<=n;i++)
    {
        d[i]=map[s][i];
        mon[i]=money[s][i];
    }
    v[s]=1;
    d[s]=0;
    mon[s]=0;
    for(i=1;id[k]+map[k][j])
                {
                    d[j]=d[k]+map[k][j];
                    mon[j]=mon[k]+money[k][j];
                }
                else if(d[j]==d[k]+map[k][j]&&mon[j]>mon[k]+money[k][j])
                {
                    mon[j]=mon[k]+money[k][j];
                }
            }
        }
    }
}
int main()
{
    int t,n,m,price,s,e,l,x,y,i,j;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d%d",&n,&m,&s,&e);
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(i==j)
                    map[i][j]=0;
                else
                    map[i][j]=MAX;
            }
        }
        while(m--)
        {
            scanf("%d%d%d%d",&x,&y,&l,&price);
            map[x][y]=map[y][x]=l;
            money[x][y]=money[y][x]=price;
        }
        memset(v,0,sizeof(v));
        dij(n,s);
        printf("%d %d\n",d[e],mon[e]);
    }
    return 0;
}

3.SDUT 2144 数据结构实验之图论九：最小生成树

有n个城市，其中有些城市之间可以修建公路，修建不同的公路费用是不同的。现在我们想知道，最少花多少钱修公路可以将所有的城市连在一起，使在任意一城市出发，可以到达其他任意的城市。

给出城市个数 可以修建的公路个数。(n <= 100， m <=10000)，给出数个abc的值，代表城市a 和城市b之间可以修建一条公路，代价为c。输出最小花费。
 

#include 
#include 
#include 
struct node
{
    int a,b,c;
} mp[10002];
int f[100005];
int gett(int x)//找头
{
    if(f[x]==x)
        return x;
    f[x]=gett(f[x]);
    return f[x];
}
int merge(int x,int y)//如若二者头不同，就把第一个的头指向第二个头上
{
    int a=gett(x),b=gett(y);
    if(a!=b)
    {
        f[a]=b;
        return 0;
    }
    else return 1;
}
void pai(int l,int r)
{
    int i=l,j=r;
    struct node k=mp[l];
    if(l>=r)
        return ;
    while(i=k.c)j--;
        mp[i]=mp[j];
        while(i