leetcode438

public class Solution
    {int nextindex = 0;public IList<int> FindAnagrams(string s, string p)
        {
            List<int> list = new List<int>();
            if (s == null || s.Length == 0 || p == null || p.Length == 0) return list;
            int[] hash = new int[256]; //character hash
            //record each character in p to hash
            foreach (char c in p)
            {
                hash[c]++;
            }
            //two points, initialize count to p's length
            int left = 0, right = 0, count = p.Length;
            while (right < s.Length)
            {
                //move right everytime, if the character exists in p's hash, decrease the count
                //current hash value >= 1 means the character is existing in p
                if (hash[s[right++]]-- >= 1) count--;

                //when the count is down to 0, means we found the right anagram
                //then add window's left to result list
                if (count == 0) list.Add(left);

                //if we find the window's size equals to p, then we have to move left (narrow the window) to find the new match window
                //++ to reset the hash because we kicked out the left
                //only increase the count if the character is in p
                //the count >= 0 indicate it was original in the hash, cuz it won't go below 0
                if (right - left == p.Length && hash[s[left++]]++ >= 0) count++;
            }
            return list;
        }
    }

https://leetcode.com/problems/find-all-anagrams-in-a-string/#/description

上面的是别人在讨论区的实现。

下面是我自己的实现，使用非递归方法，性能更好：

public class Solution
    {
        public IList<int> FindAnagrams(string s, string p)
        {
            var list = new List<int>();
            var dicp = new Dictionary<char, int>();
            foreach (var c in p)
            {
                if (dicp.ContainsKey(c))
                {
                    dicp[c]++;
                }
                else
                {
                    dicp.Add(c, 1);
                }
            }
            var dictemp = new Dictionary<char, int>(dicp);
            var counttemp = p.Length;
            var beginindex = 0;
            for (var i = 0; i < s.Length; i++)
            {
                var c = s[i];
                if (dictemp.ContainsKey(c))
                {
                    if (dictemp[c] > 0)
                    {
                        dictemp[c]--;
                        counttemp--;
                        if (counttemp == 0)
                        {
                            list.Add(beginindex);

                            //restore status
                            dictemp[s[beginindex]]++;
                            beginindex = beginindex + 1;
                            counttemp++;
                        }
                    }
                    else
                    {
                        if (s[beginindex] == c)
                        {
                            beginindex = beginindex + 1;
                        }
                        else
                        {
                            beginindex = i;
                            dictemp = new Dictionary<char, int>(dicp);
                            dictemp[c]--;
                            counttemp = p.Length - 1;
                        }
                    }
                }
                else
                {
                    beginindex = i + 1;
                    dictemp = new Dictionary<char, int>(dicp);
                    counttemp = p.Length;
                }
            }
            return list;
        }
    }