【算法编程】过河问题

    今天偶尔想到了过河问题。记得读小学六年级的时候第一次接触到这个问题--六个老虎过河问题(百度上有具体介绍，本文解决的是一个简单的问题。下一篇文章中将讨论该问题)，当时都是从逻辑思维的方法得到正确的解决方法。本文介绍了普遍适用该类问题的方法以及该方法的改进方法，下一篇文章将介绍问题的变型及解法。

向量法（人、狗、鸡、米过河问题）

    问题描写叙述：某人带狗、鸡、米用船来过河。仅仅有人会划船(好像是废话，后面问题我们还会如果动物也会划船),另外至多还能载一物，当人不在时。狗要吃鸡(有人可能会质疑：狗吃鸡？。可是我看到的是狗和猫都吃小鸡)。鸡吃米。

问人、狗、鸡、米怎么过河？

    我们用一个向量来表示人、狗、鸡、米所处的状态。比如：(1 1 1 1)表示人、狗、鸡、米都在左岸，则相应的(0 0 0 0)表示人、狗、鸡、米都在右岸。这些向量我们称为状态向量，可是因为问题的条件限制，有些状态是同意的，而有些状态是不同意的。比如(0 1 1 1)表示人不在左岸。显然是不同意的。我们能够穷举出全部同意的状态：

        (1 1 1 1)        (0 0 0 0)    

        (1 1 1 0)        (0 0 0 1)

        (1 1 0 1)        (0 0 1 0)

        (1 0 1 1)        (0 1 0 0)

        (1 0 1 0)        (0 1 0 1)

从上面的同意状态中，我们能够发现规律例如以下：

    当人在时（也就是第一位为1时），不能有相邻的0，比如(1 1 0 0)是不同意的

    当人不在时(也就是第一个为0时)，不能有相邻的1 ，比如(0 1 1 0)是不同意的

    我们将船的一次运载也用向量表示，比如(1 1 0 0)表示人和狗在船上。

因为仅仅有人会划船，则同意的运算向量为：

        (1 1 0 0)        (1 0 1 0)        (1 0 0 1)        (1 0 0 0)

因此我们能够将一次过河过程看成是一个状态向量与一个运算向量的异或运算（模2加运算：1+1=0 1+0=1 0+0=0）。依据上述的向量法的描写叙述，我们能够将问题简化成：将状态(1 1 1 1)经过奇数次与运算向量运算，变成状态为(0 0 0 0)的状态转移过程。以下是过河的图解过程：

          開始状态                船上状态                 结果状态

 1       (1 1 1 1)    ------>    (1 0 1 0)     ------>     (0 1 0 1)

 2       (0 1 0 1)    ------>    (1 0 0 0)     ------>     (1 1 0 1)

 3       (1 1 0 1)    ------>    (1 0 0 1)     ------>     (0 1 0 0)

 4       (0 1 0 0)    ------>    (1 0 1 0)     ------>     (1 1 1 0)

 5       (1 1 1 0)    ------>    (1 1 0 0)     ------>     (0 0 1 0)

 6       (0 0 1 0)    ------>    (1 0 0 0)     ------>     (1 0 1 0)

 7       (1 0 1 0)    ------>    (1 0 1 0)     ------>     (0 0 0 0)  

奇数次：去河对岸

偶数次：回河这边

注意事项：

    在第3次过河时。開始状态为(1 1 0 1)。假设船上状态为(1 1 0 0),则结果状态为(0 0 0 1)，然后经过船上状态(1 0 0 1),结果状态为(1 0 0 0),然后经过船上状态(1 0 0 0)。就能够完毕任务(总共5次过河)。

可是这里存在问题：当開始状态为(0 0 0 1)，船上状态不可能为(1 0 0 1)。由于開始状态(0 0 0 1)表示仅仅有米在左岸。船上状态(1 0 0 1)表示人和米在船上，这是不可能的！因此船上状态的选择是有限制的。奇数时，開始状态为1的位置。船上相应位置才干够为1；偶数时。開始状态为0的位置。船上相应的位置才干够为0.通俗的说：奇数时，是将有的东西运到河对岸。偶数时，是将河对岸的东西(河这边没有)运到河这边。这些数学的表述可能太麻烦，我举例说明：奇数时，当河这边仅仅有人、狗、米，我们能够从选择人、狗上船或则人、米上船，而不能选择人、鸡上船（鸡在对岸）;当偶数次数时。河这边是狗、河对岸则是人、鸡、米，我们能够人、鸡或则人、米回到河这边，而不能选择人、狗过河。

算法实现：

    上面的实现可用matlab或则c来实现。若用matlab来实现。则那些状态向量以及状态间的异或运算比較easy表示；若用c来实现，则用时较短。两者的难点在于注意事项中的船上变量的选取问题。因此这样的方法不适合用计算机实现。在状态变量较少的情况下，我们能够直接用手工进行运算的方法来得到结果(大家能够试试)。

改进型算法---图论法

    算法思路：将10个状态向量用10个点表示。将这10个状态向量分别与可行的运算向量进行运算。假设结果向量仍为同意的状态向量。则两者间连一条线，从而构成了一个图的问题。

我们的目标是找到一条能够从状态(1 1 1 1)到状态(0 0 0 0)的通路。

以下是我运算得到的图:

注意：图中的标号用于表示相应的状态

详细算法实现例如以下：

1、Dijkstra算法

#include<stdio.h>
#define M 20//边数
#define N 10//顶点数
#define MAX 10000
void Dijkstra(int v, int dist[][N],int D[N],int p[N],int s[N]) ;
int flag[N]={0};
int flag1=0;
int flag2=0;
typedef struct
{
    int startvex;
    int endvex;
    int length;
}edge;//边的结构体
edge T[M];
void main()
{
    int dist[N][N]={{0,MAX,MAX,MAX,MAX,1,MAX,MAX,MAX,MAX},//图的邻接矩阵
                    {MAX,0,MAX,MAX,MAX,MAX,1,1,MAX,MAX},
                    {MAX,MAX,0,MAX,MAX,1,1,MAX,1,MAX},
                    {MAX,MAX,MAX,0,MAX,MAX,MAX,1,1,MAX},
                    {MAX,MAX,MAX,MAX,0,MAX,MAX,1,MAX,1},
                    {1,MAX,1,MAX,MAX,0,MAX,MAX,MAX,MAX},
                    {MAX,1,1,MAX,MAX,MAX,0,MAX,MAX,MAX},
                    {MAX,1,MAX,1,1,MAX,MAX,0,MAX,MAX},
                    {MAX,MAX,1,1,MAX,MAX,MAX,MAX,0,MAX},
                    {MAX,MAX,MAX,MAX,1,MAX,MAX,MAX,MAX,0}
    };
    int D[N]={0};
    int p[N]={0};
    int s[N]={0};
    int num=0;
    Dijkstra(0,dist,D, p,s) ;//0表示从状态(1111)開始
}
 void Dijkstra(int v, int dist[][N],int D[N],int p[N],int s[N]) 
 {     int i, j, k, v1, min, max=10000, pre;     /* Max中的值用以表示dist矩阵中的值*/
    v1=v; 
    for( i=0; i<N; i++)              /* 各数组进行初始化*/
    {    D[i]=dist[v1][i]; 
        if( D[i] != MAX )  p[i]= v1+1; 
        else p[i]=0; 
        s[i]=0; 
    }
    s[v1]=1;                          /* 将源点送U */
      for( i=0; i<N-1; i++)      /* 求源点到其余顶点的最短距离*/
    {    min=10001;    /* min>max, 以保证值为的的的的顶顶顶顶点点点点也也也也能能能能加加加增加入入入U */
        for( j=0; j<N-1; j++)
              if ( ( !s[j] )&&(D[j]<min) )          /* 找出到源点具有最短距离的边*/
                  {min=D[j]; 
                        k=j; 
                     }
                s[k]=1;  /* 将找到的顶点k送入U */    
    for(j=0; j<N; j++)
     if ( (!s[j])&&(D[j]>D[k]+dist[k][j]) ) /* 调整V－U中各顶点的距离值*/
        {D[j]=D[k]+dist[k][j]; 
        p[j]=k+1;                      /* k是j的前趋*/
                }
            }                               /*  全部顶点已扩充到U中*/
            for( i=0; i<N; i++)
            {
                printf(" %d : %d ", D[i], i);
                pre=p[i]; 
            while ((pre!=0)&&(pre!=v+1))
            {    printf ("<- %d ", pre-1); 
                pre=p[pre-1]; 
            }
            printf("<-%d 
", v); 
        }
}     

结果显演示样例如以下：

从上图的第七行可知。从标号为1的状态到标号为10的状态所要经过的过程为(数组下标是从0開始的)：

    1---6---3---7---2---8---5---10

    

2、通过每对顶点之间的最短路径算法实现：

#include<stdio.h>
#define N 10 //顶点个数
#define MAX 10000
void Floyd(int dist[N][N],int A[N][N],int path[N][N])
{
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
            for(int k=0;k<N;k++)
            {
                /*if(A[i][j]>(A[i][k]+dist[k][j]))//方法一：计算每一次矩阵
                {
                    A[i][j]=(A[i][k]+dist[k][j]);
                    path[i][j]=path[k][j];
                }*/
                if(A[i][j]>(A[i][k]+A[k][j]))//方法二:计算的幂次矩阵
                {
                    A[i][j]=(A[i][k]+A[k][j]);
                    path[i][j]=path[k][j];
                }
            }
}
void main()
{
    int dist[N][N]={{0,MAX,MAX,MAX,MAX,1,MAX,MAX,MAX,MAX},//图的邻接矩阵
                    {MAX,0,MAX,MAX,MAX,MAX,1,1,MAX,MAX},
                    {MAX,MAX,0,MAX,MAX,1,1,MAX,1,MAX},
                    {MAX,MAX,MAX,0,MAX,MAX,MAX,1,1,MAX},
                    {MAX,MAX,MAX,MAX,0,MAX,MAX,1,MAX,1},
                    {1,MAX,1,MAX,MAX,0,MAX,MAX,MAX,MAX},
                    {MAX,1,1,MAX,MAX,MAX,0,MAX,MAX,MAX},
                    {MAX,1,MAX,1,1,MAX,MAX,0,MAX,MAX},
                    {MAX,MAX,1,1,MAX,MAX,MAX,MAX,0,MAX},
                    {MAX,MAX,MAX,MAX,1,MAX,MAX,MAX,MAX,0}
    };
    int A[N][N];
    int path[N][N]={0};//给出两顶点间的路径
    int pre=0;
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
        {
            A[i][j]=dist[i][j];
            if(dist[i][j]!=MAX)
                path[i][j]=i+1;
            else
                path[i][j]=0;
        }
    
    for(int k=0;k<7;k++)//若用方法一，需循环N-3次，若用方法二。须要循环lg(N-1)次
        Floyd(dist,A,path);
    printf("每对顶点间的最短路径矩阵为：
");
    for(int i=0;i<N;i++)
    {
        for(int j=0;j<N;j++)
            printf("%d ",A[i][j]);
        printf("
");
    }
    printf("
每对顶点的详细最短路径为：
");
    
    for(int i=0;i<N;i++)
    {
        for(int j=0;j<N;j++)
        {
            printf("%d: %d ",A[i][j],j+1);
        pre=path[i][j];
        while((pre!=0)&&(pre!=i+1))
        {
            printf("<- %d ",pre);
            pre=path[i][pre-1];
        }
        printf(" <- %d
",i+1);
        }
    }
}

结果显演示样例如以下：

从上图的最短路径矩阵的第一行第10列可知，从状态1到状态10须要7步，从详细最短路径的第10行可知。所要经过的过程为：

    1---6---3---7---2---8---5---10

两种方法求得的结果同样，我们能够用图形象的表演示样例如以下：

通过对照能够发现，图论法实质是在向量法的基础上进行改进的算法，不管是在手动计算还是计算机实现上都比向量法更好。

原文：http://blog.csdn.net/tengweitw/article/details/25296257

作者：nineheadedbird