COJ1078 最长公共子序列

　　原题链接：http://122.207.68.93/OnlineJudge/problem.php?id=1078

　　这道题与双序列的最长公共子序列毫不相干，其本质为单序列的最长上升子序列。

　　先离散化，然后用一个数组记录每个数字出现的位置（其实只需要记录第一行的序列），那么就可以转换成求最长上升子序列了，这里的上升是相对于某个数字的位置数组来说的（也就是n维的），比如(1,2,1) < (2,3,2)，但(2,2,2)<(1,3,3)不成立。然后O(m²)求LIS就行了。

　　第一次用JAVA，还不是很熟练，不熟悉JAVA机制与优化，代码运行得比较慢。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) {
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(in, out);
        out.close();
    }
}

class TaskA {

    public int id;
    int[] dp = new int[1005];
    public HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

    public TaskA() {
    }

    public void init() {
        id = 0;
        map.clear();
    }

    public void solve(Scanner in, PrintWriter out) {
        while (in.hasNext()) {
            init();
            int n = in.nextInt();
            int m = in.nextInt();

            Node[] k = new Node[m + 1];

            for (int j = 1; j <= m; j++) {
                map.put(in.nextInt(), j);
                k[j] = new Node();
                k[j].list.add(j);
            }
            for (int i = 1; i < n; i++) {
                for (int j = 1; j <= m; j++) {
                    int tmp = in.nextInt();
                    if (map.get(tmp) != null)
                        k[map.get(tmp)].list.add(j);
                }
            }
            int res = 0;
            dp[0] = 0;
            for (int i = 1; i <= m; i++) {
                if (k[i].list.size() == n) {
                    dp[i] = 1;
                    for (int j = i - 1; j >= 1; j--) {
                        if (k[j].list.size() == n && k[i].compareTo(k[j]) > 0)
                            dp[i] = max(dp[i], dp[j] + 1);
                    }
                    res = max(dp[i], res);
                }
            }
            System.out.println(res);
        }
    }

    public int max(int a, int b) {
        return a > b ? a : b;
    }
}

class Node implements Comparable<Object> {

    public List<Integer> list;

    public Node() {
        list = new ArrayList<Integer>();
    }

    public int compareTo(Object o) {
        Node node = (Node) o;
        int n = node.list.size();
        for (int i = 0; i < n; i++) {
            if (list.get(i).intValue() < node.list.get(i).intValue()) {
                return -1;
            }
        }
        return 1;
    }

}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }
}