青蛙跳跃对调位置游戏的穷举解决算法

　　游戏在这里，让左边的青蛙和右边的青蛙对调位置。左边和右边各有三只青蛙，中心处有一个空位。每次可以跳一个青蛙，要么向前跳一格，要么跨过前方的青蛙跳一格，青蛙不能重叠，不能往回跳。

　　下面是解决该问题的穷举算法实现，算法已扩展到左边有任意只青蛙、右边有任意只青蛙、中间有任意个空位的情形：

lr4.h

#ifndef _LR4_H
#define _LR4_H

#ifdef __cplusplus
extern "C" {
#endif

int Resolve(int left, int blank, int right, int **ppMaps, int **ppMeds, int *pCount);

#ifdef __cplusplus
};
#endif

#endif

lr4.c

#include <stdio.h>
#include <memory.h>
#include <malloc.h>

typedef int BOOL;

#define TRUE  1
#define FALSE 0

BOOL IsEqualMap(const int *pMap1, const int *pMap2, int total)
{
    return memcmp(pMap1, pMap2, total * sizeof(int)) == 0;
}

void InitBeginTailMap(int left, int blank, int right, int *pBeginMap, int *pTailMap)
{
    int index;

    pTailMap += left + blank + right - 1;

    for(index = 0; index < left; index += 1)
    {
        *pBeginMap++ = *pTailMap-- = -1;
    }

    for(index = 0; index < blank; index += 1)
    {
        *pBeginMap++ = *pTailMap-- = 0;
    }

    for(index = 0; index < right; index += 1)
    {
        *pBeginMap++ = *pTailMap-- = 1;
    }
}

BOOL GetNextMap(const int *pCurrentMap, int *pNextMap, int med, int total)
{
    if(pCurrentMap[med] != 0)
    {
        int med1 = med - pCurrentMap[med];
        int med2 = med1 - pCurrentMap[med];

        memcpy(pNextMap, pCurrentMap, total * sizeof(int));

        if(pNextMap[med] == 1)
        {
            if(med1 >= 0 && pNextMap[med1] == 0)
            {
                pNextMap[med1] = pNextMap[med];
                pNextMap[med] = 0;

                return TRUE;
            }
            else if(med2 >= 0 && pNextMap[med2] == 0)
            {
                pNextMap[med2] = pNextMap[med];
                pNextMap[med] = 0;

                return TRUE;
            }
        }
        else
        {
            if(med1 < total && pNextMap[med1] == 0)
            {
                pNextMap[med1] = pNextMap[med];
                pNextMap[med] = 0;

                return TRUE;
            }
            else if(med2 < total && pNextMap[med2] == 0)
            {
                pNextMap[med2] = pNextMap[med];
                pNextMap[med] = 0;

                return TRUE;
            }
        }
    }

    return FALSE;
}

int Resolve(int left, int blank, int right, int **ppMaps, int **ppMeds, int *pCount)
{
    BOOL result = FALSE;
    int total = left + blank + right;
    int *pEndMap = (int *)malloc(total * sizeof(int));
    int count = 0;

    *ppMaps = NULL;
    *ppMeds = NULL;

    *ppMaps = (int *)realloc(*ppMaps, (count + 1) * total * sizeof(int));
    *ppMeds = (int *)realloc(*ppMeds, (count + 1) * sizeof(int));

    if(pEndMap == NULL || *ppMaps == NULL || *ppMeds == NULL)
    {
        return FALSE;
    }

    InitBeginTailMap(left, blank, right, ppMaps[0], pEndMap);
    **ppMeds = -1;
    count = 1;

    while(TRUE)
    {
        if(count == 0)
        {
            break;
        }

        if(IsEqualMap(*ppMaps + (count - 1) * total, pEndMap, total))
        {
            result = TRUE;
            break;
        }

        (*ppMeds)[count - 1] += 1;

        if((*ppMeds)[count - 1] >= total)
        {
            count -= 1;
        }
        else
        {
            *ppMaps = (int *)realloc(*ppMaps, (count + 1) * total * sizeof(int));
            *ppMeds = (int *)realloc(*ppMeds, (count + 1) * sizeof(int));

            if(*ppMaps == NULL || *ppMeds == NULL)
            {
                break;
            }

            if(GetNextMap(*ppMaps + (count - 1) * total, *ppMaps + count * total, (*ppMeds)[count - 1], total))
            {
                (*ppMeds)[count] = -1;

                count += 1;
            }
        }
    }

    if(!result)
    {
        if(*ppMaps != NULL)
        {
            free(*ppMaps);
        }

        if(*ppMeds != NULL)
        {
            free(*ppMeds);
        }
    }

    *pCount = count;

    return result;
}

main.c

 

#include <stdio.h>
#include "lr4.h"

int main()
{
    int *pMaps, *pMeds, count;
    int left = 4;
    int blank = 2;
    int right = 4;

    if(Resolve(left, blank, right, &pMaps, &pMeds, &count))
    {
        int total = left + blank + right;
        int index, index2;

        for(index = 0; index < count; index += 1)
        {
            if(index == 0)
            {
                printf("初始状态局面：");
            }
            else
            {
                printf("第%2d步后局面：", index);
            }

            for(index2 = 0; index2 < total; index2 += 1)
            {
                printf("%3d", pMaps[index * total + index2]);
            }

            if(index != count - 1)
            {
                printf(" 跳左起第%d个青蛙\n", pMeds[index] + 1);
            }
        }

        printf("\n");

        free(pMeds);
        free(pMaps);
    }

    return 0;
}

 

示例输出：

左右各三只青蛙，中间一个空位的情形：

初始状态局面： -1 -1 -1 0 1 1 1 跳左起第3个青蛙
第 1步后局面： -1 -1 0 -1 1 1 1 跳左起第5个青蛙
第 2步后局面： -1 -1 1 -1 0 1 1 跳左起第6个青蛙
第 3步后局面： -1 -1 1 -1 1 0 1 跳左起第4个青蛙
第 4步后局面： -1 -1 1 0 1 -1 1 跳左起第2个青蛙
第 5步后局面： -1 0 1 -1 1 -1 1 跳左起第1个青蛙
第 6步后局面： 0 -1 1 -1 1 -1 1 跳左起第3个青蛙
第 7步后局面： 1 -1 0 -1 1 -1 1 跳左起第5个青蛙
第 8步后局面： 1 -1 1 -1 0 -1 1 跳左起第7个青蛙
第 9步后局面： 1 -1 1 -1 1 -1 0 跳左起第6个青蛙
第10步后局面： 1 -1 1 -1 1 0 -1 跳左起第4个青蛙
第11步后局面： 1 -1 1 0 1 -1 -1 跳左起第2个青蛙
第12步后局面： 1 0 1 -1 1 -1 -1 跳左起第3个青蛙
第13步后局面： 1 1 0 -1 1 -1 -1 跳左起第5个青蛙
第14步后局面： 1 1 1 -1 0 -1 -1 跳左起第4个青蛙
第15步后局面： 1 1 1 0 -1 -1 -1

 

左右各四个青蛙，中间两个空位的情形：

初始状态局面： -1 -1 -1 -1 0 0 1 1 1 1 跳左起第3个青蛙
第 1步后局面： -1 -1 0 -1 -1 0 1 1 1 1 跳左起第1个青蛙
第 2步后局面： 0 -1 -1 -1 -1 0 1 1 1 1 跳左起第5个青蛙
第 3步后局面： 0 -1 -1 -1 0 -1 1 1 1 1 跳左起第7个青蛙
第 4步后局面： 0 -1 -1 -1 1 -1 0 1 1 1 跳左起第8个青蛙
第 5步后局面： 0 -1 -1 -1 1 -1 1 0 1 1 跳左起第6个青蛙
第 6步后局面： 0 -1 -1 -1 1 0 1 -1 1 1 跳左起第4个青蛙
第 7步后局面： 0 -1 -1 0 1 -1 1 -1 1 1 跳左起第3个青蛙
第 8步后局面： 0 -1 0 -1 1 -1 1 -1 1 1 跳左起第5个青蛙
第 9步后局面： 0 -1 1 -1 0 -1 1 -1 1 1 跳左起第3个青蛙
第10步后局面： 1 -1 0 -1 0 -1 1 -1 1 1 跳左起第2个青蛙
第11步后局面： 1 0 -1 -1 0 -1 1 -1 1 1 跳左起第7个青蛙
第12步后局面： 1 0 -1 -1 1 -1 0 -1 1 1 跳左起第9个青蛙
第13步后局面： 1 0 -1 -1 1 -1 1 -1 0 1 跳左起第10个青蛙
第14步后局面： 1 0 -1 -1 1 -1 1 -1 1 0 跳左起第8个青蛙
第15步后局面： 1 0 -1 -1 1 -1 1 0 1 -1 跳左起第6个青蛙
第16步后局面： 1 0 -1 -1 1 0 1 -1 1 -1 跳左起第4个青蛙
第17步后局面： 1 0 -1 0 1 -1 1 -1 1 -1 跳左起第3个青蛙
第18步后局面： 1 0 0 -1 1 -1 1 -1 1 -1 跳左起第5个青蛙
第19步后局面： 1 0 1 -1 0 -1 1 -1 1 -1 跳左起第3个青蛙
第20步后局面： 1 1 0 -1 0 -1 1 -1 1 -1 跳左起第7个青蛙
第21步后局面： 1 1 0 -1 1 -1 0 -1 1 -1 跳左起第5个青蛙
第22步后局面： 1 1 1 -1 0 -1 0 -1 1 -1 跳左起第4个青蛙
第23步后局面： 1 1 1 0 -1 -1 0 -1 1 -1 跳左起第9个青蛙
第24步后局面： 1 1 1 0 -1 -1 1 -1 0 -1 跳左起第8个青蛙
第25步后局面： 1 1 1 0 -1 -1 1 0 -1 -1 跳左起第6个青蛙
第26步后局面： 1 1 1 0 -1 0 1 -1 -1 -1 跳左起第5个青蛙
第27步后局面： 1 1 1 0 0 -1 1 -1 -1 -1 跳左起第7个青蛙
第28步后局面： 1 1 1 0 1 -1 0 -1 -1 -1 跳左起第5个青蛙
第29步后局面： 1 1 1 1 0 -1 0 -1 -1 -1 跳左起第6个青蛙
第30步后局面： 1 1 1 1 0 0 -1 -1 -1 -1