农夫、狼、羊、菜问题

【题目说明】一个农夫带着一只狼，牵着一只羊，挑着一担菜去赶集，前面有一条河拦住了他，河边有一艘船但船太小一次只能载农夫和他所带的其中一种东西，农夫知道狼会吃羊`羊也会吃他所带的菜要在都不被吃的情况下农夫怎么过去？

【思路】

如果用一个四元组(Farmer,Wolf,Sheep,Veget)表示当前农夫、狼、羊和菜所处的位置，其中每个元素可以是0或者1,0表示在左岸，1表示在右岸。这样对四个元素的不同取值可以构成16种不同的状态，初始时的状态为(0,0,0,0),最终要到达的目标为(1,1,1,1).状态之间可以转换有下面四种情况：

【程序代码】

#include <stdio.h>
#define VEX_NUM 10          //最大顶点数
typedef enum {FALSE, TRUE}  Boolean;
 
//定义图的顶点类型
typedef struct
{
   int Farmer, Wolf, Sheep, Veget;
}VexType;
 
typedef struct
{
   int vexnum, e;              //图当前顶点数和边数
   VexType vexs[VEX_NUM];      //顶点向量
   int adj[VEX_NUM][VEX_NUM];  //邻接矩阵
}AdjGraph;
 
Boolean visited[VEX_NUM];
int path[VEX_NUM];
 
//查找顶点(F, W, S, V)在顶点向量中的位置
int locate(AdjGraph * G, int F, int W, int S, int V)
{
   int i;
   for(i = 0; i < G->vexnum; i++)
       if(G->vexs[i].Farmer == F && G->vexs[i].Sheep == S && G->vexs[i].Veget == V && G->vexs[i].Wolf == W)
          return (i);
   return -1;
}
 
//判断状态(F, W, S, V)是否安全
int is_safe(int F, int W, int S, int V)
{
   if(F != S && (W == S || S == V))
       return 0;
   else
       return 1;
}
 
//检查第i个状态和第j个状态之间是否可以转换
int is_connected(AdjGraph * G, int i, int j)
{
   int k;
   k = 0;
   if(G->vexs[i].Wolf != G->vexs[j].Wolf)
       k++;
   if(G->vexs[i].Sheep != G->vexs[j].Sheep)
       k++;
   if(G->vexs[i].Veget != G->vexs[j].Veget)
       k++;
   if(G->vexs[i].Farmer != G->vexs[j].Farmer && k <= 1)
       return 1;
   else
       return 0;
}
 
//创建邻接矩阵
void CreateG(AdjGraph *G)
{
   int i, j, F, W, S, V;
   i = 0;
  
   //形成所有的安全结点
   for(F = 0; F <= 1; F++)
       for(W = 0; W <= 1; W++)
          for(S = 0; S <=1; S++)
              for(V = 0; V <= 1; V++)
                 if(is_safe(F, W, S, V))
                 {
                     G->vexs[i].Farmer = F;
                     G->vexs[i].Wolf = W;
                     G->vexs[i].Sheep = S;
                     G->vexs[i].Veget = V;
                     i++;
                 }
   G->vexnum = i;
   for(i = 0; i < G->vexnum; i++)
       for(j = 0; j < G->vexnum; j++)
          if(is_connected(G, i, j))
              G->adj[i][j] = G->adj[j][i] = 1;
          else
              G->adj[i][j] = G->adj[j][i] = 0;
   return;
}
 
//输出u到v的简单路径
void print_path(AdjGraph * G, int u, int v)
{
   int k;
   k = u;
   while(k != v)
   {
       printf("(%d,%d,%d,%d)
", G->vexs[k].Farmer, G->vexs[k].Wolf, G->vexs[k].Sheep, G->vexs[k].Veget);
       k = path[k];
   }
   printf("(%d,%d,%d,%d)
", G->vexs[k].Farmer, G->vexs[k].Wolf, G->vexs[k].Sheep, G->vexs[k].Veget);
}
 
//求u到v的简单路径
void DFS_path(AdjGraph* G, int u, int v)
{
   int j;
   visited[u] = TRUE;
   for(j = 0; j < G->vexnum; j++)
       if(G->adj[u][j] && !visited[j] && !visited[v])
       {
          path[u] = j;
          DFS_path(G, j, v);
       }
}
 
void main()
{
   int i, j;
   AdjGraph graph;
   CreateG(&graph);
   for(i = 0; i < graph.vexnum; i++)
       visited[i] = FALSE;
   i = locate(&graph, 0, 0, 0, 0);
   j = locate(&graph, 1, 1, 1, 1);
   DFS_path(&graph, i, j);
   if(visited[j])
       print_path(&graph, i, j);
  
   return;
}