Java 蛮力蛙跳游戏

蛙跳的最后一个变化显示在本章末尾

简言之，你有n个百合花垫排成一行，一只青蛙站在树上 每一个

在最后一个变体中（我想使用暴力），第二个 第一个和第二个最后的百合花垫没有青蛙。你的目标是 把所有的青蛙放在同一个睡莲垫上。每只青蛙都能左右跳 根据它的睡莲垫上青蛙的数量，但不能跳上一只 空百合花垫。
（带1只青蛙的垫块移动1个点，带n只青蛙的垫块仅移动n个点）

n=12的解决方案示例：（12以下没有解决方案）

[1,0,1,1,1,1,1,1,1,1,1,0,1]-青蛙的开始形成。（计算） 青蛙从0到11。）
[1,0,1,0,2,1,1,1,1,1,1,1,0,1]-青蛙3。跳 右
[1,0,1,0,2,1,2,0,1,1,0,1]-青蛙7。向左跳
[1,0,1,0,4,1,0,0,1,1,0,1]-青蛙6。向左跳
[5,0,1,0,0,1,0,0,1,1,0,1]-青蛙4。向左跳
[0,0,1,0,0,6,0,0,1,1,0,1]-青蛙0。向右跳
[0,0,1,0,0,0,0,0,1,1,0,7]-青蛙5。向右跳
[0,0,1,0,0,0,0,0,0,2,0,7]-青蛙8。向右跳
[0,0,1,0,0,0,0,0,0,0,0,9]-青蛙9。向右跳
[0,0,10,0,0,0,0,0,0,0,0]-青蛙11。向左跳-已解决

我想找到n只青蛙的解决方案，如果存在解决方案。我手工知道12,14,15,16,17,18,19,20至少有一个解决方案，而1-11和13没有解决方案

我试着编写一段代码，它将运行所有的组合，以找到nlily pads的解决方案

编辑：由于添加了日志记录，代码现在可以工作了

import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;

// # Brute Force # Brute Force # Brute Force # Brute Force # Brute Force # //
public class Frogger {

    /** 
     * PUBLIC STATIC GLOBAL VARIABLES - Modify these as you wish.
     * 
     * Time Data: Levels < 20 ~ around couple seconds
     *            Level = 20 ~ around a minute
     *            Level = 21 ~ around a quarter of an hour
     *            Level = 22 ~ around a sixth of a minute
     *            Level = 23 ~ around half an hour
     *            Level = 24 ~ around a minute
     * 
     * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
        public static int Level = 12;
        public static boolean LogSolution = true;
        public static boolean LogAll = false;
    /** * * * * * * * * * * * * * * * * * * * * * * * * * * * */

    // used for logging
    private static Deque<Jump> solution = new ArrayDeque<>(Level);
    private static double time;

    public static void main(String[] args) {

        // log the time
        time = System.currentTimeMillis();

        // build the world & start jumping
        run(Level);
    }

    public static void run(int n) {

        // create the world
        int[] world = new int[n];
        for (int i = 0; i < n; i++) {
            world[i] = 1;
        }
        world[1] = 0;
        world[n-2] = 0;

        // start jumping
        if (Level > 11 && Level != 13) jump(world);
        else System.out.println("Unsolvable");
    }


    //////////////////////////////////////////////////////

    public static void jump(int[] world) {

    for (int i = 0; i < world.length; i++) {

        if (world[i] != 0) { // pad has a frog

            // check if it is solved at current pad
            if (world[i] == Level - 2) {
                System.out.println("SOLUTION: " + Arrays.toString(world));
                System.out.println(solution);
                System.out.println("\n" + (System.currentTimeMillis() - time) / 1000 + " seconds");
                System.exit(0);
            }   

            // roll-back var
            int temp = 0;

            // attempts to make a RIGHT jump 

                if (world[i] + i < world.length) { // right jump is in bound
                    if (world[i + world[i]]  != 0) { // can't jump on empty pad

                        temp = world[i];

                        // jump RIGHT
                        world[i + world[i]] += world[i];
                        world[i] = 0;

                        solution.push(new Jump(temp, i, i + temp)); // log the solution step 1/2
                        if (LogSolution) if (LogAll) System.out.println( "J: " + Arrays.toString(world)); // log the jump

                        // continue jumping
                        jump(world); 

                        // roll-back right jump
                        world[i] = temp;
                        world[i + world[i]] -= world[i];

                        if (LogAll) System.out.println("R: " + Arrays.toString(world)); // log the rollback
                        if (LogSolution) solution.pop(); // log the solution step 2/2
                    }
                }   

            // attempts to make a LEFT jump 

                if (i - world[i] >= 0) { // left jump is in bound
                    if (world[i - world[i]]  != 0) { // can't jump on empty pad

                        temp = world[i];

                        // jump LEFT
                        world[i - world[i]] += world[i];
                        world[i] = 0;

                        if (LogSolution) solution.push(new Jump(temp, i, i - temp)); // log the solution step 1/2
                        if (LogAll) System.out.println("J:" + Arrays.toString(world)); // log the jump

                        // continue jumping
                        jump(world); 

                        // roll-back left jump
                        world[i] = temp;
                        world[i - world[i]] -= world[i];

                        if (LogAll) System.out.println("R: " + Arrays.toString(world)); // log the rollback
                        if (LogSolution) solution.pop(); // log the solution step 2/2
                    }
                }
        }
    }
    }

}

import java.util.ArrayDeque；
导入java.util.array；
导入java.util.Deque；
//#蛮力#蛮力#蛮力#蛮力#蛮力#蛮力#//
公营蛙人{
/** 
*公共静态全局变量-根据需要修改这些变量。
* 
*时间数据：水平<20~大约几秒钟
*液位=20~1分钟左右
*液位=21~大约一刻钟
*液位=22~大约六分之一分钟
*标高=23~约半小时
*液位=24~1分钟左右
* 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
公共静态int级别=12；
公共静态布尔LogSolution=true；
公共静态布尔LogAll=false；
/** * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//用于记录
专用静态Deque解决方案=新的ArrayDeque（级别）；
私有静态双时间；
公共静态void main（字符串[]args）{
//记录时间
时间=System.currentTimeMillis（）；
//创造世界&开始跳跃
运行（水平）；
}
公共静态无效运行（int n）{
//创造世界
int[]世界=新的int[n]；
对于（int i=0；i11&&Level！=13）跳转（世界级）；
else System.out.println（“无法解决”）；
}
//////////////////////////////////////////////////////
公共静态无效跳转（int[]世界）{
for（int i=0；i=0）{//左跳转在界中
如果（world[i-world[i]！=0）{//不能在空的键盘上跳转
temp=世界[i]；
//向左跳
世界[i-世界[i]+=世界[i]；
世界[i]=0；
if（LogSolution）solution.push（newjump（temp，i，i-temp））；//记录解决方案步骤1/2
if（LogAll）System.out.println（“J:+Arrays.toString（world））；//记录跳转
//继续跳跃
跳跃（世界）；
//向后滚左跳
世界[i]=温度；
世界[i-世界[i]-=世界[i]；
if（LogAll）System.out.println（“R:+Arrays.toString（world））；//记录回滚
if（LogSolution）solution.pop（）；//记录解决方案步骤2/2
}
}
}
}
}
}

---

旁注：private static Deque<Jump> solution = new ArrayDeque<>(Level);

                    solution.push(new Jump(temp, i, i + temp));

                    solution.pop();

public class Jump {
    int count;
    int from;
    int to;

    public Jump(int count, int from, int to) {
        this.count = count;
        this.from = from;
        this.to = to;
    }

    @Override
    public String toString() {
        return "" + count + " frog/s jump from " + from + " to " + to;
    }
}

                    if (jump(world)) {
                        solution.push(new Jump(temp, i, i + temp));
                        return true;
                    }

1 frog/s jump from 3 to 4
1 frog/s jump from 7 to 6
2 frog/s jump from 6 to 4
4 frog/s jump from 4 to 0
5 frog/s jump from 0 to 5
6 frog/s jump from 5 to 11
1 frog/s jump from 8 to 9
2 frog/s jump from 9 to 11
9 frog/s jump from 11 to 2

public static void jump(int[] world) {
    for (int fromIndex = 0; fromIndex < world.length; fromIndex++) { // index of pad to jump from
        // any frog/s here?
        int frogsJumping = world[fromIndex];
        if (frogsJumping > 0) {
            // try to jump left; frogsJumping frogs jump frogsJumping places
            int targetIndex = fromIndex - frogsJumping;
            if (targetIndex >= 0 && world[targetIndex] > 0) { // must not jump to empty pad
                performJump(fromIndex, targetIndex, world, frogsJumping);
            }
            // try a right jump
            targetIndex = fromIndex + frogsJumping;
            if (targetIndex < world.length && world[targetIndex] > 0) {
                performJump(fromIndex, targetIndex, world, frogsJumping);
            }
        }
    }
}

private static void performJump(int fromIndex, int toIndex, int[] world, int frogsJumping) {
    solution.push(new Jump(frogsJumping, fromIndex, toIndex));
    world[fromIndex] = 0;
    world[toIndex] += frogsJumping;
    if (world[toIndex] == noOfFrogs) {
        System.out.println("Solved: " + Arrays.toString(world));
        System.exit(0);
    }
    jump(world);
    // backtrack
    world[toIndex] -= frogsJumping;
    world[fromIndex] = frogsJumping;
    solution.pop();
}