波瓦松分酒问题的分析

最新推荐文章于 2023-01-09 09:40:53 发布

噶西摩多

最新推荐文章于 2023-01-09 09:40:53 发布

阅读量756

点赞数

分类专栏： C语言

C语言专栏收录该内容

17 篇文章 0 订阅

订阅专栏

由于可行路径比较多（共121种），建议将结果输出的文本文件查看。

<pre name="code" class="cpp">#include <stdio.h>

typedef int BOOL;
#define TRUE    1
#define FALSE    0

typedef char byte;
typedef struct //该结构体定义了状态结点，包含3个容器。使用中它们的值表示当时3个容器中液体的体积。
{
    byte bottle12;
    byte bottle8;
    byte bottle5;
}STATE;

int times = 0;

//以下move系列的6个函数表示6种不同的液体转移方式。参数from是转移前的状态，to是转移后的状态。由于函数的返回值用来返回执行状态了，所以转移后状态采用指针来传递返回。

BOOL move12to8(STATE from, STATE * to) 
{
    if(from.bottle12 == 0 || from.bottle8 == 8)
        return FALSE;
    if(from.bottle12 > 8 - from.bottle8)
    {
        to->bottle12 = from.bottle12 - (8 - from.bottle8);
        to->bottle8 = 8;
    }
    else
    {
        to->bottle12 = 0;
        to->bottle8 = from.bottle8 + from.bottle12;
    }
    to->bottle5 = from.bottle5;
    return TRUE;
}

BOOL move12to5(STATE from, STATE * to)
{
    if(from.bottle12 == 0 || from.bottle5 == 5)
        return FALSE;
    if(from.bottle12 > 5 - from.bottle5)
    {
        to->bottle12 = from.bottle12 - (5 - from.bottle5);
        to->bottle5 = 5;
    }
    else
    {
        to->bottle12 = 0;
        to->bottle5 = from.bottle5 + from.bottle12;
    }
    to->bottle8 = from.bottle8;
    return TRUE;
}

BOOL move8to12(STATE from, STATE * to)
{
    if(from.bottle8 == 0 || from.bottle12 == 12) return FALSE;
    if(from.bottle8 > 12 - from.bottle12)
    {
        to->bottle8 = from.bottle8 - (12 - from.bottle12);
        to->bottle12 = 12;
    }
    else
    {
        to->bottle8 = 0;
        to->bottle12 = from.bottle12 + from.bottle8;
    }
    to->bottle5 = from.bottle5;
    return TRUE;
}

BOOL move8to5(STATE from, STATE * to)
{
    if(from.bottle8 == 0 || from.bottle5 == 5) return FALSE;
    if(from.bottle8 > 5 - from.bottle5)
    {
        to->bottle8 = from.bottle8 - (5 - from.bottle5);
        to->bottle5 = 5;
    }
    else
    {
        to->bottle8 = 0;
        to->bottle5 = from.bottle5 + from.bottle8;
    }
    to->bottle12 = from.bottle12;
    return TRUE;
}

BOOL move5to12(STATE from, STATE * to)
{
    if(from.bottle5 == 0 || from.bottle12 == 12) return FALSE;
    if(from.bottle5 > 12 - from.bottle12)
    {
        to->bottle5 = from.bottle5 - (12 - from.bottle12);
        to->bottle12 = 12;
    }
    else
    {
        to->bottle5 = 0;
        to->bottle12 = from.bottle5 + from.bottle12;
    }
    to->bottle8 = from.bottle8;
    return TRUE;
}

BOOL move5to8(STATE from, STATE * to)
{
    if(from.bottle5 == 0 || from.bottle8 == 8) return FALSE;
    if(from.bottle5 > 8 - from.bottle8)
    {
        to->bottle5 = from.bottle5 - (8 - from.bottle8);
        to->bottle8 = 8;
    }
    else
    {
        to->bottle5 = 0;
        to->bottle8 = from.bottle5 + from.bottle8;
    }
    to->bottle12 = from.bottle12;
    return TRUE;
}

BOOL equal(STATE s1, STATE s2) //判断两个状态是否相等
{
    if(s1.bottle12 != s2.bottle12) return FALSE;
    if(s1.bottle8 != s2.bottle8) return FALSE;
    if(s1.bottle5 != s2.bottle5) return FALSE;
    return TRUE;
}

BOOL contain(STATE s, STATE * path, int pathLength) //判断在path路径集合中是否包含了状态s。
{
    int i;
    for(i = 0; i < pathLength; i++)
    {
        if(equal(s, path[i]))
            return TRUE;
    }
    return FALSE;
}

void output(STATE * path, int pathLength) //输出一条路径（分酒方式）
{ FILE *fp;
char tong[30];

	fp=fopen("(tong).txt","at+" );
	if(fp==NULL)
	{
		printf("cannot open file\n");
		return;
	}
     int i;
	++times;
 
    fprintf(fp,"%d:\n", times);
    for(i = 0; i < pathLength; i++)
    {	
		printf("%2d:[%2d][%2d][%2d]\n", i, path[i].bottle12, path[i].bottle8, path[i].bottle5);
        fprintf(fp,"%2d:[%2d][%2d][%2d]\n", i, path[i].bottle12, path[i].bottle8, path[i].bottle5);
    }
	printf("保存完毕!\n");
     fclose(fp);
}

void search(STATE start, STATE end, STATE * path, int pathLength) //递归遍历所有的路径
{
    STATE temp;

    path[pathLength] = start;
    pathLength++;
    
    if(equal(start, end))
        output(path, pathLength);
    
    if(move12to8(start, &temp) && !contain(temp, path, pathLength))
        search(temp, end, path, pathLength);
    if(move12to5(start, &temp) && !contain(temp, path, pathLength))
        search(temp, end, path, pathLength);
    if(move8to12(start, &temp) && !contain(temp, path, pathLength))
        search(temp, end, path, pathLength);
    if(move8to5(start, &temp) && !contain(temp, path, pathLength))
        search(temp, end, path, pathLength);
    if(move5to12(start, &temp) && !contain(temp, path, pathLength))
        search(temp, end, path, pathLength);
    if(move5to8(start, &temp) && !contain(temp, path, pathLength))
        search(temp, end, path, pathLength);
}

int main()
{
    STATE path[14 * 13 / 2];
	STATE a1={12, 0, 0};
STATE a2={6, 6, 0};
    search(a1, a2, path, 0);

    return 0;
}

我们只关心最优解

#include <stdio.h>

typedef int BOOL;
#define TRUE    1
#define FALSE    0

typedef char byte;
typedef struct
{
    byte bottle12;
    byte bottle8;
    byte bottle5;
}STATE;

BOOL move12to8(STATE from, STATE * to)
{
    if(from.bottle12 == 0 || from.bottle8 == 8)
        return FALSE;
    if(from.bottle12 > 8 - from.bottle8)
    {
        to->bottle12 = from.bottle12 - (8 - from.bottle8);
        to->bottle8 = 8;
    }
    else
    {
        to->bottle12 = 0;
        to->bottle8 = from.bottle8 + from.bottle12;
    }
    to->bottle5 = from.bottle5;
    return TRUE;
}

BOOL move12to5(STATE from, STATE * to)
{
    if(from.bottle12 == 0 || from.bottle5 == 5)
        return FALSE;
    if(from.bottle12 > 5 - from.bottle5)
    {
        to->bottle12 = from.bottle12 - (5 - from.bottle5);
        to->bottle5 = 5;
    }
    else
    {
        to->bottle12 = 0;
        to->bottle5 = from.bottle5 + from.bottle12;
    }
    to->bottle8 = from.bottle8;
    return TRUE;
}

BOOL move8to12(STATE from, STATE * to)
{
    if(from.bottle8 == 0 || from.bottle12 == 12) return FALSE;
    if(from.bottle8 > 12 - from.bottle12)
    {
        to->bottle8 = from.bottle8 - (12 - from.bottle12);
        to->bottle12 = 12;
    }
    else
    {
        to->bottle8 = 0;
        to->bottle12 = from.bottle12 + from.bottle8;
    }
    to->bottle5 = from.bottle5;
    return TRUE;
}

BOOL move8to5(STATE from, STATE * to)
{
    if(from.bottle8 == 0 || from.bottle5 == 5) return FALSE;
    if(from.bottle8 > 5 - from.bottle5)
    {
        to->bottle8 = from.bottle8 - (5 - from.bottle5);
        to->bottle5 = 5;
    }
    else
    {
        to->bottle8 = 0;
        to->bottle5 = from.bottle5 + from.bottle8;
    }
    to->bottle12 = from.bottle12;
    return TRUE;
}

BOOL move5to12(STATE from, STATE * to)
{
    if(from.bottle5 == 0 || from.bottle12 == 12) return FALSE;
    if(from.bottle5 > 12 - from.bottle12)
    {
        to->bottle5 = from.bottle5 - (12 - from.bottle12);
        to->bottle12 = 12;
    }
    else
    {
        to->bottle5 = 0;
        to->bottle12 = from.bottle5 + from.bottle12;
    }
    to->bottle8 = from.bottle8;
    return TRUE;
}

BOOL move5to8(STATE from, STATE * to)
{
    if(from.bottle5 == 0 || from.bottle8 == 8) return FALSE;
    if(from.bottle5 > 8 - from.bottle8)
    {
        to->bottle5 = from.bottle5 - (8 - from.bottle8);
        to->bottle8 = 8;
    }
    else
    {
        to->bottle5 = 0;
        to->bottle8 = from.bottle5 + from.bottle8;
    }
    to->bottle12 = from.bottle12;
    return TRUE;
}

BOOL equal(STATE s1, STATE s2)
{
    if(s1.bottle12 != s2.bottle12) return FALSE;
    if(s1.bottle8 != s2.bottle8) return FALSE;
    if(s1.bottle5 != s2.bottle5) return FALSE;
    return TRUE;
}

BOOL contain(STATE s, STATE * path, int pathLength)
{
    int i;
    for(i = 0; i < pathLength; i++)
    {
        if(equal(s, path[i]))
            return TRUE;
    }
    return FALSE;
}

void output(STATE * path, int pathLength)
{
    int i;
    for(i = pathLength - 1; i >= 0; i--)
    {
        printf("%2d:[%2d][%2d][%2d]\n", pathLength - i - 1, path[i].bottle12, path[i].bottle8, path[i].bottle5);
    }
    puts("");
}

void search(STATE start, STATE end)
{
    STATE path[14 * 13 / 2];
    STATE listState[14 * 13 / 2];
    STATE temp;
    int mapPreIndex[14 * 13 / 2] = {0};
    int listLength, i, j;
    
    listState[0] = start;
    listLength = 1;
    
    for(i = 0; i < listLength; i++)
    {
        if(move12to8(listState[i], &temp) && !contain(temp, listState, listLength))
        {
            listState[listLength] = temp;
            mapPreIndex[listLength] = i;
            listLength++;
            if(equal(temp, end)) break;
        }
        if(move12to5(listState[i], &temp) && !contain(temp, listState, listLength))
        {
            listState[listLength] = temp;
            mapPreIndex[listLength] = i;
            listLength++;
            if(equal(temp, end)) break;
        }
        if(move8to12(listState[i], &temp) && !contain(temp, listState, listLength))
        {
            listState[listLength] = temp;
            mapPreIndex[listLength] = i;
            listLength++;
            if(equal(temp, end)) break;
        }
        if(move8to5(listState[i], &temp) && !contain(temp, listState, listLength))
        {
            listState[listLength] = temp;
            mapPreIndex[listLength] = i;
            listLength++;
            if(equal(temp, end)) break;
        }
        if(move5to12(listState[i], &temp) && !contain(temp, listState, listLength))
        {
            listState[listLength] = temp;
            mapPreIndex[listLength] = i;
            listLength++;
            if(equal(temp, end)) break;
        }
        if(move5to8(listState[i], &temp) && !contain(temp, listState, listLength))
        {
            listState[listLength] = temp;
            mapPreIndex[listLength] = i;
            listLength++;
            if(equal(temp, end)) break;
        }
    }

    if(equal(listState[listLength - 1], end))
    {
        i = listLength - 1;
        for(j = 0; i > 0; j++)
        {
            path[j] = listState[i];
            i = mapPreIndex[i];
        }
        path[j++] = listState[0];
        output(path, j);
    }
}

int main()
{
    search((STATE){12, 0, 0}, (STATE){6, 6, 0});
    return 0;
}