Dynamic Programming (II)

1. The Longest Prefix

　　This is my solution to USACO training problem "prefix":

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

public class prefix {
    public static Scanner input;
    public static PrintWriter output;
    public static String [] dict;
    public static char [] obj;
    
    private static int solve(int num,int len)  {
        int [] dp = new int [len+1];
        // dp[i] will be the length of the longest prefix
        //        that starts from obj[i]
        for (int i=len-1;i>=0;i--) {
            for (int j=0;j<num;j++) {
                if (!consult(i,j,len)) {
                    continue;
                }
                int d = dict[j].length();
                if (d+dp[i+d]>dp[i]) {
                    dp[i] = dp[i+d]+d;
                }
            }
        }
        return dp[0];
    }
    private static boolean consult(int pos,int j,int len)  {
        // Returns whether obj[pos] starts with dict[j]
        for (int i=0;i<dict[j].length();i++) {
            if (pos+i>=len||obj[pos+i]!=dict[j].charAt(i)) {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) throws IOException{
        dict = new String [256];
        obj = new char [200000];
        input = new Scanner(new FileReader("prefix.in"));
        int num = 0;
        do {
            dict[num++] = input.next();
        } while (!dict[num-1].equals("."));
        String line = null;
        int len = 0;
        while (input.hasNext()) {
            line = input.nextLine();
            for (int i=0;i<line.length();i++) {
                obj[len++] = line.charAt(i);
            }
        }
        input.close();
        output = new PrintWriter(new FileWriter("prefix.out"));
        output.println(solve(num,len));
        output.close();
    }
}

2. Stringsobits

　　This is my solution to USACO training problem "kimbits":

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

public class kimbits {
    public static Scanner input;
    public static PrintWriter output;
    public static long [][] dp;
    
    private static void binSrch(int len,int num,long idx)  {
        // Generate the desired string from left to right by
        //        using a Divide-and-Conquer method
        if (len<=0) {
            output.println();
        } else if (idx<=dp[len-1][num]) {
            output.print(0);
            binSrch(len-1,num,idx);
        } else {
            output.print(1);
            binSrch(len-1,num-1,idx-dp[len-1][num]);
        }
    }
    public static void main(String[] args) throws IOException{
        // Obtain the input:
        input = new Scanner(new FileReader("kimbits.in"));
        int len = input.nextInt();
        int num = input.nextInt();
        long idx = input.nextLong();
        input.close();
        // Dynamic Programming:
        //        dp[i][j] will be the number of strings of length i,
        //                which have j or fewer 1s
        dp = new long [len+1][num+1];
        for (int j=0;j<=num;j++) {
            // please pay attention to this basis
            dp[0][j] = 1;
        }
        for (int i=1;i<=len;i++) {
            dp[i][0] = 1;
            for (int j=1;j<=num;j++) {
                dp[i][j] = dp[i-1][j]+dp[i-1][j-1];
            }
        }
        // Phrase the output:
        output = new PrintWriter(new FileWriter("kimbits.out"));
        binSrch(len,num,idx);
        output.close();
    }
}

3. Contact

　　This is my solution to USACO training problem "contact":

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

public class contact {
    public static Scanner input;
    public static PrintWriter output;
    public static int [] info;
    public static int [] dp;
    
    private static class Subseq {
        public int code, freq;
        
        public Subseq(int code, int freq) {
            this.code = code;
            this.freq = freq;
        }
        public String toString() {
            return seqHelp(code);
        }
        private String seqHelp(int val) {
            // Decode the code of the 0-1 sequence
            if (val==0) {
                return "";
            } else {
                String str = String.valueOf(1-(val&1));
                // turn to the parent node recursively
                return seqHelp((val-1)>>1)+str;
            }
        }
    }
    
    private static void solve(int min,int max,int num,int len) {
        PriorityQueue<Subseq> q = new PriorityQueue<Subseq>(1<<13,
                new Comparator<Subseq> () {
                    public int compare(Subseq s1,Subseq s2) {
                        // ATTENTION: there is an order on code when freq ties
                        if (s1.freq>s2.freq)  {
                            return -1;
                        } else if (s1.freq<s2.freq){
                            return 1;
                        } else if (s1.code<s2.code) {
                            return -1;
                        } else if (s1.code>s2.code) {
                            return 1;
                        } else {
                            return 0;
                        }
                    }
                }
        );
        // Dynamic Programming:
        //        each sequence is coded into an integer, 
        //        which is an index of a complete binary tree
        dp = new int[1<<13];
        for (int i=0;i<len;i++) {
            int code = 0;
            for (int j=0;j<max&&i+j<len;j++) {
                if (info[i+j]==0) {
                    code = (code<<1)+1;
                } else {
                    code = (code<<1)+2;
                }
                dp[code]++;
            }
        }
        for (int i=(1<<min)-1;i<(1<<max<<1);i++) {
            if (dp[i]>0) {
                // ATTENTION: do not enqueue a 0-1 sequence
                //        unless its frequency is greater than 0
                q.add(new Subseq(i,dp[i]));
            }
        }
        // This is the most frustrating part:
        //        phrase the output in the format required
        int tmp = 0;
        for (int i=0;i<num;i++) {
            if (q.isEmpty()) {
                break;
            } else {
                tmp = q.peek().freq;
                output.println(tmp);
            }
            int mod = 0;
            while (!q.isEmpty()&&q.peek().freq==tmp) {
                if (mod>0) {
                    output.print(" ");
                }
                output.print(q.poll());
                if (mod==5) {
                    output.println();
                }
                mod = (mod+1)%6;
            }
            if (mod>0) {
                output.println();
            }
        }
    }
    public static void main(String[] args) throws IOException {
        info = new int [200000];
        // Obtain the input:
        input = new Scanner(new FileReader("contact.in"));
        int min = input.nextInt();
        int max = input.nextInt();
        int num = input.nextInt();
        String line; 
        int len = 0;
        while (input.hasNext()) {
            line = input.nextLine();
            for (int i=0;i<line.length();i++) {
                info[len++] = line.charAt(i)-'0';
            }
        }
        input.close();
       max = (max<len)? max:len;
       // Phrase the output:
       output = new PrintWriter(new FileWriter("contact.out"));
       solve(min,max,num,len);
       output.close();
    }
}