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

最新推荐文章于 2026-08-20 21:29:57 发布

原创最新推荐文章于 2026-08-20 21:29:57 发布 · 847 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

经典算法，LeetCode题目研究

算法/LeetCode

本文介绍了一种算法，用于判断一个非空字符串是否可以通过重复拼接其子串来构造。通过逐步改进算法，最终实现了高效的解决方案，并附带了详细的代码示例。

原文

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;
        }