Question

因此，在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则关闭。这是我的代码

/**
* 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;
}
}

正如您所看到的，我将在nextState方法中生成下一个状态。检查是否以相同的方法满足最终状态要求。

我的问题（对于长时间的背景感到抱歉）：如果灯的初始状态是1111111111（比如10个灯，全部都亮）并且c是1（允许开关次数），则只有四种状态可供搜索因为，

0000000000（按下开关1）
0101010101（按下开关2）
1010101010（按下开关3）
0111011101（按下开关4）

最终状态条件是灯7应该关闭。（我们不关心任何其他灯具）所以答案应该是

0000000000 (All are off)
0101010101 (1,3,5,7,9 are off)

但是评分者将答案显示为

0000000000
0101010101
0110110110

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

Answer 1

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

开关＃1：0000000000＆lt; -

开关＃2：0101010101＆lt; -

开关＃3：1010101010

开关＃4：0110110110＆lt; -

Answer 2

7 % 3 = 1

你可能错过了这个事实。

Answer 3

你的解决方案想法是正确的，但你的代码是一种噩梦:(

将灯的状态视为N位向量。对于N = 4，0000表示全部关闭，1111表示全部打开。

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

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

生成深度优先搜索的状态

3 个答案: