【字符串】最短摘要问题

给定一段产品的英文描述，包含M个英文单词，每个单词以空格分隔。无其他标点符号； 再给定N个英文单词做关键词。

编程实现方法，目标是按照此产品的描述包含N个关键字的长度最短的子串，作为产品简介输出。 每个关键词至少出现一次。

方法1：暴力法

利用双层循环，从头遍历M个英文单词，如果N个关键词均包含在keyFound[i,j]中，且如果这段距离是最短的，就更新begin，end,直至扫描完全部M个英文单词。打印最短的产品简介。

方法2：尺取法

尺取法通常是指对数组保存一对下标（起点，终点），然后根据实际情况交替推进两个端点直到得出答案的方法。

扫描M个英文单词，二叉搜索查找该处单词是否在关键词中，如果不在就continue，如果在，且右边界大于i且全部找到就更新最短距离，再继续走循环直到结束。

第一次右边界从i+1走,查找接下来未找到的关键词，同上。需要考虑在关键词有重复的情况。

private static void solve1(String[] src, String[] keys) {

        int minlength = Integer.MAX_VALUE;
        int begin = -1;
        int end = -1;
        for (int i = 0; i < src.length; i++) {
            for (int j = i + 1; j < src.length; j++) {

                if (containsAll(src, keys, i, j)) {// 如果该段包含全部的关键词

                    if (j - i + 1 < minlength) {// 且为距离最短的一段
                        minlength = j - i + 1;
                        begin = i;
                        end = j;
                    }
                    break;
                }
            }
        }
        print(src, begin, end);
    }

 

  public static void solve2(String[] src, String[] keys) {
            Arrays.sort(keys);
            int j=-1;
            int begin=-1;
            int end=-1;
            int minlength=Integer.MAX_VALUE;
            for (int i = 0; i < src.length; i++) {
                String word=src[i];
                int index=Arrays.binarySearch(keys, word);
                if(index==-1){
                    continue;
                }else{//i处是一个关键字
                    if(j<src.length && j>=i &&containsAll(src, keys, i, j)){//所有关键词全部找到
                        if(minlength>j-i+1){
                            minlength=j-i+1;
                            begin=i;
                            end=j;
                        }
                        continue;
                    }
                    
                }
                if(j==-1)
                    j=i+1;
                while(j<src.length){
                        String word1=src[i];
                        int index1=Arrays.binarySearch(keys, word1);
                        if(index1==-1){
                            j++;
                        }else{//j处是一个关键字
                            if(containsAll(src, keys, i, j)){//所有关键词全部找到
                                if(minlength>j-i+1){
                                    minlength=j-i+1;
                                    begin=i;
                                    end=j;
                                }
                                break;//退出while循环
                            }else{//还没找到左右，j继续走
                                j++;
                                }
                            }
                            
                        }
            }
            print(src, begin, end);
      }

 

判断该段是否包含全部关键词 思路：

利用hash映射，将关键词keys的数组加入如果之前没出现过，就将其加入map,如果出现过就将其value+1；

然后在利用第二个map2，扫描src[i,j]段单词数组，同上操作；

最后扫描关键词的map,如果map2的那段中不包含关键词中，或者包含关键词的个数不相等 就return false;

/**
     * 
     * @param src
     * @param keys
     * @param i
     * @param j
     * @return
     */
    private static boolean containsAll(String[] src, String[] keys, int i, int j) {
        Map<String, Integer> map = new HashMap<>();
        for (int k = 0; k < keys.length; k++) {
            String key = keys[k];
            if (map.get(key) == null) {
                map.put(key, 1);
            } else {// 如果已经存在，就将value+1
                map.put(key, map.get(key) + 1);
            }

        }
        Map<String, Integer> map2 = new HashMap<>();
        for (int k = i; k <= j; k++) {
            String key = src[k];
            if (map2.get(key) == null) {
                map2.put(key, 1);
            } else {// 如果已经存在，就将value+1
                map2.put(key, map2.get(key) + 1);
            }

        }
        for (Map.Entry<String, Integer> e : map.entrySet()) {
            if (map2.get(e.getKey()) == null
                    || map2.get(e.getKey()) < e.getValue()) {
                return false;
            }

        }

        return true;
    }

 

打印结果数组

    private static void print(String[] src, int begin, int end) {

        System.out.println(begin + " " + end);
        for (int i = begin; i <= end; i++) {
            System.out.print(src[i] + " ");
        }
        // System.out.println();

    }

 

测试代码

public static void main(String[] args) {
        String[] s1 = { "a", "b", "c", "seed", "h", "e", "f", "c", "c", "seed",
                "e", "f", "seed", "c" };
        String[] s2 = { "c", "e","c" };
    //    solve1(s1, s2);
        solve2(s1,s2);
    }