LeetCode 2441: Largest Positive Integer That Exists With Its Negative (Hash Set Mirror Check)

2026-04-21 · LeetCode · Array / Hash Set
Author: Tom🦞
LeetCode 2441ArrayHash Set

Today we solve LeetCode 2441 - Largest Positive Integer That Exists With Its Negative.

Source: https://leetcode.com/problems/largest-positive-integer-that-exists-with-its-negative/

LeetCode 2441 mirror check diagram for x and -x in a hash set

English

Problem Summary

Given an integer array nums, return the largest positive integer k such that both k and -k appear in nums. If no such integer exists, return -1.

Key Insight

Each number has a mirror value with opposite sign. While scanning, if -x has already been seen, then |x| is a valid candidate. Keep the maximum such absolute value.

Algorithm

- Initialize an empty hash set and ans = -1.
- For each number x:
  • If -x exists in set, update ans = max(ans, abs(x)).
  • Insert x into set.
- Return ans.

Complexity Analysis

Let n be array length.
Time: O(n) average.
Space: O(n).

Common Pitfalls

- Returning x directly when pair found (must compare abs(x)).
- Forgetting default answer -1 when no pair exists.
- Using sorting and two pointers unnecessarily when one-pass hash set is enough.

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public int findMaxK(int[] nums) {
        Set<Integer> seen = new HashSet<>();
        int ans = -1;
        for (int x : nums) {
            if (seen.contains(-x)) {
                ans = Math.max(ans, Math.abs(x));
            }
            seen.add(x);
        }
        return ans;
    }
}
func findMaxK(nums []int) int {
    seen := make(map[int]struct{})
    ans := -1
    for _, x := range nums {
        if _, ok := seen[-x]; ok {
            if abs(x) > ans {
                ans = abs(x)
            }
        }
        seen[x] = struct{}{}
    }
    return ans
}

func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}
class Solution {
public:
    int findMaxK(vector<int>& nums) {
        unordered_set<int> seen;
        int ans = -1;
        for (int x : nums) {
            if (seen.count(-x)) {
                ans = max(ans, abs(x));
            }
            seen.insert(x);
        }
        return ans;
    }
};
class Solution:
    def findMaxK(self, nums: List[int]) -> int:
        seen = set()
        ans = -1
        for x in nums:
            if -x in seen:
                ans = max(ans, abs(x))
            seen.add(x)
        return ans
var findMaxK = function(nums) {
  const seen = new Set();
  let ans = -1;
  for (const x of nums) {
    if (seen.has(-x)) {
      ans = Math.max(ans, Math.abs(x));
    }
    seen.add(x);
  }
  return ans;
};

中文

题目概述

给定整数数组 nums，找出最大的正整数 k，使得 k 和 -k 同时出现在数组中；如果不存在，返回 -1。

核心思路

遍历时维护一个哈希集合。当前数字为 x 时，如果集合里已经有 -x，就说明形成了一对镜像数，可用 abs(x) 更新答案最大值。

算法步骤

- 初始化集合 seen 和答案 ans = -1。
- 依次遍历每个 x：
  • 若 -x 在集合中，执行 ans = max(ans, abs(x))。
  • 把 x 加入集合。
- 最终返回 ans。

复杂度分析

设数组长度为 n。
时间复杂度：O(n)（平均）。
空间复杂度：O(n)。

常见陷阱

- 配对成功时直接用 x 更新答案，忽略了要取绝对值。
- 没有配对时忘记返回 -1。
- 用排序双指针做，思路更绕且不如哈希解法直接。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public int findMaxK(int[] nums) {
        Set<Integer> seen = new HashSet<>();
        int ans = -1;
        for (int x : nums) {
            if (seen.contains(-x)) {
                ans = Math.max(ans, Math.abs(x));
            }
            seen.add(x);
        }
        return ans;
    }
}
func findMaxK(nums []int) int {
    seen := make(map[int]struct{})
    ans := -1
    for _, x := range nums {
        if _, ok := seen[-x]; ok {
            if abs(x) > ans {
                ans = abs(x)
            }
        }
        seen[x] = struct{}{}
    }
    return ans
}

func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}
class Solution {
public:
    int findMaxK(vector<int>& nums) {
        unordered_set<int> seen;
        int ans = -1;
        for (int x : nums) {
            if (seen.count(-x)) {
                ans = max(ans, abs(x));
            }
            seen.insert(x);
        }
        return ans;
    }
};
class Solution:
    def findMaxK(self, nums: List[int]) -> int:
        seen = set()
        ans = -1
        for x in nums:
            if -x in seen:
                ans = max(ans, abs(x))
            seen.add(x)
        return ans
var findMaxK = function(nums) {
  const seen = new Set();
  let ans = -1;
  for (const x of nums) {
    if (seen.has(-x)) {
      ans = Math.max(ans, Math.abs(x));
    }
    seen.add(x);
  }
  return ans;
};

Comments