有n 个长为m+1 的字符串

有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接，问这n 个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。

 

分析一下，将各个字符串作为一个节点，首尾链接就好比是一条边，将两个节点连接起来，于是问题就变成一个有关图的路径长度的问题。链接所得的字符串最长长度即为从图的某个节点出发所能得到的最长路径问题，与最短路径类似，可以应用弗洛伊德算法求解。对于循环，即可认为各个节点通过其他节点又回到自己，反应在路径长度上，就表示某个节点到自己节点的路径大于零（注：初始化个节点到自己的长度为零）。

 

 

view plain

1. public class MaxCatenate {  
2.   
3.     public static void main(String[] args)   
4.     {  
5.         String[] text = new String[]{  
6.                  "abcd",  
7.                   "bcde",  
8.                    "cdea",  
9.                     "deab",  
10.                      "eaba",  
11.                       "abab",  
12.                     "deac",  
13.                    "cdei",  
14.                   "bcdf",  
15.                    "cdfi",  
16.                     "dfic",  
17.                    "cdfk",  
18.                   "bcdg",  
19.         };  
20.         maxCatenate(text);  
21.     }  
22.       
23.     public static void maxCatenate(String[] text)  
24.     {  
25.         int[][] G = new int[text.length][text.length];  
26.         for(int i=0; i<G.length; i++)  
27.         {  
28.             String suffix = text[i].substring(1);  
29.             for(int j=0; j<G.length; j++)  
30.                 if(text[j].indexOf(suffix)==0)  
31.                     G[i][j] = 1;  
32.         }  
33.         for(int k=0; k<G.length; k++)  
34.             for(int i=0; i<G.length; i++)  
35.                 for(int j=0; j<G.length; j++)  
36.                     if(G[i][k]!=0&&G[k][j]!=0)  
37.                     {  
38.                         int dist = G[i][k] + G[k][j];  
39.                         if(dist>G[i][j])  
40.                         {  
41.                             G[i][j] = dist;  
42.                         }  
43.                     }  
44.         for(int i=0; i<G.length; i++)  
45.             if(G[i][i]>1)  
46.             {  
47.                 System.out.println("circle is deteted!");  
48.                 return;  
49.             }  
50.         int max = 0;  
51.         for(int i=0; i<G.length; i++)  
52.             for(int j=0; j<G.length; j++)  
53.                 max = Math.max(max, G[i][j]);  
54.         System.out.println("Max length is " + (max+text[0].length()));  
55.     }  
56.   
57. }  

 

 

如果在text字符串数组中再加一个"babc"，就将形成环路，导致一些节点自身的路径非零，环路检测会报告出错。