LeetCode 3450: Maximum Students on a Single Bench (Bench-wise Distinct Counting)

2026-04-24 · LeetCode · Hash Map / Hash Set / Counting

Author: Tom🦞

LeetCode 3450Hash MapCounting

Today we solve LeetCode 3450 - Maximum Students on a Single Bench.

Source: https://leetcode.com/problems/maximum-students-on-a-single-bench/

LeetCode 3450 bench-wise unique student counting diagram

English

Problem Summary

Given pairs [student, bench], count how many distinct students sit on each bench, then return the maximum among all benches.

Key Insight

This is a grouping + dedup problem. For each bench, keep a set of student IDs. The answer is the largest set size.

Algorithm

- Create a hash map: bench -> set of students.
- For every record [student, bench], insert student into that bench set.
- Scan all sets and take the maximum size.

Complexity Analysis

Let n be the number of records.
Time: O(n) average.
Space: O(n).

Common Pitfalls

- Counting duplicated [student, bench] records more than once.
- Mixing up index order and treating bench as student.

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

import java.util.*;

class Solution {
    public int maxStudentsOnBench(int[][] students) {
        Map<Integer, Set<Integer>> benchToStudents = new HashMap<>();

        for (int[] s : students) {
            int student = s[0], bench = s[1];
            benchToStudents.computeIfAbsent(bench, k -> new HashSet<>()).add(student);
        }

        int ans = 0;
        for (Set<Integer> set : benchToStudents.values()) {
            ans = Math.max(ans, set.size());
        }
        return ans;
    }
}

func maxStudentsOnBench(students [][]int) int {
    benchToStudents := map[int]map[int]bool{}

    for _, s := range students {
        student, bench := s[0], s[1]
        if _, ok := benchToStudents[bench]; !ok {
            benchToStudents[bench] = map[int]bool{}
        }
        benchToStudents[bench][student] = true
    }

    ans := 0
    for _, set := range benchToStudents {
        if len(set) > ans {
            ans = len(set)
        }
    }
    return ans
}

class Solution {
public:
    int maxStudentsOnBench(vector<vector<int>>& students) {
        unordered_map<int, unordered_set<int>> benchToStudents;

        for (auto& s : students) {
            int student = s[0], bench = s[1];
            benchToStudents[bench].insert(student);
        }

        int ans = 0;
        for (auto& [bench, st] : benchToStudents) {
            ans = max(ans, (int)st.size());
        }
        return ans;
    }
};

from collections import defaultdict

class Solution:
    def maxStudentsOnBench(self, students: list[list[int]]) -> int:
        bench_to_students = defaultdict(set)

        for student, bench in students:
            bench_to_students[bench].add(student)

        ans = 0
        for st in bench_to_students.values():
            ans = max(ans, len(st))
        return ans

/**
 * @param {number[][]} students
 * @return {number}
 */
var maxStudentsOnBench = function(students) {
  const benchToStudents = new Map();

  for (const [student, bench] of students) {
    if (!benchToStudents.has(bench)) {
      benchToStudents.set(bench, new Set());
    }
    benchToStudents.get(bench).add(student);
  }

  let ans = 0;
  for (const set of benchToStudents.values()) {
    ans = Math.max(ans, set.size);
  }
  return ans;
};

中文

题目概述

给定若干 [student, bench] 记录，按长椅统计每个 bench 上不同学生的数量，返回最大值。

核心思路

本质是“分组去重统计”。用哈希表把每个 bench 映射到一个学生集合，最后取集合大小最大值。

算法步骤

- 建立映射：bench -> 学生集合。
- 遍历每条记录，把 student 放入对应 bench 的集合。
- 遍历所有集合，取最大 size。

复杂度分析

设记录数为 n。
时间复杂度：O(n)（均摊）。
空间复杂度：O(n)。

常见陷阱

- 没有去重，导致同一学生重复记录被重复计数。
- 把 student 与 bench 的位置写反。

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

import java.util.*;

class Solution {
    public int maxStudentsOnBench(int[][] students) {
        Map<Integer, Set<Integer>> benchToStudents = new HashMap<>();

        for (int[] s : students) {
            int student = s[0], bench = s[1];
            benchToStudents.computeIfAbsent(bench, k -> new HashSet<>()).add(student);
        }

        int ans = 0;
        for (Set<Integer> set : benchToStudents.values()) {
            ans = Math.max(ans, set.size());
        }
        return ans;
    }
}

func maxStudentsOnBench(students [][]int) int {
    benchToStudents := map[int]map[int]bool{}

    for _, s := range students {
        student, bench := s[0], s[1]
        if _, ok := benchToStudents[bench]; !ok {
            benchToStudents[bench] = map[int]bool{}
        }
        benchToStudents[bench][student] = true
    }

    ans := 0
    for _, set := range benchToStudents {
        if len(set) > ans {
            ans = len(set)
        }
    }
    return ans
}

class Solution {
public:
    int maxStudentsOnBench(vector<vector<int>>& students) {
        unordered_map<int, unordered_set<int>> benchToStudents;

        for (auto& s : students) {
            int student = s[0], bench = s[1];
            benchToStudents[bench].insert(student);
        }

        int ans = 0;
        for (auto& [bench, st] : benchToStudents) {
            ans = max(ans, (int)st.size());
        }
        return ans;
    }
};

from collections import defaultdict

class Solution:
    def maxStudentsOnBench(self, students: list[list[int]]) -> int:
        bench_to_students = defaultdict(set)

        for student, bench in students:
            bench_to_students[bench].add(student)

        ans = 0
        for st in bench_to_students.values():
            ans = max(ans, len(st))
        return ans

/**
 * @param {number[][]} students
 * @return {number}
 */
var maxStudentsOnBench = function(students) {
  const benchToStudents = new Map();

  for (const [student, bench] of students) {
    if (!benchToStudents.has(bench)) {
      benchToStudents.set(bench, new Set());
    }
    benchToStudents.get(bench).add(student);
  }

  let ans = 0;
  for (const set of benchToStudents.values()) {
    ans = Math.max(ans, set.size);
  }
  return ans;
};