图的常用存储结构----邻接矩阵

邻接矩阵

analystS：最简单，最常用，可以直接查询vi与vj之间是否有边以及权值

analystW:不能存储重边，大图空间开销大，对于稀疏图空间利用效率也不高。

key:无论任何顺序输入边，最后值都应该一样。

initial：map[i][i] = 0 map[i][j] = INF

example：nyoj 38

#include
   
   
    
    
#include
    
    
     
     
#include
     
     
      
      
#include
      
      
       
       
using namespace std;
#define Max 999999
#define N 510
int map[510][510];
int dis[510];
int visit[1200];
int minlong;
int prim(int s,int v)
{
    int i,j,k;
    int min;
    minlong = 0;
    for(i = 1; i <= v; i++)
    {
        dis[i] = map[s][i];
    }
    memset(visit,false,sizeof(visit));
    visit[s] = true;
    dis[s] = 0;

    for(i = 1; i <= v-1; i++)
    {
        min = Max;
        for(j = 1; j <= v; j++)
        {
            if(!visit[j] && dis[j] < min && dis[j] >= 0)
            {
                min = dis[j];
                k = j;
            }
        }
        //if(k = 0)
            //return minlong;
        minlong += dis[k];
        visit[k] = true;
        for(j = 1; j <= v; j++)
        {
            if(!visit[j] && map[k][j] < dis[j])
            {
                dis[j] = map[k][j];
            }
        }
    }
    return minlong;
}
int main()
{
    int T;
    int i;
    int v,e;
    int a,b,c;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&v,&e);
        
        memset(map,0,sizeof(map));
        memset(dis,-1,sizeof(dis));

        for(i = 0; i < e; i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b])//处理重边
            {
                if(map[a][b] > c)
                {
                    map[a][b] = c;
                    map[b][a] = c;
                }
            }
            else
            {
                map[a][b] = c;
                map[b][a] = c;
            }
        }
        int t = Max;
        int coast;
        for(i = 0; i < v; i++)
        {
            scanf("%d",&coast);
            if(coast < t)
                t = coast;
        }
       printf("%d\n",t+prim(1,v));
    }
}