Leetcode 30.与所有单词相关联的子串

与所有单词相关联的字串

给定一个字符串 s 和一些长度相同的单词 words。在 s 中找出可以恰好串联 words 中所有单词的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。

示例 1:

输入:

s = "barfoothefoobarman",

words = ["foo","bar"]

输出: [0,9]

解释: 从索引 0 和 9 开始的子串分别是 "barfoor" 和 "foobar" 。

输出的顺序不重要, [9,0] 也是有效答案。

题目的意思是给你一个字符串，和一个字符串的数组，需要返回一个该字符串的索引组成的数组，返回的索引有如下性质：从每个索引开始，长度为L的字串需要精确包含字符串数组中的所有字符串（不多不少）。L 为字符串数组中所有字符串长度之和。

解决思路，使用一个map，键为字符串数组中的字符串，值为该字符串在字符串数组中出现的次数。遍历字符串s，寻找和字符串数组中的字符串相同的字串，找到后map中的值减一，否则重新初始化map，从下一个字符开始遍历。如果map中所有的值都为0，则找到了一个符合条件的子串，索引压入数组。

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;

 class Solution {
     public static void  initializeMap(HashMap<String,Integer> hashMap, String[] words){
         //hashMap=new HashMap<String,Integer>();
         for(int i=0;i<words.length;i++){
             if(!hashMap.containsKey(words[i])){
                 hashMap.put(words[i],1);
             }else{
                 hashMap.put(words[i],hashMap.get(words[i])+1);
             }
         }
     }
     public static List<Integer> findSubstring(String s, String[] words) {
         if(s==null || s.equals("") || words.length==0) return new ArrayList<Integer>();
         HashMap<String,Integer> hashMap=new HashMap<String,Integer>();
         int singleWordLen=words[0].length();//单个字串长度
         int wordsLen=words.length;
         int slen=s.length();
         int i,j,count;
         boolean countChange=false;//判断是否改变过map中的值，如果没有变则无需重新初始化
         List<Integer> result=new ArrayList<Integer>();
         count=wordsLen;//计数器表示还需要找到的字串个数
         if(wordsLen==0 || slen==0) return result;
         initializeMap(hashMap,words);
         for(i=0;i<=slen-wordsLen*singleWordLen;i++){
             String subStr=s.substring(i,i+singleWordLen);
             j=i;
             //当该字串存在于map中且值大于0，并且j不越界的情况下
             while(hashMap.containsKey(subStr) && hashMap.get(subStr)!=0 && j+singleWordLen<=slen){
                 hashMap.put(subStr,hashMap.get(subStr)-1);
                 count--;
                 countChange=true;//改变了map的值
                 j=j+singleWordLen;
                 if(j+singleWordLen<=slen)
                     subStr=s.substring(j,j+singleWordLen);//下一个字符串
                 else
                     break;
                 if(!hashMap.containsKey(subStr))
                     break;
             }
             if(count==0){
                 result.add(i);//找齐所有字符串数组中的字串后把该索引压入
             }
             if(countChange){
                 hashMap.clear();
                 initializeMap(hashMap,words);
                 count=wordsLen;
                 countChange=false;
             }
         }
         return result;
     }

     public  static void main(String[] args){
         String s="wordgoodgoodgoodbestword";
         String[] words={"word","good","best","good"};
         List<Integer> list=findSubstring(s,words);
         for(int i:list){
             System.out.println(i);
         }
     }
 }