Depth-First Search (II)

1. Generating Permutations

　　Here is a class that can generate all possible k-permutations from 0 through n-1:

import java.util.*; 

public class Permutation {
    public static int [] combArr;
    public static int [] permArr;

    public static void genPerm(int pos,int k,int visit) {
        if (pos==k) {
            // Print the solution:
            for (int i=0;i<k-1;i++) {
                System.out.print(permArr[i]+" ");
            }
            System.out.print(permArr[k-1]+"
");
            return;
        }
        int test = 1;
        for (int b=0;b<k;b++){
            if ((test&visit)==0){
                permArr[pos] = combArr[b];
                genPerm(pos+1,k,visit|test);
            }
            test <<= 1;
        }
    }
    public static void genComb(int pos,int n,int k) {
        if (pos==k) {
            // Generate the permutations:
            genPerm(0,k,0);
            return;
        }
        for (int v=combArr[pos-1]+1;v<n;v++){
            combArr[pos] = v;
            genComb(pos+1,n,k);
        }
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        in.close();
        combArr = new int [k];
        permArr = new int [k];
        for (int v=0;v<n;v++){
            combArr[0] = v;
            genComb(1,n,k);
        }
        System.out.println();
    }
}

　　The program above was written when I took up Java in the summer of 2014.

2. N-Queen Problem

　　This is my solution to the USACO training problem "checker":

import java.io.*;
import java.util.*;

public class checker {
    public static BufferedReader input;
    public static PrintWriter output;
    public static int val, size;
    public static int [] state;
    
    public static void dfs(int depth,int inval,int left,int right) {
        if (depth==size) {
            if (++val<4) {
                // print one of the first three solutions:
                for (int i=0;i<size-1;i++) {
                    output.print(state[i]+" ");
                }
                output.println(state[size-1]);
            }
            return;
        }
        int pos = (inval|left|right);
        for (int i=0;i<size;i++) {
            if ((pos&(1<<i))==0) {
                int lt = ((left|(1<<i))<<1);
                int rt = ((right|(1<<i))>>1);
                state[depth] = i+1;
                dfs(depth+1,inval|(1<<i),lt,rt);
            }
        }
    }
    public static void solve() {
        for (int i=0;i<size;i++) {
            int inval = (1<<i);
            state[0] = i+1;
            dfs(1,inval, (inval<<1),(inval>>1));
        }
    }
    public static void main(String[] args) throws IOException {
        input = new BufferedReader(new FileReader("checker.in"));
        size = Integer.parseInt(input.readLine());
        input.close();
        state = new int [size];
        solve();
        output = new PrintWriter(new FileWriter("checker.out"));
        output.println(val);
        output.close();
    }
}

3. Party Lamps

　　This is my solution to the USACO training problem "lamps":

import java.io.*;
import java.util.*;

public class lamps {
    public static BufferedReader input;
    public static PrintWriter output;
    public static boolean [] list;
    public static int num,cnt,open,closed;
    
    public static int turn(int state,int mode) {
        switch (mode) {
        case 0: state ^= 63; break;
        case 1: state ^= 21; break;
        case 2: state ^= 42; break;
        case 3: state ^= 9;
        } 
        return state;
    }
    public static boolean test(int state)  {
        for (int i=0;i<6;i++) {
            if ((open&(1<<i))>0 && (state&(1<<i))==0) {
                return false;
            } else if ((closed&(1<<i))>0 && (state&(1<<i))>0) {
                return false;
            }
        }
        return true;
    }
    public static int inv(int state)  {
        int val = 0;
        for (int i=0;i<6;i++) {
            val <<= 1;
            val += (state&1);
            state >>= 1;
        }
        return val;
    }
    public static void dfs(int depth,int state,int op) {
        if (depth==4) {
            if (test(state) && op%2==cnt%2 && op<=cnt) {
                list[inv(state)] = true;
            }
            return;
        } 
        dfs(depth+1,turn(state,depth),op+1);
        dfs(depth+1,state,op);
    }
    public static void show(int state)  {
        state = inv(state);
        for (int i=0;i<num;i++) {
            if ((state&(1<<(i%6)))>0) {
                output.print(1);
            } else {
                output.print(0);
            }
        } 
        output.println();
    }
    public static void main(String[] args) throws IOException{
        // Obtain the Input:
        input = new BufferedReader(new FileReader("lamps.in"));
        String line = input.readLine(); // first line of input
        num = Integer.parseInt(line);
        line = input.readLine(); // second line of input
        cnt = Integer.parseInt(line);
        line = input.readLine(); // third line of input
        StringTokenizer str = new StringTokenizer(line);
        int idx = Integer.parseInt(str.nextToken())-1;
        while (idx>=0) {
            open |= (1<<(idx%6));
            idx = Integer.parseInt(str.nextToken())-1;
        }
        line = input.readLine(); // fourth line of input
        str = new StringTokenizer(line);
        idx = Integer.parseInt(str.nextToken())-1;
        while (idx>=0) {
            closed |= (1<<(idx%6));
            idx = Integer.parseInt(str.nextToken())-1;
        }
        input.close();
        // Solve the Problem:
        list = new boolean[64];
        dfs(0,63,0);
        boolean flag = false;
        for (int i=0;i<64;i++) {
            if (list[i]) {
                flag = true;
                show(i);
            }
        }
        // Phrase the Output:
        output = new PrintWriter(new FileWriter("lamps.out"));
        if (!flag) {
            output.println("IMPOSSIBLE");
        }
        output.close();
    }
}