等差數列之1726. 同積元組

前言

一，1726. 同積元組

給你一個由 不同 正整數組成的數組 nums ，請你返回滿足 a * b = c * d 的元組 (a, b, c, d) 的數量。其中 a、b、c 和 d 都是 nums 中的元素，且 a != b != c != d 。

示例 1：

輸入：nums = [2,3,4,6]
輸出：8
解釋：存在 8 個滿足題意的元組：
(2,6,3,4) , (2,6,4,3) , (6,2,3,4) , (6,2,4,3)
(3,4,2,6) , (3,4,2,6) , (3,4,6,2) , (4,3,6,2)
示例 2：

輸入：nums = [1,2,4,5,10]
輸出：16
解釋：存在 16 個滿足題意的元組：
(1,10,2,5) , (1,10,5,2) , (10,1,2,5) , (10,1,5,2)
(2,5,1,10) , (2,5,10,1) , (5,2,1,10) , (5,2,10,1)
(2,10,4,5) , (2,10,5,4) , (10,2,4,5) , (10,2,4,5)
(4,5,2,10) , (4,5,10,2) , (5,4,2,10) , (5,4,10,2)
示例 3：

輸入：nums = [2,3,4,6,8,12]
輸出：40
示例 4：

輸入：nums = [2,3,5,7]
輸出：0

提示：

1 <= nums.length <= 1000
1 <= nums[i] <= 104
nums 中的所有元素 互不相同
通過次數2,960提交次數7,399

鏈接

二， 解題思路

根據題意可以理解爲求得目標值的 和LeetCode上兩數之和是一樣的題型

那個這個目標值就要保存到哈希表中了查詢的時候時間複雜度 O ( 1 ) O(1) O(1)

題中題意提示我們nums 中的所有元素 互不相同所以不需要去重和排序了

1. 直接結算目標值保存到哈希表
2. 哈希表中的個數大於1是就要使用等差數列結算出元組的個數

等差數列的公式

a n = a 1 + ( n − 1 ) ∗ d a_n = a_1 +(n-1)*d an​=a1​+(n−1)∗d

S n = n ∗ a 1 + ( n − 1 ) n 2 ∗ d S_n = n*a_1 + \frac{(n-1)n}{2} *d Sn​=n∗a1​+2(n−1)n​∗d

d是公差

舉例分析

nums = [ 2 , 3 , 4 , 6 , 8 , 12 ] [2,3,4,6,8,12] [2,3,4,6,8,12]

組合有

[2,  3]  => 6
[2,  4]  => 8
[2,  6]  => 12
[2,  8]  => 16
[2, 12]  => 24
[3,  4]  => 12
[3,  6]  => 18
[3,  8]  => 24
[3, 12]  => 36
[4,  6]  => 24
[4,  8]  => 32
[4, 12]  => 48
[6,  8]  => 48
[6, 12]  => 72
[8, 12]  => 96

目標值有target = [ 6 , 8 , 12 , 16 , 18 , 24 , 32 , 48 , 72 , 96 ] [ 6, 8, 12, 16,18, 24, 32, 48, 72, 96 ] [6,8,12,16,18,24,32,48,72,96]

target[6]= 1
target[8]= 1
target[12]= 2
target[16]= 1
target[18]= 1
target[24]= 3
target[32]= 1
target[36]= 1
target[48]= 2
target[72]= 1
target[96]= 1

其中有目標值target[24]=3

這個需要使用等差數列來求和 大於目標值的個數大於等於2要使用等差數列求和

公差是1

a 1 = 0 a1=0 a1=0

帶入公式求得個數是 n ∗ 0 + a ( n − 1 ) a n 2 ∗ 1 = 3 ∗ 2 2 = 3 n*0 + \frac{a_(n-1)a_n}{2} *1 = \frac{3*2}{2} = 3 n∗0+2a(​n−1)an​​∗1=23∗2​=3

三， 代碼

class Solution {
   
   
public:
    int tupleSameProduct(vector<int>& nums) 
    {
   
   
        int count = 0;
        //時間複雜度降低到O(N^2)
        std::unordered_map<long long , int>  m_target;
        for (int i = 0; i < nums.size(); ++i)
        {
   
   
            for (int j = i+1; j < nums.size(); ++j)
            {
   
   
                if (i != j)
                {
   
   
                    ++m_target[nums[i]* nums[j]];
                }
            }
        }
        for (const std::pair<long long , int> &_pair: m_target)
        {
   
   
            if (_pair.second> 1)
            {
   
   
                //等差數列求和公式 [n (a1) + (a(n-1) +an)/2 ]
                count += ((_pair.second*(_pair.second-1))*4) ;
            }
        }
        return count;
    }
};

時間複雜度 O ( N 2 ) O(N^2) O(N2)
空間複雜度 O ( N ) O(N) O(N)

總結