【算法】1913. 两个数对之间的最大乘积差(多语言实现)

简介: 两个数对 (a, b) 和 (c, d) 之间的 乘积差 定义为 (a * b) - (c * d) 。 例如,(5, 6) 和 (2, 7) 之间的乘积差是 (5 * 6) - (2 * 7) = 16 。给你一个整数数组 nums ,选出四个 不同的 下标 w、x、y 和 z ,使数对 (nums[w], nums[x]) 和 (nums[y], nums[z]) 之间的 乘积差 取到 最大值 。返回以这种方式取得的乘积差中的 最大值 。

1913. 两个数对之间的最大乘积差:

两个数对 (a, b)(c, d) 之间的 乘积差 定义为 (a * b) - (c * d)

  • 例如,(5, 6)(2, 7) 之间的乘积差是 (5 * 6) - (2 * 7) = 16

给你一个整数数组 nums ,选出四个 不同的 下标 wxyz ,使数对 (nums[w], nums[x])(nums[y], nums[z]) 之间的 乘积差 取到 最大值

返回以这种方式取得的乘积差中的 最大值

样例 1:

输入:
    nums = [5,6,2,7,4]
    
输出:
    34
    
解释:
    可以选出下标为 1 和 3 的元素构成第一个数对 (6, 7) 以及下标 2 和 4 构成第二个数对 (2, 4)
    乘积差是 (6 * 7) - (2 * 4) = 34

样例 2:

输入:
    nums = [4,2,5,9,7,4,8]
    
输出:
    64
    
解释:
    可以选出下标为 3 和 6 的元素构成第一个数对 (9, 8) 以及下标 1 和 5 构成第二个数对 (2, 4)
    乘积差是 (9 * 8) - (2 * 4) = 64

提示:

  • 4 <= nums.length <= $10^4$
  • 1 <= nums[i] <= $10^4$

分析

  • 面对这道算法题目,首先可以想一下两个正整数如何形成最大差值?
  • 被减数尽可能大,减数尽可能小,就可以有最大差值。
  • 两个正整数的乘积怎么尽可能大呢?
  • 两个正整数尽可能大,他们的乘积就会最大化;反之两个正整数尽可能小,他们的乘积就会最小化。
  • 所以我们其实要找出最大的两个数和最小的两个数。
  • 最大的两个数相乘作为被减数,最小的两个数相乘作为减数。
  • 在一个无序整数数组中如何找到两个最大值和两个最小值呢?
  • 首先想到,可以先排序,然后取最前面两个数和最后面两个数。但是排序至少需要O(nlogn)的时间复杂度。
  • 事实上我们只需要遍历一次,记录下最大的两个数和最小的两个数就可以了。

题解

java

class Solution {
    public int maxProductDifference(int[] nums) {
        int max1 = 0;
        int max2 = 0;
        int min1 = 10001;
        int min2 = 10001;

        for (int num : nums) {
            if (num > max1) {
                max2 = max1;
                max1 = num;
            } else if (num > max2) {
                max2 = num;
            }
            if (num < min1) {
                min2 = min1;
                min1 = num;
            } else if (num < min2) {
                min2 = num;
            }
        }

        return max1 * max2 - min1 * min2;
    }
}

c

int maxProductDifference(int* nums, int numsSize){
    int max1 = 0;
    int max2 = 0;
    int min1 = 10001;
    int min2 = 10001;

    for (int i = 0; i < numsSize; ++i) {
        int num = nums[i];
        if (num > max1) {
            max2 = max1;
            max1 = num;
        } else if (num > max2) {
            max2 = num;
        }
        if (num < min1) {
            min2 = min1;
            min1 = num;
        } else if (num < min2) {
            min2 = num;
        }
    }

    return max1 * max2 - min1 * min2;
}

c++

class Solution {
public:
    int maxProductDifference(vector<int>& nums) {
        int max1 = 0;
        int max2 = 0;
        int min1 = 10001;
        int min2 = 10001;

        for (int num: nums) {
            if (num > max1) {
                max2 = max1;
                max1 = num;
            } else if (num > max2) {
                max2 = num;
            }
            if (num < min1) {
                min2 = min1;
                min1 = num;
            } else if (num < min2) {
                min2 = num;
            }
        }

        return max1 * max2 - min1 * min2;
    }
};

python

class Solution:
    def maxProductDifference(self, nums: List[int]) -> int:
        max1 = 0
        max2 = 0
        min1 = 10001
        min2 = 10001

        for num in nums:
            if num > max1:
                max2 = max1
                max1 = num
            elif num > max2:
                max2 = num
            if num < min1:
                min2 = min1
                min1 = num
            elif num < min2:
                min2 = num;

        return max1 * max2 - min1 * min2
        

go

func maxProductDifference(nums []int) int {
    max1 := 0
    max2 := 0
    min1 := 10001
    min2 := 10001

    for _, num := range nums {
        if num > max1 {
            max2 = max1
            max1 = num
        } else if num > max2 {
            max2 = num
        }
        if num < min1 {
            min2 = min1
            min1 = num
        } else if num < min2 {
            min2 = num
        }
    }

    return max1*max2 - min1*min2
}

rust

impl Solution {
    pub fn max_product_difference(nums: Vec<i32>) -> i32 {
        let mut max1 = 0;
        let mut max2 = 0;
        let mut min1 = 10001;
        let mut min2 = 10001;

        nums.iter().for_each(|num| {
            if *num > max1 {
                max2 = max1;
                max1 = *num;
            } else if *num > max2 {
                max2 = *num;
            }
            if *num < min1 {
                min2 = min1;
                min1 = *num;
            } else if *num < min2 {
                min2 = *num;
            }
        });

        max1 * max2 - min1 * min2
    }
}

原题传送门:https://leetcode-cn.com/problems/maximum-product-difference-between-two-pairs/


非常感谢你阅读本文~
放弃不难,但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子:https://developer.aliyun.com/profile/sqd6avc7qgj7y 博客原创~

相关文章
|
5月前
|
自然语言处理 Rust 算法
【算法】13. 罗马数字转整数(多语言实现)
罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。 | 字符 | 数值 | |--|--| | I | 1 | | V | 5 | | X | 10 | | L | 50 | | C | 100 | | D | 500 | | M | 1000 | 例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。 通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1
【算法】13. 罗马数字转整数(多语言实现)
|
5月前
|
设计模式 算法 Java
【数据结构和算法】除自身以外数组的乘积
给你一个整数数组nums,返回数组answer,其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。题目数据保证数组nums之中任意元素的全部前缀元素和后缀的乘积都在32 位整数范围内。请不要使用除法,且在O(n)时间复杂度内完成此题。
50 1
|
12月前
|
自然语言处理 Rust 算法
【算法】9. 回文数(多语言实现)
给你一个整数 x ,如果 x 是一个回文整数,返回 true ;否则,返回 false 。 回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。例如,121 是回文,而 123 不是。
|
5月前
|
算法 测试技术 vr&ar
☆打卡算法☆LeetCode 152. 乘积最大子数组 算法解析
☆打卡算法☆LeetCode 152. 乘积最大子数组 算法解析
|
3月前
|
自然语言处理 Rust 算法
【算法】17. 电话号码的字母组合(多语言实现)
给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。
【算法】17. 电话号码的字母组合(多语言实现)
|
2月前
|
算法
【算法】前缀和——除自身以外数组的乘积
【算法】前缀和——除自身以外数组的乘积
|
2月前
|
算法 Java 索引
LeetCode初级算法题:寻找数组的中心索引+x的平方根+三个数的最大乘积+Leetcode 149:直线上最多的点数 Java详解
LeetCode初级算法题:寻找数组的中心索引+x的平方根+三个数的最大乘积+Leetcode 149:直线上最多的点数 Java详解
30 0
|
4月前
|
算法 自然语言处理 Rust
【算法】16. 最接近的三数之和(多语言实现)
给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数,使它们的和与 target 最接近。 返回这三个数的和。 假定每组输入只存在恰好一个解。
|
5月前
|
自然语言处理 Rust 算法
【算法】15. 三数之和(多语言实现)
给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ,同时还满足 nums[i] + nums[j] + nums[k] == 0 。请 你返回所有和为 0 且不重复的三元组。 注意:答案中不可以包含重复的三元组。
|
5月前
|
自然语言处理 Rust 算法
【算法】14. 最长公共前缀(多语言实现)
编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀,返回空字符串 ""。
下一篇
无影云桌面