求出在字符串S中包含字符串T的最小字符串

记得本科的时候算法课上看到过这个题目，当时没有做出来，今天做360笔试的时候竟然仍然没做出来，真蛋疼。回来研究了半天，我擦，两个小时做那么多题目，这个肯定做不出来。

  题目：

        大意是：给定一个字符串S：“BLFBFSYDLEAKLFBYM”，和一个关键字T：“LBY”，求出在S中包含T的最小字符串？那么应该求出最小字符串：“LFBY”

       思路一：遍历T，再遍历S。（咋一看是这样，但是操作起来比较麻烦，我也没实现）

       思路二：分别求出关键字T中第一个字符和最后一个字符在S中的位置P1,P2，那么我们要求的答案就在P1和P2的组合当中。(额外浪费了很多空间)

       按道理，两种思路都可以行的通。目前，我按照思路二实现Java版的：

       

[java] view plain copy print ?

1. <span style="font-size:18px;">        </span><span style="font-size:14px;">  
2.         public static void main(String []args)  
3.             {  
4.                final String content="BLFBFSYDLEAKLFBYM";  
5.                final String key="LBY";  
6.                System.out.println(getAbstract(content, key));  
7.             }  
8.         /* 
9.          * content="BLFBFSYDLEAKLFBYM" 
10.          * key="LBY" 
11.          * 求包含key的最小字符串 
12.          * 注意abstract是L***Y,开始的肯定是L，结束的是Y 
13.          */  
14.         public static String getAbstract(String content,String key)  
15.         {  
16.             String tempString="";  
17. //           * 依次找到在content中L出现的位置和Y出现的位置   
18. //           * 那么要求的摘要只可能出现在L的位置和Y的位置的组合中   
19.             ArrayList<Integer> keyFirstList=new ArrayList<Integer>();  
20.             ArrayList<Integer>keyLastList=new ArrayList<Integer>();  
21.             for(int i=0;i<content.length();i++)  
22.                 {  
23.                     if(content.charAt(i)==key.charAt(0))  
24.                         keyFirstList.add(i);  
25.                     else if(content.charAt(i)==key.charAt(key.length()-1))  
26.                         keyLastList.add(i);  
27.                     else  
28.                         ;//do noting   
29.                 }  
30.             //得到所有的可能位置组合   
31.             //注意，很多组合显然不合适，start位置必须小于end的位置   
32.             int [][]maxAbstact=new int[keyFirstList.size()][keyLastList.size()];  
33.             for(int i=0;i<keyFirstList.size();i++)  
34.                 for(int j=0;j<keyLastList.size();j++)  
35.                     {  
36.                         if(keyFirstList.get(i)>=keyLastList.get(j))  
37.                             maxAbstact[i][j]=-1;  
38.                         else   
39.                             {  
40.                                 maxAbstact[i][j]=isContainKey(content, key,   
41.                                         keyFirstList.get(i), keyLastList.get(j));  
42.                             }  
43.                     }  
44.             int minLength=content.length();  
45.             int start = 0 ,end = 0;  
46.             //求出数据中的最小值，即要求字符串的最小的长度   
47.             for(int i=0;i<keyFirstList.size();i++)  
48.                 for(int j=0;j<keyLastList.size();j++)  
49.                     {  
50.                         if(maxAbstact[i][j]>-1&&maxAbstact[i][j]<minLength)  
51.                             {  
52.                                 minLength=maxAbstact[i][j];  
53.                                 start=i;  
54.                                 end=j;  
55.                             }  
56.                     }  
57.             for(int i=keyFirstList.get(start);i<=keyLastList.get(end);i++)  
58.                 {  
59.                    tempString+=content.charAt(i);  
60.                 }  
61.             return tempString;  
62.         }  
63.         /* 
64.          * 从start 到end的位置是否包含key 
65.          */  
66.         public static int isContainKey(String content ,String key,int start,int end)  
67.         {  
68.             int newStart=start;  
69.             for(int i=1;i<key.length()-1;i++)  
70.                 {  
71.                     int j=newStart+1;  
72.                     for(;j<end;j++)  
73.                         {  
74.                             if(content.charAt(j)==key.charAt(i))  
75.                                 {  
76.                                     newStart=j;  
77.                                     break;  
78.                                 }  
79.                         }  
80.                     if(j==end)  
81.                         return -1;  
82.                 }  
83.             return end-start;  
84.         }</span>