Total KMP

最新推荐文章于 2019-08-06 17:28:00 发布
最新推荐文章于 2019-08-06 17:28:00 发布
阅读量58 收藏
点赞数
原文链接：http://www.cnblogs.com/zhy2002/archive/2008/12/18/1357655.html
版权

Because it was a nightmare.

ContractedBlock.gif ExpandedBlockStart.gif Code
namespace ConsoleTest
{
    class KMPTest
    {
        public static void Test()
        {
            int[] source;
            int[] pattern;

            //source = new[] { 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1 };
            //pattern = new[] { 4, 3, 2 };

            //source = new[] { 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1 };
            //pattern = new[] { 4, 3, 2, 2 };

            //source = new[] { 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1 };
            //pattern = new[] { 1, 2, 3 };

            //source = new[] { 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1 };
            //pattern = new[] { 6, 7, 6 };

            source = new[] { 1, 1, 2, 1, 1, 1, 2, 2, 1 };
            pattern = new[] { 1, 1, 1, 2 };

            //source = new[] {1,2,3,1,1,1,2,3,4 };
            //pattern = new[] {1,1,1 };

            //source = new[] { 1,1,2,2,3};
            //pattern = new[] { 1,2 };

            //source = new[] {1,1,2,2,3,3,3};
            //pattern = new[] { 5,5,5 };

            //source = new[] { 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1 };
            //pattern = new[] { 4, 3, 2 };

            Console.WriteLine(IndexOf<int>.ExecuteKMPP(source, pattern));



        }
    }
}

 

 

 

ContractedBlock.gif ExpandedBlockStart.gif Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ZhyCodeLibrary.Algo
{
    /// <summary>
    /// System.String类实现了IEnumerable&lt;Char&gt;,但是没有实现IList&lt;Char&gt;
    /// 所以应该另外实现针对String的KMP算法
    /// 
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static class IndexOf<T>
    {
        #region KMP generic

        /// <summary>
        /// 泛型版的Next回溯函数求解方法
        /// </summary>
        /// <param name="pattern">模式串</param>
        /// <returns>Next回溯函数</returns>
        private static int[] Next(IList<T> pattern)
        {
            int[] next = new int[pattern.Count];
            next[0] = -1;
            if (pattern.Count < 2) //如果只有1个元素不用kmp效率会好一些
            {
                return next;
            }

            next[1] = 0;    //第二个元素的回溯函数值必然是0，可以证明：
            //1的前置序列集为{空集,L[0]}，L[0]的长度不小于1，所以淘汰，空集的长度为0，故回溯函数值为0
            int i = 2;  //正被计算next值的字符的索引
            int j = 0;  //计算next值所需要的中间变量，每一轮迭代初始时j总为next[i-1]
            while (i < pattern.Count)    //很明显当i==pattern.Length时所有字符的next值都已计算完毕，任务已经完成
            { //状态点
                //用Equals作为元素匹配条件
                if (pattern[i - 1].Equals(pattern[j]))   //首先必须记住在本函数实现中，迭代计算next值是从第三个元素开始的
                {   //如果L[i-1]等于L[j]，那么next[i] = j + 1
                    next[i++] = ++j;
                }
                else
                {   //如果不相等则检查next[i]的下一个可能值----next[j]
                    j = next[j];
                    if (j == -1)    //如果j == -1则表示next[i]的值是1
                    {   //可以把这一部分提取出来与外层判断合并
                        //书上的kmp代码很难理解的一个原因就是已经被优化，从而遮蔽了其实际逻辑
                        next[i++] = ++j;
                    }
                }
            }
            return next;

        }

        public static int ExecuteKMP(IEnumerable<T> source, IList<T> pattern)
        {
            int[] next = Next(pattern);
            return ExecuteKMPInternal(source, pattern, next);
        }

        private static int ExecuteKMPInternal(IEnumerable<T> source, IList<T> pattern, int[] next)
        {
            IEnumerator<T> iterator = source.GetEnumerator();

            int i = iterator.MoveNext() ? 0 : -1;//这两条语句必须总是一起执行 //主串指针

            int j = 0;  //模式串指针
            //如果子串没有匹配完毕并且主串没有搜索完成
            while (j < pattern.Count && i > -1)
            {
                if (iterator.Current.Equals(pattern[j]))    //i和j的逻辑意义体现于此，用于指示本轮迭代中要判断是否相等的主串字符和模式串字符
                {
                    i = iterator.MoveNext() ? i + 1 : -1;
                    j++;
                }
                else
                {
                    j = next[j];    //依照指示迭代回溯
                    if (j == -1)    //回溯有情况，这是第二种
                    {
                        i = iterator.MoveNext() ? i + 1 : -1;
                        j++;
                    }
                }
            }
            //如果j==pattern.Length则表示循环的退出是由于子串已经匹配完毕而不是主串用尽
            return j < pattern.Count ? -1 : i - j;
        }

        /// <summary>
        /// 泛型版的Next函数
        /// </summary>
        /// <param name="pattern">模式串可以是一个实现了IList的对象，所有数组都实现了IList</param>
        /// <param name="isEqual">此函数必须是反映一个等价关系，即满足自反、传递、交换，否则算法会出现逻辑错误。这是KMP算法的前提。</param>
        /// <returns>返回Next回溯函数</returns>
        private static int[] Next(IList<T> pattern, Func<T, T, bool> isEqual)
        {
            int[] next = new int[pattern.Count];
            next[0] = -1;
            if (pattern.Count < 2) //如果只有1个元素不用kmp效率会好一些
            {
                return next;
            }

            next[1] = 0;    //第二个元素的回溯函数值必然是0，可以证明：
            //1的前置序列集为{空集,L[0]}，L[0]的长度不小于1，所以淘汰，空集的长度为0，故回溯函数值为0
            int i = 2;  //正被计算next值的字符的索引
            int j = 0;  //计算next值所需要的中间变量，每一轮迭代初始时j总为next[i-1]
            while (i < pattern.Count)    //很明显当i==pattern.Length时所有字符的next值都已计算完毕，任务已经完成
            { //状态点
                //用Equals作为元素匹配条件
                if (isEqual(pattern[i - 1], pattern[j]))   //首先必须记住在本函数实现中，迭代计算next值是从第三个元素开始的
                {   //如果L[i-1]等于L[j]，那么next[i] = j + 1
                    next[i++] = ++j;
                }
                else
                {   //如果不相等则检查next[i]的下一个可能值----next[j]
                    j = next[j];
                    if (j == -1)    //如果j == -1则表示next[i]的值是1
                    {   //可以把这一部分提取出来与外层判断合并
                        //书上的kmp代码很难理解的一个原因就是已经被优化，从而遮蔽了其实际逻辑
                        next[i++] = ++j;
                    }
                }
            }
            return next;

        }

        public static int ExecuteKMP(IEnumerable<T> source, IList<T> pattern, Func<T, T, bool> isEqual)
        {
            int[] next = Next(pattern, isEqual);
            return ExecuteKMPInternal(source, pattern, isEqual, next);
        }

        /// <summary>
        /// KMP的核心包括两部分，Next(NextVal)求解和KMP匹配函数
        /// 本方法实现了泛型版的KMP匹配函数
        /// ExcuteKMP方法是对KMP调用的便捷封装
        /// </summary>
        /// <param name="source"></param>
        /// <param name="pattern"></param>
        /// <param name="isEqual">必须是等价函数，这是KMP函数的前提，切记。</param>
        /// <param name="next"></param>
        /// <returns></returns>
        private static int ExecuteKMPInternal(IEnumerable<T> source, IList<T> pattern, Func<T, T, bool> isEqual, int[] next)
        {
            IEnumerator<T> iterator = source.GetEnumerator();

            int i = iterator.MoveNext() ? 0 : -1;//这两条语句必须总是一起执行 //主串指针

            int j = 0;  //模式串指针
            //如果子串没有匹配完毕并且主串没有搜索完成
            while (j < pattern.Count && i > -1)
            {
                if (isEqual(iterator.Current, pattern[j]))    //i和j的逻辑意义体现于此，用于指示本轮迭代中要判断是否相等的主串字符和模式串字符
                {
                    i = iterator.MoveNext() ? i + 1 : -1;

                    j++;
                }
                else
                {
                    j = next[j];    //依照指示迭代回溯
                    if (j == -1)    //回溯有情况，这是第二种
                    {
                        i = iterator.MoveNext() ? i + 1 : -1;
                        j++;
                    }
                }
            }
            //如果j==pattern.Length则表示循环的退出是由于子串已经匹配完毕而不是主串用尽
            return j < pattern.Count ? -1 : i - j;
        }

        /// <summary>
        /// 终于把KMP算法搞定了，两眼全是泪水
        /// </summary>
        /// <param name="pattern"></param>
        /// <returns></returns>
        private static int[] NextVal(IList<T> pattern)
        {
            int[] next = new int[pattern.Count];
            next[0] = -1;
            if (pattern.Count < 2) //如果只有1个元素不用kmp效率会好一些
            {
                return next;
            }

            next[1] = 0;    //第二个元素的回溯函数值必然是0，可以证明：
            //1的前置序列集为{空集,L[0]}，L[0]的长度不小于1，所以淘汰，空集的长度为0，故回溯函数值为0
            int i = 2;  //正被计算next值的字符的索引
            int j = 0;  //计算next值所需要的中间变量，每一轮迭代初始时j总为next[i-1]
            while (i < pattern.Count)    //很明显当i==pattern.Length时所有字符的next值都已计算完毕，任务已经完成
            { //状态点
                //用Equals作为元素匹配条件
                if (j == -1 || pattern[i - 1].Equals(pattern[j]))   //首先必须记住在本函数实现中，迭代计算next值是从第三个元素开始的
                {   //如果L[i-1]等于L[j]，那么next[i] = j + 1
                    j++;
                    if (pattern[i].Equals(pattern[j]))
                    {
                        next[i] = next[j];
                    }
                    else
                    {
                        next[i] = j;
                    }
                    i++;
                }
                else
                {   //如果不相等则检查next[i]的下一个可能值----next[j]
                    j = next[j];
                }
            }
            return next;
        }

        //KMPP=KMP plus
        public static int ExecuteKMPP(IEnumerable<T> source, IList<T> pattern)
        {
            int[] next = NextVal(pattern);
            return ExecuteKMPInternal(source, pattern, next);
        }

        #endregion

        #region KMP string

        /// <summary>
        /// 求一个字符串的回溯函数。
        /// 约定序列下标从0开始。
        /// 回溯函数是整数集[0,n-1]到N的映射，n为字符串的长度。
        /// 回溯函数的定义：
        /// 设存在非空序列L，i为其合法下标；
        /// L[i]的前前置序列集为：{空集,L中所有以i-1为最后一个元素下标的子序列}
        /// L的前置序列集为：{空集,L中所有以0为第一个元素下标的子序列}
        /// 下标i的回溯函数值的定义为：
        /// 如果i=0,回溯函数值为-1
        /// 否则i的回溯函数值为i的前置序列集和L的前置序列集中相等元素的最大长度
        /// 换句话说是，设集合V={x,x属于i的前置序列集,并且x属于L的前置序列集，并且x的长度小于i}，回溯函数值为max(V)
        /// 当i=0时并不存在这样的一个x，所以约定此时的回溯函数值为-1
        /// 回溯函数的意义：
        /// 如果标号为j的字符同主串失配，那么将子串回溯到next[j]继续与主串匹配，如果next[j]=-1,则主串的匹配点后移一位，同子串的第一个元素开始匹配。
        /// 同一般的模式匹配算法相比，kmp通过回溯函数在失配的情况下跳过了若干轮匹配(向右滑动距离可能大于1)
        /// kmp算法保证跳过去的这些轮匹配一定是失配的，这一点可以证明
        /// </summary>
        /// <param name="pattern">模式串，上面的注释里将其称为子串</param>
        /// <returns>回溯函数是kmp算法的核心，本函数依照其定义求出回溯函数，KMP函数依照其意义使用回溯函数。</returns>
        private static int[] Next(string pattern)
        {
            int[] next = new int[pattern.Length];
            next[0] = -1;
            if (pattern.Length < 2) //如果只有1个元素不用kmp效率会好一些
            {
                return next;
            }

            next[1] = 0;    //第二个元素的回溯函数值必然是0，可以证明：
            //1的前置序列集为{空集,L[0]}，L[0]的长度不小于1，所以淘汰，空集的长度为0，故回溯函数值为0
            int i = 2;  //正被计算next值的字符的索引
            int j = 0;  //计算next值所需要的中间变量，每一轮迭代初始时j总为next[i-1]
            while (i < pattern.Length)    //很明显当i==pattern.Length时所有字符的next值都已计算完毕，任务已经完成
            { //状态点
                if (pattern[i - 1] == pattern[j])   //首先必须记住在本函数实现中，迭代计算next值是从第三个元素开始的
                {   //如果L[i-1]等于L[j]，那么next[i] = j + 1
                    next[i++] = ++j;
                }
                else
                {   //如果不相等则检查next[i]的下一个可能值----next[j]
                    j = next[j];
                    if (j == -1)    //如果j == -1则表示next[i]的值是1
                    {   //可以把这一部分提取出来与外层判断合并
                        //书上的kmp代码很难理解的一个原因就是已经被优化，从而遮蔽了其实际逻辑
                        next[i++] = ++j;
                    }
                }
            }
            return next;
        }

        /// <summary>
        /// KMP函数同普通的模式匹配函数的差别在于使用了next函数来使模式串一次向右滑动多位称为可能
        /// next函数的本质是提取重复的计算
        /// </summary>
        /// <param name="source">主串</param>
        /// <param name="pattern">用于查找主串中一个位置的模式串</param>
        /// <returns>-1表示没有匹配，否则返回匹配的标号</returns>
        public static int ExecuteKMP(string source, string pattern)
        {
            int[] next = Next(pattern);
            return ExecuteKMPInternal(source, pattern, next);
        }

        private static int ExecuteKMPInternal(string source, string pattern, int[] next)
        {
            int i = 0;  //主串指针
            int j = 0;  //模式串指针
            //如果子串没有匹配完毕并且主串没有搜索完成
            while (j < pattern.Length && i < source.Length)
            {
                if (source[i] == pattern[j])    //i和j的逻辑意义体现于此，用于指示本轮迭代中要判断是否相等的主串字符和模式串字符
                {
                    i++;
                    j++;
                }
                else
                {
                    j = next[j];    //依照指示迭代回溯
                    if (j == -1)    //回溯有情况，这是第二种
                    {
                        i++;
                        j++;
                    }
                }
            }
            //如果j==pattern.Length则表示循环的退出是由于子串已经匹配完毕而不是主串用尽
            return j < pattern.Length ? -1 : i - j;
        }

        #endregion

        #region KMP plus string

        /// <summary>
        /// NextVal是另外一种求回溯函数的方法，同Next基本上一样
        /// 唯一的区别在于j指针回溯的时候，判断一下pattern[j]同pattern[i]是否相等，如果相等，由于是在i处失配，
        /// 那么与在j处也必然失配，所以直接回溯到Next[j]
        /// 在next中，判断回溯后的串是否匹配完全是KMP的责任，但在NextVal中将一部分判断提取到了NextVal中
        /// KMP实在是太复杂了，感觉没有说得特别清楚。估计以后再捡起来还要费不少劲。
        /// so keep thinking
        /// </summary>
        /// <param name="pattern">模式串</param>
        /// <returns>NextVal回溯函数</returns>
        public static int[] NextVal(string pattern)
        {
            int[] next = new int[pattern.Length];
            next[0] = -1;
            if (pattern.Length < 2) //如果只有1个元素不用kmp效率会好一些
            {
                return next;
            }

            next[1] = 0;    //第二个元素的回溯函数值必然是0，可以证明：
            //1的前置序列集为{空集,L[0]}，L[0]的长度不小于1，所以淘汰，空集的长度为0，故回溯函数值为0
            int i = 2;  //正被计算next值的字符的索引
            int j = 0;  //计算next值所需要的中间变量，每一轮迭代初始时j总为next[i-1]
            while (i < pattern.Length)    //很明显当i==pattern.Length时所有字符的next值都已计算完毕，任务已经完成
            { //状态点
                if (j == -1 || pattern[i - 1] == pattern[j])   //首先必须记住在本函数实现中，迭代计算next值是从第三个元素开始的
                {   //如果L[i-1]等于L[j]，那么next[i] = j + 1
                    ++j;
                    if (pattern[i] == pattern[j])
                    {
                        next[i] = next[j];  //超量回溯
                    }
                    else
                    {
                        next[i] = j;    //标准的next回溯
                    }
                    i++;

                }
                else
                {   //如果不相等则检查next[i]的下一个可能值----next[j]
                    j = next[j];

                }
            }
            return next;
        }

        /// <summary>
        /// KMPP means KMP plus
        /// </summary>
        /// <param name="source"></param>
        /// <param name="pattern"></param>
        /// <returns>-1 means not found</returns>
        public static int ExecuteKMPP(string source, string pattern)
        {
            int[] next = NextVal(pattern);
            int i = 0;  //主串指针
            int j = 0;  //模式串指针
            //如果子串没有匹配完毕并且主串没有搜索完成
            while (j < pattern.Length && i < source.Length)
            {
                if (source[i] == pattern[j])    //i和j的逻辑意义体现于此，用于指示本轮迭代中要判断是否相等的主串字符和模式串字符
                {
                    i++;
                    j++;
                }
                else
                {
                    j = next[j];    //依照指示迭代回溯
                    if (j == -1)    //回溯有情况，这是第二种
                    {
                        i++;
                        j++;
                    }
                }
            }
            //如果j==pattern.Length则表示循环的退出是由于子串已经匹配完毕而不是主串用尽
            return j < pattern.Length ? -1 : i - j;
        }

        #endregion

        public static int Execute(IEnumerable<T> list, T elem, Func<T, T, bool> isEqual)
        {
            int i = 0;
            foreach (T t in list)
            {
                if (isEqual(t, elem))
                {
                    return i;
                }
                i++;
            }
            return -1;
        }
    }
}

 

测试代码：

 

 

转载于:https://www.cnblogs.com/zhy2002/archive/2008/12/18/1357655.html

weixin_30919571
关注
KMP查找算法的泛型实现
07-01
KMP查找算法的C++泛型实现.有详尽的测试用例在内
C#版泛型kmp算法
weixin_30235225的博客
07-20 186
#region KMP generic private static int[] Next(IList<T> pattern) { int[] next = new int[pattern.Count]; next[0] = -1; if (pattern....
泛型KMP算法
weixin_33912453的博客
06-06 66
当我们需要从一个字符串（主串）中寻找一个模式串（子串）时，使用KMP算法可以极大地提升效率。KMP是一个高效的字符串匹配算法，它巧妙的消除了在匹配的过程中指针回溯的问题，关于KMP算法的更多介绍，可以参考这里。 原始的KMP算法适用的对象是字符串的匹配搜索，其实针对任意类型的串（实际上就是一个数组）的子串搜索，都可以使用KMP算法。比如，我们可能需要在byte[]中查找一个特定的字节数组，这同样...
VB.NET2005通过泛型实现的KMP查找算法
weixin_30832983的博客
03-31 76
增强型的模式匹配算法，KMP查找算法VB.NET 2005泛型实现。也不知道用的对不对，但是个人感觉好像是对的。不过做测试的时候发现如果是字符串（字符数组）的匹配，用KMP算法比.NET自己的String.IndexOf还要慢。不知道.NET怎么做的，可能也是KMP算法吧。 和2003版的一样，主函数KMPSearch进行实际的匹配操作。子函数KMPSearchGetNextArray负责...
C#算法系列（11）——KMP模式匹配算法
午夜支枕听河流
12-15 1986
今天要实现的这个算法是在复习串操作时出现的，之前看过一遍，但时隔久远，毫无印象，捡起来还有点儿困难，发现当时理解不是那么透彻，自己主要理解难点是这个算法如何求解next数组。明白之后，发现它也并不难理解，就是有些资料的术语起了误导的作用，下面会按照小白的思路进行一系列说明，力求道明它的本质。一、KMP算法背景       主要是要解决求解子串在主串中第一次出现位置的问题，KMP的提出能使得这个求解过
KMP总结
qq_40510246的博客
07-26 296
本来上次写了一篇的，但是浏览器突然崩溃，闪退出去，，，写得东西都没了，，我，，，XXX，这次重写。 首先推荐一篇很好的KMP入门博客：https://blog.csdn.net/v_july_v/article/details/7041827 上周学习KMP的时候，确实有段时间很迷，因为我把两个不同版本的next数组弄混了，诶，上面这个链接里面有关next数组的东西讲的都很详细，有兴趣的可以去...
KMP算法
nia305的博客
08-09 390
1.字符串匹配：给定两个字符串S1, S2，我们需要确定S1里面是否包含S2，换句话说就是判断S2是否是S1的子串。 我们很容易想到的方法就是暴力搜索：从第一个字符开始匹配，如果不相等则顺序后移一位，再进行比较，伪代码为：n = s1.size m = s2.size for i = 0 to n - m if s2[0 ... m-1] == s1[s ... s+m-1]
kmp
Inkbamboo专栏
04-05 752
kmp是高效的子串匹配算法，比传统的朴素算法
Oulipo KMP
学 以致用
04-10 390
Oulipo Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 39658 Accepted: 15959 InputThe first line of the input file contains a single number: the number of test cases to follow
HDU 3336 KMP
北望村
01-14 159
Count the string Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 11954    Accepted Submission(s): 5545 Problem Description It is we
简单KMP Number Sequence
wjhuihuii的博客
08-16 224
Number Sequence Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 22055 Accepted Submission(s): 9428Problem Description Given two sequences
KMP+扩展KMP
UniverseofHK的博客
05-04 663
KMP next数组表示P[j]以前最长相同前缀后缀 若下标从0开始(以下模板就采用这种方式)，next[ i ] 表示前面长度为 i 的字符串前缀和后缀相等的最大长度为 next[ i ] 。 若下标从1开始，则next[ i ] 表示前面长度 i - 1的字符串中前缀和后缀相等的最大长度为 next[ i ] - 1 两种方式当S[i]与P[j]不同时j都应该移动到next[j] const ...
KMP
wuxiao18的博客
11-27 260
http://acm.hdu.edu.cn/showproblem.php?pid=1711 Number Sequence Time Limit: 10000/5000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 42930Accepte...
[HDU 5510][2015ACM/ICPC 亚洲区沈阳站]　Bazinga　KMP+剪支
ＡＴＯＤ
04-20 3469
Bazinga Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 1597 Accepted Submission(s): 499Problem Description Ladies and gentlemen, please s
HDU3336-KMP
CSDN
03-05 1516
Count the string Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3838    Accepted Submission(s): 1793 Problem Description It is well kn
kmp的最小循环节
冉筱
08-06 448
KMP最小循环节、循环周期： 定理：假设S的长度为len，则S存在最小循环节，循环节的长度L为len-next[len]，子串为S[0…len-next[len]-1]。 （1）如果len可以被len - next[len]整除，则表明字符串S可以完全由循环节循环组成，循环周期T=len/L。 （2）如果不能，说明还需要再添加几个字母才能补全。需要补的个数是循环个数L-len%L=L-(le...
ssm智能家政保洁预约系统最新完整版程序+论文.zip
10-18
基于SSM框架的智能家政保洁预约系统，是一个旨在提高家政保洁服务预约效率和管理水平的平台。该系统通过集成现代信息技术，为家政公司、家政服务人员和消费者提供了一个便捷的在线预约和管理系统。 系统的主要功能包括： 1. **用户管理**：允许消费者注册、登录，并管理他们的个人资料和预约历史。 2. **家政人员管理**：家政服务人员可以注册并更新自己的个人信息、服务类别和服务时间。 3. **服务预约**：消费者可以浏览不同的家政服务选项，选择合适的服务人员，并在线预约服务。 4. **订单管理**：系统支持订单的创建、跟踪和管理，包括订单的确认、完成和评价。 5. **评价系统**：消费者可以在家政服务完成后对服务进行评价，帮助提高服务质量和透明度。 6. **后台管理**：管理员可以管理用户、家政人员信息、服务类别、预约订单以及处理用户反馈。 系统采用Java语言开发，使用MySQL数据库进行数据存储，通过B/S架构实现用户与服务的在线交互。系统设计考虑了不同用户角色的需求，包括管理员、家政服务人员和普通用户，每个角色都有相应的权限和功能。此外，系统还采用了软件组件化、精化体系结构、分离逻辑和数据等方法，以便于未来的系统升级和维护。 智能家政保洁预约系统通过提供一个集中的平台，不仅方便了消费者的预约和管理，也为家政服务人员提供了一个展示和推广自己服务的机会。同时，系统的后台管理功能为家政公司提供了强大的数据支持和决策辅助，有助于提高服务质量和管理效率。该系统的设计与实现，标志着家政保洁服务向现代化和网络化的转型，为管理决策和控制提供保障，是行业发展中的重要里程碑。
东方财富网抓取上市公司爬虫-EMSpider.zip
最新发布
10-18
东方财富网抓取上市公司爬虫-EMSpider
卫生健康系统-java-基于springBoot智能推荐的卫生健康系统（毕业论文+开题）
10-18
本基于智能推荐的卫生健康系统有管理员和用户两个角色。用户功能有个人中心，健康视频管理，视频类型管理，科室类型管理，医生信息管理，在线预约管理，我的收藏管理等。管理员功能有个人中心，用户管理，健康视频管理，视频类型管理，科室类型管理，医生信息管理，在线预约管理，健康论坛管理，我的收藏管理，留言板管理，系统管理等。因而具有一定的实用性。 本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得基于智能推荐的卫生健康系统管理工作系统化、规范化。
KMP算法详解与实现
"本文将介绍KMP算法，一种高效的字符串匹配算法，由D.E.Knuth、V.R.Pratt和J.H.Morris三位学者独立发现。KMP算法的核心在于利用预处理得到的next函数，存储模式串的局部匹配信息，避免在比较过程中不必要的字符回溯...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值