图的最短路径

这里有三个版本，前面的最好，再次之，再次之。
每个点有个数据包，数据包里放的是这个点到到始的length和这个length所对路径
4 4
0 1 1
0 3 8
0 2 3
2 3 4
32767 1 3 8
1 32767 32767 32767
3 32767 32767 4
8 32767 4 32767
0->0
1->01
2->02
3->023
Press any key to continue

#include <iostream>
using namespace std;

//012345分别表示v0 v1......
struct ll
{
  int lenth;//记录l【i】到v0的路长；
  char lujing[20];
};
  int v;//点数目
  int edge;///边数目
  int si=0;//si用来控制s数组的位置


int** draw();//绘图
int no_s_l_min(int* s,struct ll* jilu);//不在s数组中的l数组中最小的点
int no_s(int k,int* s);//不在s数组中的
int main(int argc, char const *argv[])
{
  int i,j;
  int**a=draw();
//------------------------------------------------------------------------//
  int* s=new int[v];//存放ok了的标记,si用来控制s数组的位置
  for ( i = 0; i < v; ++i)s[i]=32767;
//------------------------------------------------------------------------//
  struct ll* jilu=new struct ll[v];
  for( i = 0; i < v; ++i)
  {
    jilu[i].lenth=32767;
    for (j = 0; j < 10; ++j)
     jilu[i].lujing[j]='\0';
  }
//------------------------------------------------------------------------//
  jilu[0].lenth=0;//v0点进入，初始化
  jilu[0].lujing[0]='0';
  jilu[0].lujing[1]='\0';
  int u=0;//不属于s的并且l【u】最小的一个顶点
//------------------------------------------------------------------------//
  while( no_s(v-1,s) )//最后一个点不在s中
  {
    u=no_s_l_min(s,jilu);
    s[si++]=u;
    for ( i = 0; i < v; ++i)
    {
       if (no_s(i,s) && a[u][i]<32767 && i!=u)
       {
         if (jilu[u].lenth+a[u][i]<jilu[i].lenth)//lenth和路径将会改变
         {/更换i的所有数据
            jilu[i].lenth=jilu[u].lenth+a[u][i];
            int j;
            for (j = 0; jilu[u].lujing[j] != '\0'; ++j)
                jilu[i].lujing[j]=jilu[u].lujing[j];

            jilu[i].lujing[j]=i+48;//变为i的字符
            jilu[i].lujing[j+1]='\0';
         }
       }
    }
  }
//------------------------------------------------------------------------//
    for ( i = 0; i < v; ++i)
      cout<<i<<"->"<<jilu[i].lujing<<"\n";
  return 0;
}
int** draw()//绘图
{
  int i,j;
  cin>>v>>edge;///输入点数目和边数目
  int **a=new int*[v];
  for ( i = 0; i < v; ++i)
    a[i]=new int[v];
  for ( i = 0; i < v; ++i)
    for ( j = 0; j < v; ++j)
      a[i][j]=32767;

  int spot1,spot2,len;
  for ( i = 0; i < edge; ++i)
  {
    cin>>spot1>>spot2>>len;
    a[spot1][spot2]=len;    a[spot2][spot1]=len;
  }
    for ( i = 0; i < v; ++i){
    for ( j = 0; j < v; ++j)
      cout<<a[i][j]<<" ";
    cout<<"\n";
    }
    cout<<"\n";
  return a;
}
int no_s_l_min(int* s,struct ll* jilu)//不再s数组中的l数组中最小的点
{
  int mark=0;
  int min;
     for (int i = 0; i < v; ++i)
     {
       if(no_s(i,s) )//不在s数组里的点vi
        {
          if(mark==0){min=i;mark=1;}//必然会执行一次，初始化min
          else
          {
            if (jilu[min].lenth > jilu[i].lenth)
              min=i;         
          }
        }
     }
     return min;//返回Vmin;
}
int no_s(int k,int* s)
{
  for (int i = 0; i <= si; ++i)
    if(s[i]==k)return 0;//点vk不再s[i]中
 return 1;
}














#include <iostream>
using namespace std;

//012345分别表示v0 v1......
int a[6][6]={
  {0,4,2,32767,32767,32767},
  {4,0,3,5,32767,32767},
  {2,3,0,8,10,32767},
  {32767,5,8,0,2,6},
  {32767,32767,10,2,0,3},
  {32767,32767,32767,6,3,0}
};
struct ll
{
  int lenth;//记录l【i】到v0的路长；
  char lujing[10];
};
int s[6]={32767,32767,32767,32767,32767,32767},si=0;//存放ok了的标记,si用来控制s数组的位置
struct ll jilu[6];


int no_s_l_min();//不在s数组中的l数组中最小的点
int no_s(int k);//不在s数组中的
int main(int argc, char const *argv[])
{
  
  for(int i = 0; i < 6; ++i)
  {
    jilu[i].lenth=32767;
    for (int j = 0; j < 10; ++j)
     jilu[i].lujing[j]='\0';
  }

  jilu[0].lenth=0;//v0点进入，初始化
  jilu[0].lujing[0]='0';
  jilu[0].lujing[1]='\0';
  int u=0;//不属于s的并且l【u】最小的一个顶点

  while( no_s(5) )//v5不在s中
  {
    u=no_s_l_min();
    s[si++]=u;
    for (int i = 0; i < 6; ++i)
    {
       if (no_s(i) && a[u][i]<32767 && i!=u)
       {
         if (jilu[u].lenth+a[u][i]<jilu[i].lenth)//lenth和路径将会改变
         {
            jilu[i].lenth=jilu[u].lenth+a[u][i];
            int j;
            for (j = 0; jilu[u].lujing[j] != '\0'; ++j)
                jilu[i].lujing[j]=jilu[u].lujing[j];

            jilu[i].lujing[j]=i+48;//变为i的字符
            jilu[i].lujing[j+1]='\0';
         }
       }
    }
  }

    for ( i = 0; i < 6; ++i)
      cout<<i<<"->"<<jilu[i].lujing<<"\n";
  return 0;
}

int no_s_l_min()//不再s数组中的l数组中最小的点
{
  int mark=0;
  int min;
     for (int i = 0; i < 6; ++i)
     {
       if(no_s(i) )//不在s数组里的点vi
        {
          if(mark==0){min=i;mark=1;}//必然会执行一次，初始化min
          else
          {
            if (jilu[min].lenth > jilu[i].lenth)
              min=i;         
          }
        }
     }
     return min;//返回Vmin;
}
int no_s(int k)
{
  for (int i = 0; i <= si; ++i)
    if(s[i]==k)return 0;//点vk不再s[i]中
 return 1;
}









#include <iostream>
using namespace std;

//012345分别表示v0 v1......
int a[6][6]={
  {0,4,2,32767,32767,32767},
  {4,0,1,5,32767,32767},
  {2,1,0,8,10,32767},
  {32767,5,8,0,2,6},
  {32767,32767,10,2,0,3},
  {32767,32767,32767,6,3,0}
};
struct ll
{
  int lenth;
  char lujing[10];
};
int s[6]={32767,32767,32767,32767,32767,32767},si=0;//存放ok了的标记,si用来控制s数组的位置
int l[6]={32767,32767,32767,32767,32767,32767};//记录l【i】到v0的路长；
struct ll jilu[6];



int no_s_l_min();//不在s数组中的l数组中最小的点
int no_s(int k);//不在s数组中的
int main(int argc, char const *argv[])
{

  for(int i = 0; i < 6; ++i)
	{
	  jilu[i].lenth=32767;
	  for (int j = 0; j < 10; ++j)
	   jilu[i].lujing[j]='\0';
	}
  l[0]=0;//v0点进入，初始化
  jilu[0].lenth=0;
  jilu[0].lujing[0]='0';
  jilu[0].lujing[1]='\0';
  int u=0;//不属于s的并且l【u】最小的一个顶点

  while( no_s(5) )//v5不在s中
  {
    u=no_s_l_min();
    s[si++]=u;
    for (int i = 0; i < 6; ++i)
    {
       if (no_s(i) && a[u][i]<32767 && i!=u)
       {
         if (l[u]+a[u][i]<l[i])//lenth和路径将会改变
         {
            l[i]=l[u]+a[u][i];
            jilu[i].lenth=l[i];
            int j;
            for (j = 0; jilu[u].lujing[j] != '\0'; ++j)
                jilu[i].lujing[j]=jilu[u].lujing[j];

            jilu[i].lujing[j]=i+48;//变为i的字符
			jilu[i].lujing[j+1]='\0';
         }
       }
    }
  }

    for ( i = 0; i < 6; ++i)
      cout<<i<<"->"<<jilu[i].lujing<<"\n";
    


  return 0;
}

int no_s_l_min()//不再s数组中的l数组中最小的点
{
  int mark=0;
  int min;
     for (int i = 0; i < 6; ++i)
     {
       if(no_s(i) )//不在s数组里的点vi
        {
          if(mark==0){min=i;mark=1;}//必然会执行一次，初始化min
          else
          {
            if (l[min] > l[i])
              min=i;         
          }
        }
     }
     return min;//返回Vmin;
}
int no_s(int k)
{
  for (int i = 0; i <= si; ++i)
  {
    if(s[i]==k)return 0;//点vk不再s[i]中
  }
 return 1;
}