【2475. 数组中不等三元组的数目】

最新推荐文章于 2024-09-09 22:01:06 发布

千北@

最新推荐文章于 2024-09-09 22:01:06 发布

阅读量983

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法数据结构 c++

本文链接：https://blog.csdn.net/Sugar_wolf/article/details/131183389

版权

LeetCode 专栏收录该内容

397 篇文章 2 订阅

订阅专栏

文章提供了三种方法来解决LeetCode上的一个问题：计算数组中不重复的三元组(i,j,k)的数量。方法一是简单的三重循环枚举，时间复杂度为O(n^3)；方法二是先排序再计算，时间复杂度为O(nlogn)；方法三是利用哈希表，时间复杂度为O(n)。每种方法都给出了C++实现及执行时间和空间复杂度分析。

摘要由CSDN通过智能技术生成

来源：力扣（LeetCode）

描述：

给你一个下标从 0 开始的正整数数组 nums 。请你找出并统计满足下述条件的三元组 (i, j, k) 的数目：

0 <= i < j < k < nums.length
nums[i]、nums[j] 和 nums[k] 两两不同 。
- 换句话说：nums[i] != nums[j]、nums[i] != nums[k] 且 nums[j] != nums[k] 。

返回满足上述条件三元组的数目。

示例 1：

输入：nums = [4,4,2,4,3]
输出：3
解释：下面列出的三元组均满足题目条件：
- (0, 2, 4) 因为 4 != 2 != 3
- (1, 2, 4) 因为 4 != 2 != 3
- (2, 3, 4) 因为 2 != 4 != 3
共计 3 个三元组，返回 3 。
注意 (2, 0, 4) 不是有效的三元组，因为 2 > 0 。

示例 2：

输入：nums = [1,1,1,1,1]
输出：0
解释：不存在满足条件的三元组，所以返回 0 。

提示：

3 <= nums.length <= 100
1 <= nums[i] <= 1000

方法一：枚举

记数组 nums 的大小为 n，使用三重循环，枚举所有 0 ≤ i < j < k < n 的三元组，如果三元组 (i, j, k) 满足 nums[i] ≠ nums[j]、nums[i] ≠ nums[k] 且 nums[j] ≠ nums[k]，那么将结果加 1，枚举结束后返回最终结果。

代码：

class Solution {
public:
    int unequalTriplets(vector<int>& nums) {
        int res = 0, n = nums.size();
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                for (int k = j + 1; k < n; k++) {
                    if (nums[i] != nums[j] && nums[i] != nums[k] && nums[j] != nums[k]) {
                        res++;
                    }
                }
            }
        }
        return res;
    }
};

执行用时：60 ms, 在所有 C++ 提交中击败了44.06%的用户
内存消耗：8.2 MB, 在所有 C++ 提交中击败了87.36%的用户
复杂度分析
时间复杂度：O(n³)，其中 n 是数组 nums 的大小。
空间复杂度：O(1)。

方法二：排序

由题意可知，数组元素的相对顺序不影响结果，因此我们可以将数组 nums 从小到大进行排序。排序后，数组中的相同元素一定是相邻的。当我们以某一堆相同的数 [i, j) 作为三元组的中间元素时，这堆相同的元素的左边元素数目为 i，右边元素数目为 n − j，那么符合条件的三元组数目为：

i × (j − i) × (n − j)

对以上结果求和并返回最终结果。

代码：

class Solution {
public:
    int unequalTriplets(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int res = 0, n = nums.size();
        for (int i = 0, j = 0; i < n; i = j) {
            while (j < n && nums[j] == nums[i]) {
                j++;
            }
            res += i * (j - i) * (n - j);
        }
        return res;
    }
};

执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
内存消耗：8.2 MB, 在所有 C++ 提交中击败了68.58%的用户
复杂度分析
时间复杂度：O(nlogn)，其中 n 是数组 nums 的大小。主要为排序所需的时间。
空间复杂度：O(logn)。排序所需的栈空间。

方法三：哈希表

类似于方法二，我们可以使用哈希表 count 记录各个元素的数目，然后遍历哈希表（此时数组元素按照哈希表的遍历顺序进行排列），记当前遍历的元素数目 v，先前遍历的元素总数目为 t，那么以当前遍历的元素为中间元素的符合条件的三元组数目为：

t × v × (n − t − v)

对以上结果求和并返回最终结果。

代码：

class Solution {
public:
    int unequalTriplets(vector<int>& nums) {
        unordered_map<int, int> count;
        for (auto x : nums) {
            count[x]++;
        }
        int res = 0, n = nums.size(), t = 0;
        for (auto [_, v] : count) {
            res += t * v * (n - t - v);
            t += v;
        }
        return res;
    }
};

执行用时：4 ms, 在所有 C++ 提交中击败了85.44%的用户
内存消耗：8.5 MB,在所有 C++ 提交中击败了20.69%的用户
复杂度分析
时间复杂度：O(n)，其中 n 是数组 nums 的大小。
空间复杂度：O(n)。保存哈希表所需的空间。
author：LeetCode-Solution