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

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

单向，输出最小需要步数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#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;i<n;i++)
    {
        min=MAX;
        for(j=1;j<=n;j++)
        {
            if(d[j]<min&&v[j]==0)
            {
                k=j;
                min=d[j];
            }
        }//寻找距离初始点，路径最短的点
        v[k]=1;//马上要更新他周围的点，避免不必要的比较
        //寻找与k直连的点，写出他到s的路径，如果大于 s到k到直连点的路径，则更新为较小值。
        for(j=1;j<n;j++)
        {
            if(v[j]==0&&map[k][j]<MAX)
            {
                if(d[j]>d[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 <stdio.h>
#include <stdlib.h>
#include <string.h>
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<j)
    {
        while(i<j&&mp[j].c>=k.c)j--;
        mp[i]=mp[j];
        while(i<j&&mp[i].c<=k.c)i++;
        mp[j]=mp[i];
    }
    mp[i]=k;
    pai(l,i-1);
    pai(i+1,r);
}
int main()
{
    int n,m,i,cost,num;
    while(~scanf("%d%d",&n,&m))
    {
        if(m==0)
            printf("0\n");
        else
        {
            memset(f,0,sizeof(f));
            for(i=1; i<=103; i++)//这里注意n是个数，但城市的下标只需<=100，可能比n大
                f[i]=i;//所以将下标范围内的数全部初始化
            for(i=1; i<=m; i++)
                scanf("%d%d%d",&mp[i].a,&mp[i].b,&mp[i].c);
            pai(1,m);
            for(i=1,cost=0,num=0; i<=m; i++)
            {
                if(num==n-1)break;
                if(merge(mp[i].a,mp[i].b)==0)
                {
                    num++;
                    cost+=mp[i].c;
                }
            }
            printf("%d\n",cost);
        }
    }
    return 0;
}