给字符串s1、s2，在s1中找包含s2里所有字符的最小子串

/**
 * 
 采用hashMap进行比较,达到O(n)


 java实现如下:
 
 */
import java.util.HashMap;


public class SubString {


        private String[] src_string = null;


        private String[] sub_string = null;


        /**
         * 最小minSubString在src_string中的位置
         * 
         * 结果
         * 
         * @author wangzhg
         * 
         */
        class Pojo {
                private int pojo_i;


                private int pojo_k;


                private int[] obj_integer = new int[2];// obj_integer[0]代表开始编号,obj_integer[1]代表结束编号.


                private String[] obj_string = null;


                public Pojo(int i, int k, int begin, int end) {
                        pojo_i = i;
                        pojo_k = k;
                        obj_integer[0] = begin;
                        obj_integer[1] = end;
                }


                public int getMinus() {
                        return obj_integer[1] - obj_integer[0];
                }


                public void makeObjString() {
                        obj_string = new String[getMinus() + 1];
                        for (int i = obj_integer[0]; i <= obj_integer[1]; i++) {
                                obj_string[i - obj_integer[0]] = src_string[i];// 一次copy
                        }
                }


                public void print() {
                        for (int i = 0; i < obj_string.length; i++)
                                System.out.print(this.obj_string[i] + "  ");
                        System.out.println("\n");
                }
        }


        private Pojo[] Pojo_obj = null;// 可能有多个结果


        // key String 串;value Integer[]位置
        private HashMap src_stringMap = new HashMap();


        private HashMap sub_stringMap = new HashMap();


        private void initSrcHashMap() {
                String key = null;
                Integer[] value = null;
                for (int src_i = 0; src_i < src_string.length; src_i++) {
                        key = src_string[src_i];// 直接用src_string的string了
                        if (src_stringMap.containsKey(src_string[src_i])) {// 如果hashMap中有string值了.则重新放置value
                                Integer[] tmp = (Integer[]) src_stringMap
                                                .get(src_string[src_i]);// 得到value
                                value = new Integer[tmp.length + 1];// 需要重新分配空间
                                int i = 0;
                                for (; i < tmp.length; i++) {// copy赋值
                                        value[i] = tmp[i];
                                }
                                i++;
                                value[i] = new Integer(src_i);// 必须重新new
                                src_stringMap.put(key, value);
                        } else {
                                value = new Integer[1];
                                value[0] = new Integer(src_i);// 必须重新new
                                src_stringMap.put(key, value);// 构建hashMap
                        }
                }
        }


        /**
         * 判断是否存在
         * 
         * @return
         */
        private boolean getSubStringMap() {
                for (int sub_i = 0; sub_i < sub_string.length; sub_i++) {// 循环sub_string,找到hashMap中的对应key
                        String key = sub_string[sub_i];
                        Integer[] value = null;
                        if (src_stringMap.containsKey(key)) {
                                value = (Integer[]) src_stringMap.get(key);
                                sub_stringMap.put(key, value);
                        } else {
                                return false;// 不存在min子串
                        }
                }
                return true;
        }


        /**
         * 计算minSubString
         * 
         * @return
         */
        private Pojo[] getMinSubString() {// 转变为,求最短路径问题(可能有多个最短路径)
                Integer[] begin = (Integer[]) sub_stringMap.get(sub_string[0]);
                Integer[] end = (Integer[]) sub_stringMap
                                .get(sub_string[sub_string.length - 1]);
                Pojo[][] p = new Pojo[begin.length][end.length];
                int min = 0;
                // 得到跨度最小的value
                for (int i = 0; i < begin.length; i++) {// 构造2个数比较Pojo
                        for (int k = 0; k < end.length; k++) {
                                p[i][k] = new Pojo(i, k, begin[i].intValue(), end[k].intValue());
                                if (i == 0 && k == 0)
                                        min = p[i][k].getMinus();
                                if (p[i][k].getMinus() < min) {
                                        min = p[i][k].getMinus();
                                }
                        }
                }


                // 找到min,其余全部置null
                int num = 0;
                for (int i = 0; i < begin.length; i++) {// 构造2个数比较Pojo
                        for (int k = 0; k < end.length; k++) {
                                if (p[i][k].getMinus() != min) {
                                        p[i][k] = null;
                                } else {
                                        num++;
                                }
                        }
                }


                // 转置
                int id = 0;
                Pojo_obj = new Pojo[num];
                for (int i = 0; i < begin.length; i++) {// 构造2个数比较Pojo
                        for (int k = 0; k < end.length; k++) {
                                if (p[i][k] != null) {
                                        Pojo_obj[id] = p[i][k];
                                        Pojo_obj[id].makeObjString();// copySubString
                                        id++;
                                }
                        }
                }


                return Pojo_obj;
        };


        /**
         * 
         * @param src
         * @return
         */
        public Pojo[] getMinSubString(String[] src, String[] sub) {
                src_string = src;
                sub_string = sub;
                initSrcHashMap();// 构建hashMap
                if (!getSubStringMap())// 没有,直接返回null
                        return null;
                return getMinSubString();
        }


        public static void main(String[] arg) {
                String[] src = { "cc", "dd", "e", "f", "g", "h", "i" };
                String[] sub = { "dd", "e", "f" };
                Pojo[] obj_string = new SubString().getMinSubString(src, sub);
                for (int i = 0; i < obj_string.length; i++) {
                        obj_string[i].print();
                }
        }
}