【N数之和】leetcode 1,15,18题题解

最新推荐文章于 2022-05-10 10:45:20 发布

疯人院院士

最新推荐文章于 2022-05-10 10:45:20 发布

阅读量503

点赞数 1

CC 4.0 BY-SA版权

分类专栏：算法文章标签： leetcode 题解

本文链接：https://blog.csdn.net/qq_38702445/article/details/90413337

算法专栏收录该内容

3 篇文章

订阅专栏

本文介绍了如何解决LeetCode中关于求三数和与四数和的问题，遵循排序和使用HashSet避免重复的解题原则。通过示例代码展示了O(n^2)和O(n^3)复杂度的解决方案，适用于更高数量级的数之和问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

两数、三数、四数之和的通解

- 三数之和
- 四数之和

leetcode上面的第一道题就是两数之和，这道题虽然很简单但是也蕴含着不少算法知识。但后面又接二连三地出现了“三数之和”、“四数之和”，便有聪明的同学想：难道就没有什么通解吗？事实上是有的，这也是本文的目的。

解这类问题的原则有以下两条
1，排序
2，使用hashSet检验重复

第一条就不用说了，如果不排序的话很难保证找出全部的解，也不方便检验重复。
第二条的hashset包括两部分：各级（除最后两级以外）的访问过的值的集合，最后两级中访问过的值的集合，话不多说，三数和四数之和的代码如下：

三数之和


        //三数之和
        //判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 09 ？
        //返回所有满足条件且不重复的三元组。
        public static IList<IList<int>> ThreeSum(int[] nums)
        {
            return ThreeSum(nums, 0);
        }

        //解题思想
        //使用“访问过的元素集合”来避免重复
        public static IList<IList<int>> ThreeSum(int[] nums, int target)
        {
            //初始化
            List<IList<int>> ans = new List<IList<int>>();//结果

            //1,排序
            Array.Sort(nums);

            //2,从前往后遍历
            HashSet<int> visitedSet = new HashSet<int>();//访问过的集合，防止重复
            for(int i = 0;i < nums.Length; i++)
            {
                if (!visitedSet.Contains(nums[i]))//如果不重复（重复的话就不用再访问了）
                {
                    HashSet<int> internalVisitedSet = new HashSet<int>();//访问过的集合，防止重复
                    visitedSet.Add(nums[i]);
                    //使用双指针方法求出和为 target-nums[i] 的两个数即可
                    int l = i + 1, r = nums.Length - 1;
                    while(l < r)
                    {
                        if (nums[l] + nums[r] == target - nums[i])
                        {
                            if(!(internalVisitedSet.Contains(nums[l])||internalVisitedSet.Contains(nums[r])))
                                ans.Add(new List<int>() { nums[i], nums[l], nums[r] });
                            internalVisitedSet.Add(nums[l]);
                            internalVisitedSet.Add(nums[r]);
                            l++;r--;
                        }
                        else if (nums[l] + nums[r] > target - nums[i])
                            r--;
                        else
                            l++;
                    }
                }
            }


            return ans;

        }

四数之和


        public static IList<IList<int>> FourSum(int[] nums, int target)
        {
            List<IList<int>> ans = new List<IList<int>>();

            //先排序
            Array.Sort(nums);

            //遍历
            HashSet<int> _1stVisited = new HashSet<int>();//第一个数中已访问的集合
            for(int i = 0;i < nums.Length; i++)
            {
                if (!_1stVisited.Contains(nums[i]))
                {
                    _1stVisited.Add(nums[i]);

                    HashSet<int> _2ndVisited = new HashSet<int>();
                    for(int j = i + 1;j < nums.Length; j++)
                    {
                        if (!_2ndVisited.Contains(nums[j]))
                        {
                            _2ndVisited.Add(nums[j]);
                            HashSet<int> _34thVisited = new HashSet<int>();
                            int l = j + 1, r = nums.Length - 1;
                            while(l < r)
                            {
                                if (!_34thVisited.Contains(nums[l]) && !_34thVisited.Contains(nums[r]))
                                {
                                    if (nums[i] + nums[j] + nums[l] + nums[r] == target)
                                    {
                                        _34thVisited.Add(nums[l]); _34thVisited.Add(nums[r]);
                                        ans.Add(new List<int>() { nums[i], nums[j], nums[l], nums[r] });
                                        l++; r--;
                                    }
                                    else if (nums[i] + nums[j] + nums[l] + nums[r] < target)
                                        l++;
                                    else
                                        r--;
                                }
                                else if (_34thVisited.Contains(nums[l]))
                                    l++;
                                else
                                    r--;
                            }
                        }
                    }
                }
            }
            return ans;
        }

可以看出这两个代码几乎一样，效率分别是O(n^2) 和 O(n^3)，这样就算遇到五数之和五千数之和都不怕啦