Java 为深度优先搜索生成状态

所以在USACO上练习时，我被这个问题困住了

问题描述：房间中有N个灯（所有灯最初都打开）。灯有4个开关，每个开关切换特定灯，如：

Switch 1 : Toggles all the lamps
Switch 2 : Toggles all ordered numbered lamps
Switch 3 : Toggles all even numbered lamps
Switch 4 : Toggles all numbers that have modulus 1 with 3 (1, 4, 9)

提供的数字c表示开关按下的总数。 最初，所有灯都亮起。还提供了一些处于最终状态的灯的状态

工作是列出灯泡可能的所有最终状态

为此，我提出了一个基于深度优先搜索的解决方案。我用数组中的一个元素表示每个灯泡，如果数组[I-1]为1，灯泡I为开；如果数组[I-1]=0，灯泡I为关。这是我的密码

/**
* Created by hp on 21-05-2015.
*/
import java.util.*;
public class lamps {
public static void main(String[] args) {
    Scanner myScanner = new Scanner(System.in);
    int numLamps = myScanner.nextInt();
    int[] startState = new int[numLamps];
    for(int i = 0; i < numLamps; i++){
        startState[i] = 1;
    }
    int numSwitchPressed = myScanner.nextInt();
    int[] finalState = new int[numLamps];
    /*
        -1 represents the lamp's state in the final state,
        whose state is not stated , can be both on and off
     */
    for(int i = 0; i < numLamps; i++){
        finalState[i] = -1;
    }

    /*
        ON Lamps in the final state
     */
    int on = myScanner.nextInt();
    while(on != -1){
        finalState[on-1] = 1;
        on = myScanner.nextInt();
    }

    /*
        OFF Lamps in the final state
     */
    int off = myScanner.nextInt();
    while(off != -1){
        finalState[off-1] = 0;
        off = myScanner.nextInt();
    }

    //TESTING THE GENERATE STATES METHOD HERE
    ArrayList<int[]> nextStates = nextStates(startState);
    for(int[] x: nextStates){
        for(int y: x){
            System.out.print(y + " ");
        }
        System.out.println();
    }
    System.out.println("========================================");
    System.out.println("========================================");
    callSearch(finalState, numSwitchPressed);
}
/*
    Generate the states that are results of pressing each switch
    Switch 1 : Toggle all
    Switch 2 : Toggle odd numbered lamps(effectively indices 0,2,4,6, )
    Switch 3 : Toggle even numbered lamps(effectively indices 1, 3, 5, 7)
    Switch 4 : Toggle lamps numbered 3x+1 (1, 4, 7, 10, 13)
 */
public static ArrayList<int[]> nextStates(int[] presentState){
    int len = presentState.length;
    ArrayList<int[]> nextState = new ArrayList<int[]>();
    int[] switchOne = new int[len];
    int[] switchTwo = new int[len];
    int[] switchThree = new int[len];
    int[] switchFour = new int[len];

    // Switch One : Toggle All
    for(int i = 0; i < len; i++){
        switchOne[i] = 1 - presentState[i];
    }
    nextState.add(switchOne);

    //Switch Two : Toggle odd numbered lamps
    for(int i = 0; i < len; i++){
        if(i % 2 == 0){
            switchTwo[i] = 1 - presentState[i];
        }
        else{
            switchTwo[i] = presentState[i];
        }
    }
    nextState.add(switchTwo);

    // Switch Three : Toggle even numbered lamps
    // 1, 3, 5, 7 , 9
    for(int i = 0; i < len; i++){
        if(i % 2 != 0){
            switchThree[i] = 1 - presentState[i];
        }
        else{
            switchThree[i] = presentState[i];
        }
    }
    nextState.add(switchThree);

    // Switch four : Toggle 1, 4, 7, 10
    for(int i = 0; i < len; i++){
        if(i % 3 == 1){
            switchFour[i] = 1 - presentState[i];
        }
        else{
            switchFour[i] = presentState[i];
        }
    }
    nextState.add(switchFour);
    return nextState;
}
/*
    def searchFinal (cntSoFar, FixedCnt, currentState, FinalState):
        if cntSoFar == FixedCnt:
            if currentState == FinalState:
                print currentState
                return
            return
        ListOfNextStates = generatenextState(currentState)
        for each new_state in ListOfNextStates:
            searchFinal(cntSoFar+1, FixedCnt, new_state, FinalState)
 */
public static void searchFinal(int cntSoFar, int FixedCnt, int[] currentState, int[] finalState){
    if(cntSoFar == FixedCnt){
        if(same(currentState, finalState)){
            for(int i = 0; i < finalState.length; i++){
                System.out.print(currentState[i] + " ");
            }
            System.out.println();
            return;
        }
        return;
    }
    ArrayList<int[]> nextStates = nextStates(currentState);
    for(int[] states: nextStates){
        searchFinal(cntSoFar+1, FixedCnt, states, finalState);
    }
}
/*
    WRAPPER METHOD FOR searchFinal
 */
public static void callSearch(int[] finalState, int FixedCnt){
    int len = finalState.length;
    int[] start = new int[len];
    for(int i = 0; i < len; i++)
        start[i] = 1;
    ArrayList<int[]> firstCandidates = nextStates(start);
    for(int[] state: firstCandidates){
        searchFinal(0, FixedCnt, state, finalState);
    }
}
public static boolean same(int[] currentState, int[] finalState){
    int len = finalState.length;
    for(int i = 0; i < len; i++){
        if(finalState[i] != -1){
            if(currentState[i] != finalState[i])
                return false;
        }
    }
    return true;
}
}

但评分员给出的答案是

0000000000
0101010101
0110110110

问题：评分员的第三个状态回答，这是从哪里来的？我的意思是，由于c是1（允许按下的开关数量），灯的唯一可能状态是前面列出的4个。平地机回答中提到的第三种灯状态如何可能

开关4：将模数为1的所有数字切换为3

开关#1:

0000000000

开关4：将模数为1的所有数字切换为3

开关#1:

0000000000

开关4：将模数为1的所有数字切换为3

开关#1:

0000000000

开关4：将模数为1的所有数字切换为3

开关#1:

0000000000

你可能错过了这个事实

你可能错过了这个事实

你可能错过了这个事实

---

您可能忽略了这一事实。

您的解决方案想法是正确的，但您的代码是一场噩梦：(

把灯的状态想象成一个N位向量。对于N=4，0000表示全部关闭，1111表示全部打开

如果将N位向量分成6位的集合（当然不包括任何尾随位），无论执行哪种开关，每个集合都将具有完全相同的值。也就是说，如果N>=12，则位0到5将与位6到11完全相同。因此，可以将每个开关操作表示为应用于6位向量的逐位操作

---

DFS是正确的起点，但您当前的DFS树有4^c个节点。利用循环检测和6位向量的有限大小来避免重复计算。

您的解决方案思路是正确的，但您的代码是一场噩梦：(

把灯的状态想象成一个N位向量。对于N=4，0000表示全部关闭，1111表示全部打开

如果将N位向量分成6位的集合（当然不包括任何尾随位），无论执行哪种开关，每个集合都将具有完全相同的值。也就是说，如果N>=12，则位0到5将与位6到11完全相同。因此，可以将每个开关操作表示为应用于6位向量的逐位操作

---

DFS是正确的起点，但您当前的DFS树有4^c个节点。利用循环检测和6位向量的有限大小来避免重复计算。

您的解决方案思路是正确的，但您的代码是一场噩梦：(

把灯的状态想象成一个N位向量。对于N=4，0000表示全部关闭，1111表示全部打开

如果将N位向量分成6位的集合（当然不包括任何尾随位），无论执行哪种开关，每个集合都将具有完全相同的值。也就是说，如果N>=12，则位0到5将与位6到11完全相同。因此，可以将每个开关操作表示为应用于6位向量的逐位操作

---

DFS是正确的起点，但您当前的DFS树有4^c个节点。利用循环检测和6位向量的有限大小来避免重复计算。

您的解决方案思路是正确的，但您的代码是一场噩梦：(

把灯的状态想象成一个N位向量。对于N=4，0000表示全部关闭，1111表示全部打开

如果将N位向量分成6位的集合（当然不包括任何尾随位），无论执行哪种开关，每个集合都将具有完全相同的值。也就是说，如果N>=12，则位0到5将与位6到11完全相同。因此，可以将每个开关操作表示为应用于6位向量的逐位操作

---

DFS是正确的开始位置，但您当前的DFS树有4^c个节点。利用循环检测和6位向量的有限大小避免重复计算。

问题陈述链接，请定义

顺序编号
！如果灯号从1开始，按第4个开关将产生最后一个结果。同时按INg第4个开关肯定不会产生结果
011101101
，即使您在0处启动灯号。请链接问题陈述。定义
顺序编号
！如果灯号在1处启动，按下第4个开关将产生最后一个结果。同时按下第4个开关肯定不会产生结果
011101101
，即使您在0处启动灯号。请定义问题陈述链接。定义
顺序编号
！如果灯号在1处启动，按第4个开关将产生最后一个结果。同时，按第4个开关肯定不会产生结果
011011101101
，即使您在0处启动灯号。请定义问题陈述链接。Define
有序编号
！如果灯号从1开始，按第4个开关将产生最后一个结果。同时按第4个开关也肯定不会产生结果
01101111001
，即使灯号从0开始。哦，是的，你是对的。我想我必须稍微更改一下我的整个程序，因为还有其他错误kes（比如不检查是否有人访问过生成的声明）。哦，是的，你是对的。我想我会的
0000000000
0101010101
0110110110

1 % 3 = 1
4 % 3 = 1
7 % 3 = 1
10 % 3 = 1

7 % 3 = 1