有n 个长为m+1 的字符串，求前后m个字符匹配所能形成的最长字符串链

package strings;

/**
 * @author ycsun E-mail:stevesun521@gmail.com
 * @version 创建时间：2012-10-2 下午8:36:17 类说明
 */
public class MaxCatenate {

    /*
     * 有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接， 问这n
     * 个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。
     */
    private int m = 1;
    private int[][] adjMatrix;
    private int vertexnum = 0;
    private String[] text;
    private int[][] d;
    private int[][] path;
    private int maxPosX, maxPosY;
    private int maxLenth = Integer.MIN_VALUE;

    public MaxCatenate(int m, String[] text) {
        this.m = m;
        this.vertexnum = text.length;
        this.adjMatrix = new int[vertexnum][vertexnum];
        this.d = new int[vertexnum][vertexnum];
        this.text = text;
        this.path = new int[vertexnum][vertexnum];
    }

    public boolean hasEdge(String strA, String strB) {
        boolean result = false;
        String suffix = strA.substring(strA.length() - m);
        result = strB.startsWith(suffix);
        return result;
    }

    public void createAdjMatrix() {
        for (int i = 0; i < vertexnum; i++) {
            for (int j = 0; j < vertexnum; j++) {
                path[i][j] = -1;
                if (hasEdge(text[i], text[j])) {
                    adjMatrix[i][j] = 1;
                    this.d[i][j] = 1;
                } else {
                    adjMatrix[i][j] = Integer.MIN_VALUE;
                    this.d[i][j] = Integer.MIN_VALUE;
                }
            }
        }
    }

    public void longestFloyd() {
        for (int i = 0; i < vertexnum; i++) {
            for (int j = 0; j < vertexnum; j++) {
                for (int k = 0; k < vertexnum; k++) {
                    if (d[j][i] > Integer.MIN_VALUE
                            && d[i][k] > Integer.MIN_VALUE
                            && d[j][i] + d[i][k] > d[j][k]) {
                        d[j][k] = d[j][i] + d[i][k];
                        path[j][k] = i;
                        if (maxLenth < d[j][k]) {
                            maxLenth = d[j][k];
                            maxPosX = j;
                            maxPosY = k;
                        }
                    }
                }
            }
        }
    }

    public void hasCircle() {
        for (int i = 0; i < vertexnum; i++) {
            if (d[i][i] > Integer.MIN_VALUE) {
                System.out.println("Have a circle");
                break;
            }
        }
    }

    public void printMaxLenth() {
        System.out.println("Max length is " + maxLenth);
    }

    public void printMaxLenthPath() {
        System.out.print(text[maxPosX] + "-->");
        printMaxLenthPath(maxPosX, maxPosY);
        System.out.println(text[maxPosY]);
    }

    private void printMaxLenthPath(int x, int y) {
        int k = path[x][y];
        if (k == -1)
            return;
        printMaxLenthPath(x, k);
        System.out.print(text[k] + "-->");
        printMaxLenthPath(k, y);
    }

    public void printMatrix() {
        for (int i = 0; i < vertexnum; i++) {
            for (int j = 0; j < vertexnum; j++) {
                if (adjMatrix[i][j] > Integer.MIN_VALUE) {
                    System.out.print(adjMatrix[i][j] + " ");
                } else {
                    System.out.print("* ");
                }

            }
            System.out.println();
        }
        System.out.println("------------------------------------------------");
        for (int i = 0; i < vertexnum; i++) {
            for (int j = 0; j < vertexnum; j++) {
                if (d[i][j] > Integer.MIN_VALUE) {
                    System.out.print(d[i][j] + " ");
                } else {
                    System.out.print("* ");
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        String[] text = new String[] { "abcd", "qwer", "bcde", "wert", "erty",
                "cdeh", "tyui", "rtyu", };
        MaxCatenate maxCatenate = new MaxCatenate(3, text);
        maxCatenate.createAdjMatrix();
        maxCatenate.longestFloyd();
        maxCatenate.printMaxLenth();
        maxCatenate.printMaxLenthPath();
    }
}