Depth-First Search (III)

1. Mother's Milk

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

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

public class milk3 {
    public static BufferedReader input;
    public static PrintWriter output;
    public static boolean [] list;
    public static int [] size;
    
    private static void pour(int i,int j,int [] prev,boolean [][] vis) {
        int [] state = {prev[0],prev[1],size[2]-prev[0]-prev[1]};
        int delt = (state[i]<size[j]-state[j])? 
                state[i]:size[j]-state[j];
        state[i] -= delt;
        state[j] += delt;
        if (!vis[state[0]][state[1]]) {
            vis[state[0]][state[1]] = true;
            dfs(state,vis);
            vis[state[0]][state[1]] = false;
        } else if (state[0]==0) {
            list[state[2]] = true;
        }
        
    }
    private static void dfs(int [] state,boolean [][] visit) {
        pour(0,1,state,visit);
        pour(0,2,state,visit);
        pour(1,0,state,visit);
        pour(1,2,state,visit);
        pour(2,0,state,visit);
        pour(2,1,state,visit);
    }
    public static void main(String[] args) throws IOException {
        input = new BufferedReader(new FileReader("milk3.in"));
        StringTokenizer str = new StringTokenizer(input.readLine());
        size = new int[3];
        size[0] = Integer.parseInt(str.nextToken());
        size[1] = Integer.parseInt(str.nextToken());
        size[2] = Integer.parseInt(str.nextToken());
        input.close();
        list = new boolean [size[2]+1];
        boolean [][] visit = new boolean[size[2]+1][size[2]+1];
        dfs(new int[2],visit);
        output = new PrintWriter(new FileWriter("milk3.out"));
        for (int i=0;i<size[2];i++) {
            if (list[i]) {
                output.print(i+" ");
            }
        }
        output.println(size[2]);
        output.close();
    }
}

2. Wormholes

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

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

public class wormhole {
    public static class Point {
        public int x,y;
    }
    
    public static Scanner in;
    public static PrintWriter out;
    public static int num;
    public static Point[] hole;
    public static int[] next;
    
    private static int test(int[] pair) {
        // Test whether Bessie will get stuck in a cycle
        boolean[] vis = new boolean[num];
        for (int i=0;i<num;i++) {
            if (!vis[i]) {
                int j = i;
                while (j>=0) {
                    vis[j] = true;
                    j = next[pair[j]];
                    if (i==j) {
                        return 1;
                    }
                }
            }
        }
        return 0;
    }
    private static int dfs(int[] pair,int depth) {
        // Enumeration of Wormhole-Pair Matching
        if (depth==num) {
            return test(pair);
        } else if (pair[depth]>=0) {
            return dfs(pair,depth+1);
        } else {
            int val = 0;
            for (int i=depth+1;i<num;i++) {
                if (pair[i]>=0)  {
                    continue;
                }
                pair[depth] = i;
                pair[i] = depth;
                val += dfs(pair,depth+1);
                pair[i] = -1;
            }
            pair[depth] = -1;
            return val;
        }
    }
    private static void setNext() {
        next = new int[num];
        for (int i=0;i<num;i++) {
            next[i] = -1;
        }
        for (int i=0;i<num;i++) {
            for (int j=0;j<num;j++) {
                // next[i]==j means Bessie will falls into hole[j]
                //        after she departs from hole[i]
                if (hole[i].y!=hole[j].y || hole[j].x<=hole[i].x) {
                    continue;
                } else if (next[i]<0 || hole[next[i]].x>hole[j].x) {
                    next[i] = j;
                }
            } 
        }
    }
    private static void solve() { 
        int val = 0;
        int[] pair = new int[num];
        for (int i=0;i<num;i++) {
            pair[i] = -1;
        }
        val += dfs(pair,0);
        out.println(val);
    }
    public static void init() {
        num = in.nextInt();
        hole = new Point[num];
        for (int i=0;i<num;i++) {
            hole[i] = new Point();
            hole[i].x = in.nextInt();
            hole[i].y = in.nextInt();
        }
        setNext();
    }
    public static void main(String[] args) throws IOException {
        in = new Scanner(new FileReader("wormhole.in"));
        init();
        in.close();
        out = new PrintWriter(new FileWriter("wormhole.out"));
        solve();
        out.close();
    }
}

3. Zero Sum

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

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

public class zerosum {
    public static Scanner in;
    public static PrintWriter out;
    
    private static boolean test(char[] op,int n) {
        int val = 0, tmp = 1;
        boolean minus = false;
        for (int i=1;i<n;i++) {
            if (op[i]==' ') {
                tmp = tmp*10+(i+1);
            } else if (op[i]=='+') {
                if (!minus) {
                    val+=tmp;
                } else {
                    val-=tmp;
                }
                tmp = i+1;
                minus = false;
            } else {
                if (!minus) {
                    val+=tmp;
                } else {
                    val-=tmp;
                }
                tmp = i+1;
                minus = true;
            }
        }
        if (!minus) {
            return val==-tmp;
        } else {
            return val==tmp;
        }
    }
    private static void print(char[] op,int n) {
        out.print(1);
        for (int i=1;i<n;i++) {
            out.print(op[i]+""+(i+1));
        }
        out.println();
    }
    private static void dfs(char[] op,int k,int n) {
        if (k==n) {
            if (test(op,n)) {
                print(op,n); 
            }
            return;
        }
        op[k] = ' ';
        dfs(op,k+1,n);
        op[k] = '+';
        dfs(op,k+1,n);
        op[k] = '-';
        dfs(op,k+1,n);
    }
    public static void main(String[] args) throws IOException {
        in = new Scanner(new FileReader("zerosum.in"));
        int n = in.nextInt();
        in.close();
        out = new PrintWriter(new FileWriter("zerosum.out"));
        dfs(new char[n],1,n);
        out.close();
    }
}