LeetCode-Easy部分中标签为String 459. Repeated Substring Pattern

原文

Given a non-empty string check if it can be constructed by taking a substring of it and appending multiple copies of the substring together. You may assume the given string consists of lowercase English letters only and its length will not exceed 10000.

Example 1:
Input: "abab"

Output: True

Explanation: It's the substring "ab" twice.

Example 2:
Input: "aba"

Output: False

Example 3:
Input: "abcabcabcabc"

Output: True

Explanation: It's the substring "abc" four times. (And the substring "abcabc" twice.)

代码分析

判断字符串可由子串重复模式组成吗。思路，默认第一个字符为可重复组合整个串，则去掉这个字符组成的子串中，这个字符的indexof为0，依次检查，若不成立，再组合前两个字符，。。。

代码实现

        public bool RepeatedSubstringPattern(string s)
        {
            for (int i = 1; i < s.Length; i++)
            {
                string prefix = s.Substring(0, i); //可能的重复子串
                string strsub = s.Substring(i); //去掉以上可能的重复子串后
                int index = strsub.IndexOf(prefix);
                if (index != 0)
                    continue;
                else //表明紧接着字符串匹配上
                {
                    int j = 2;
                    while(j*i<s.Length)
                    {
                        strsub = s.Substring(j*i);
                        index = strsub.IndexOf(prefix);
                        if (index != 0)
                        {
                            break;
                        }
                        else
                            j++;
                    }
                    if (j * i == s.Length)
                        return true;
                }

            }
            return false;
        }

以上算法在leetcode上运行显示超时，深入思考后发现，重复子串的个数一定是原串的质因子，所以小改代码如下：

        public bool RepeatedSubstringPattern(string s)
        {
            for (int i = s.Length/2; i > 0 ; i--) //改动1
            { 
                if (s.Length % i != 0)//改动1
                    continue;//
                ///////////////////以下与上一版一样//////////////////
                string prefix = s.Substring(0, i); //可能的重复子串
                string strsub = s.Substring(i); //去掉以上可能的重复子串后
                int index = strsub.IndexOf(prefix);
                if (index != 0)
                    continue;
                else //表明紧接着字符串匹配上
                {
                    int j = 2;
                    while(j*i<s.Length)
                    {
                        strsub = s.Substring(j*i);
                        index = strsub.IndexOf(prefix);
                        if (index != 0)
                        {
                            break;
                        }
                        else
                            j++;
                    }
                    if (j * i == s.Length)
                        return true;
                }

            }
            return false;
        }

继续改进，已知重复子串后构造一个串的方法：

        public bool RepeatedSubstringPattern(string s)
        {
            for (int i = s.Length/2; i > 0 ; i--)
            {
                if (s.Length % i != 0)
                    continue;
                string prefix = s.Substring(0, i); //可能的重复子串
                string strsub = s.Substring(i); //去掉以上可能的重复子串后
                int index = strsub.IndexOf(prefix);
                if (index != 0)
                    continue;
                else //表明紧接着字符串匹配上
                {
                //用这个子串重复s.Length/i次，若与原串相等，便为true。
                    StringBuilder sb = new StringBuilder(); 
                    for (int j = 0; j < s.Length / i;j++ )
                        sb.Append(prefix);
                    if (sb.ToString() == s)
                        return true;
                }

            }
            return false;
        }

更多string题目

http://blog.csdn.net/daigualu/article/details/69566863