diff --git a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/README.md b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/README.md
index 2163c4ba89643..b406cea4d2d56 100644
--- a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/README.md	
+++ b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/README.md	
@@ -88,32 +88,90 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3461.Ch
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：模拟
+
+我们可以模拟题目描述的操作，直到字符串 $s$ 中只剩下两个数字为止，判断这两个数字是否相同。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 为字符串 $s$ 的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def hasSameDigits(self, s: str) -> bool:
+        t = list(map(int, s))
+        n = len(t)
+        for k in range(n - 1, 1, -1):
+            for i in range(k):
+                t[i] = (t[i] + t[i + 1]) % 10
+        return t[0] == t[1]
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public boolean hasSameDigits(String s) {
+        char[] t = s.toCharArray();
+        int n = t.length;
+        for (int k = n - 1; k > 1; --k) {
+            for (int i = 0; i < k; ++i) {
+                t[i] = (char) ((t[i] - '0' + t[i + 1] - '0') % 10 + '0');
+            }
+        }
+        return t[0] == t[1];
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    bool hasSameDigits(string s) {
+        int n = s.size();
+        string t = s;
+        for (int k = n - 1; k > 1; --k) {
+            for (int i = 0; i < k; ++i) {
+                t[i] = (t[i] - '0' + t[i + 1] - '0') % 10 + '0';
+            }
+        }
+        return t[0] == t[1];
+    }
+};
 ```
 
 #### Go
 
 ```go
+func hasSameDigits(s string) bool {
+	t := []byte(s)
+	n := len(t)
+	for k := n - 1; k > 1; k-- {
+		for i := 0; i < k; i++ {
+			t[i] = (t[i]-'0'+t[i+1]-'0')%10 + '0'
+		}
+	}
+	return t[0] == t[1]
+}
+```
 
+#### TypeScript
+
+```ts
+function hasSameDigits(s: string): boolean {
+    const t = s.split('').map(Number);
+    const n = t.length;
+    for (let k = n - 1; k > 1; --k) {
+        for (let i = 0; i < k; ++i) {
+            t[i] = (t[i] + t[i + 1]) % 10;
+        }
+    }
+    return t[0] === t[1];
+}
 ```
 
 <!-- tabs:end -->
diff --git a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/README_EN.md b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/README_EN.md
index 97de013ed3d8c..6fc69644e5610 100644
--- a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/README_EN.md	
+++ b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/README_EN.md	
@@ -86,32 +86,90 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3461.Ch
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Simulation
+
+We can simulate the operations described in the problem until the string $s$ contains exactly two digits, and then check if these two digits are the same.
+
+The time complexity is $O(n^2)$, and the space complexity is $O(n)$. Here, $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def hasSameDigits(self, s: str) -> bool:
+        t = list(map(int, s))
+        n = len(t)
+        for k in range(n - 1, 1, -1):
+            for i in range(k):
+                t[i] = (t[i] + t[i + 1]) % 10
+        return t[0] == t[1]
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public boolean hasSameDigits(String s) {
+        char[] t = s.toCharArray();
+        int n = t.length;
+        for (int k = n - 1; k > 1; --k) {
+            for (int i = 0; i < k; ++i) {
+                t[i] = (char) ((t[i] - '0' + t[i + 1] - '0') % 10 + '0');
+            }
+        }
+        return t[0] == t[1];
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    bool hasSameDigits(string s) {
+        int n = s.size();
+        string t = s;
+        for (int k = n - 1; k > 1; --k) {
+            for (int i = 0; i < k; ++i) {
+                t[i] = (t[i] - '0' + t[i + 1] - '0') % 10 + '0';
+            }
+        }
+        return t[0] == t[1];
+    }
+};
 ```
 
 #### Go
 
 ```go
+func hasSameDigits(s string) bool {
+	t := []byte(s)
+	n := len(t)
+	for k := n - 1; k > 1; k-- {
+		for i := 0; i < k; i++ {
+			t[i] = (t[i]-'0'+t[i+1]-'0')%10 + '0'
+		}
+	}
+	return t[0] == t[1]
+}
+```
 
+#### TypeScript
+
+```ts
+function hasSameDigits(s: string): boolean {
+    const t = s.split('').map(Number);
+    const n = t.length;
+    for (let k = n - 1; k > 1; --k) {
+        for (let i = 0; i < k; ++i) {
+            t[i] = (t[i] + t[i + 1]) % 10;
+        }
+    }
+    return t[0] === t[1];
+}
 ```
 
 <!-- tabs:end -->
diff --git a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.cpp b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.cpp
new file mode 100644
index 0000000000000..e9ffb42ea88cb
--- /dev/null
+++ b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.cpp	
@@ -0,0 +1,13 @@
+class Solution {
+public:
+    bool hasSameDigits(string s) {
+        int n = s.size();
+        string t = s;
+        for (int k = n - 1; k > 1; --k) {
+            for (int i = 0; i < k; ++i) {
+                t[i] = (t[i] - '0' + t[i + 1] - '0') % 10 + '0';
+            }
+        }
+        return t[0] == t[1];
+    }
+};
diff --git a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.go b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.go
new file mode 100644
index 0000000000000..32043ab9f7279
--- /dev/null
+++ b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.go	
@@ -0,0 +1,10 @@
+func hasSameDigits(s string) bool {
+	t := []byte(s)
+	n := len(t)
+	for k := n - 1; k > 1; k-- {
+		for i := 0; i < k; i++ {
+			t[i] = (t[i]-'0'+t[i+1]-'0')%10 + '0'
+		}
+	}
+	return t[0] == t[1]
+}
diff --git a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.java b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.java
new file mode 100644
index 0000000000000..fec4b4f79eba1
--- /dev/null
+++ b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public boolean hasSameDigits(String s) {
+        char[] t = s.toCharArray();
+        int n = t.length;
+        for (int k = n - 1; k > 1; --k) {
+            for (int i = 0; i < k; ++i) {
+                t[i] = (char) ((t[i] - '0' + t[i + 1] - '0') % 10 + '0');
+            }
+        }
+        return t[0] == t[1];
+    }
+}
diff --git a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.py b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.py
new file mode 100644
index 0000000000000..ff73194dfdf42
--- /dev/null
+++ b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.py	
@@ -0,0 +1,8 @@
+class Solution:
+    def hasSameDigits(self, s: str) -> bool:
+        t = list(map(int, s))
+        n = len(t)
+        for k in range(n - 1, 1, -1):
+            for i in range(k):
+                t[i] = (t[i] + t[i + 1]) % 10
+        return t[0] == t[1]
diff --git a/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.ts b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.ts
new file mode 100644
index 0000000000000..394b7061fa8b2
--- /dev/null
+++ b/solution/3400-3499/3461.Check If Digits Are Equal in String After Operations I/Solution.ts	
@@ -0,0 +1,10 @@
+function hasSameDigits(s: string): boolean {
+    const t = s.split('').map(Number);
+    const n = t.length;
+    for (let k = n - 1; k > 1; --k) {
+        for (let i = 0; i < k; ++i) {
+            t[i] = (t[i] + t[i + 1]) % 10;
+        }
+    }
+    return t[0] === t[1];
+}
diff --git a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/README.md b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/README.md
index 3ffa6e1211320..9e611932efe20 100644
--- a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/README.md	
+++ b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/README.md	
@@ -76,32 +76,163 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3462.Ma
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：贪心 + 优先队列（小根堆）
+
+我们可以用一个优先队列（小根堆） $\textit{pq}$ 来维护最大的 $k$ 个元素。
+
+遍历每一行，对每一行的元素进行排序，然后取出每一行最大的 $\textit{limit}$ 个元素，将这些元素加入 $\textit{pq}$ 中。如果 $\textit{pq}$ 的大小超过了 $k$，就将堆顶元素弹出。
+
+最后，将 $\textit{pq}$ 中的元素相加即可。
+
+时间复杂度 $O(n \times m \times (\log m + \log k))$，空间复杂度 $O(k)$。其中 $n$ 和 $m$ 分别为矩阵 $\textit{grid}$ 的行数和列数。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def maxSum(self, grid: List[List[int]], limits: List[int], k: int) -> int:
+        pq = []
+        for nums, limit in zip(grid, limits):
+            nums.sort()
+            for _ in range(limit):
+                heappush(pq, nums.pop())
+                if len(pq) > k:
+                    heappop(pq)
+        return sum(pq)
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long maxSum(int[][] grid, int[] limits, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        int n = grid.length;
+        for (int i = 0; i < n; ++i) {
+            int[] nums = grid[i];
+            int limit = limits[i];
+            Arrays.sort(nums);
+            for (int j = 0; j < limit; ++j) {
+                pq.offer(nums[nums.length - j - 1]);
+                if (pq.size() > k) {
+                    pq.poll();
+                }
+            }
+        }
+        long ans = 0;
+        for (int x : pq) {
+            ans += x;
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long maxSum(vector<vector<int>>& grid, vector<int>& limits, int k) {
+        priority_queue<int, vector<int>, greater<int>> pq;
+        int n = grid.size();
+
+        for (int i = 0; i < n; ++i) {
+            vector<int> nums = grid[i];
+            int limit = limits[i];
+            ranges::sort(nums);
+
+            for (int j = 0; j < limit; ++j) {
+                pq.push(nums[nums.size() - j - 1]);
+                if (pq.size() > k) {
+                    pq.pop();
+                }
+            }
+        }
+
+        long long ans = 0;
+        while (!pq.empty()) {
+            ans += pq.top();
+            pq.pop();
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+type MinHeap []int
+
+func (h MinHeap) Len() int           { return len(h) }
+func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] }
+func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *MinHeap) Push(x interface{}) {
+	*h = append(*h, x.(int))
+}
+func (h *MinHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}
+
+func maxSum(grid [][]int, limits []int, k int) int64 {
+	pq := &MinHeap{}
+	heap.Init(pq)
+	n := len(grid)
+
+	for i := 0; i < n; i++ {
+		nums := make([]int, len(grid[i]))
+		copy(nums, grid[i])
+		limit := limits[i]
+		sort.Ints(nums)
+
+		for j := 0; j < limit; j++ {
+			heap.Push(pq, nums[len(nums)-j-1])
+			if pq.Len() > k {
+				heap.Pop(pq)
+			}
+		}
+	}
+
+	var ans int64 = 0
+	for pq.Len() > 0 {
+		ans += int64(heap.Pop(pq).(int))
+	}
+
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function maxSum(grid: number[][], limits: number[], k: number): number {
+    const pq = new MinPriorityQueue();
+    const n = grid.length;
+    for (let i = 0; i < n; i++) {
+        const nums = grid[i];
+        const limit = limits[i];
+        nums.sort((a, b) => a - b);
+        for (let j = 0; j < limit; j++) {
+            pq.enqueue(nums[nums.length - j - 1]);
+            if (pq.size() > k) {
+                pq.dequeue();
+            }
+        }
+    }
+    let ans = 0;
+    while (!pq.isEmpty()) {
+        ans += pq.dequeue() as number;
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->
diff --git a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/README_EN.md b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/README_EN.md
index f2fcaa0641b40..52635f560ad25 100644
--- a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/README_EN.md	
+++ b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/README_EN.md	
@@ -74,32 +74,163 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3462.Ma
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Greedy + Priority Queue (Min-Heap)
+
+We can use a priority queue (min-heap) $\textit{pq}$ to maintain the largest $k$ elements.
+
+Traverse each row, sort the elements in each row, and then take the largest $\textit{limit}$ elements from each row and add them to $\textit{pq}$. If the size of $\textit{pq}$ exceeds $k$, pop the top element of the heap.
+
+Finally, sum the elements in $\textit{pq}$.
+
+The time complexity is $O(n \times m \times (\log m + \log k))$, and the space complexity is $O(k)$. Here, $n$ and $m$ are the number of rows and columns of the matrix $\textit{grid}$, respectively.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def maxSum(self, grid: List[List[int]], limits: List[int], k: int) -> int:
+        pq = []
+        for nums, limit in zip(grid, limits):
+            nums.sort()
+            for _ in range(limit):
+                heappush(pq, nums.pop())
+                if len(pq) > k:
+                    heappop(pq)
+        return sum(pq)
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long maxSum(int[][] grid, int[] limits, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        int n = grid.length;
+        for (int i = 0; i < n; ++i) {
+            int[] nums = grid[i];
+            int limit = limits[i];
+            Arrays.sort(nums);
+            for (int j = 0; j < limit; ++j) {
+                pq.offer(nums[nums.length - j - 1]);
+                if (pq.size() > k) {
+                    pq.poll();
+                }
+            }
+        }
+        long ans = 0;
+        for (int x : pq) {
+            ans += x;
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long maxSum(vector<vector<int>>& grid, vector<int>& limits, int k) {
+        priority_queue<int, vector<int>, greater<int>> pq;
+        int n = grid.size();
+
+        for (int i = 0; i < n; ++i) {
+            vector<int> nums = grid[i];
+            int limit = limits[i];
+            ranges::sort(nums);
+
+            for (int j = 0; j < limit; ++j) {
+                pq.push(nums[nums.size() - j - 1]);
+                if (pq.size() > k) {
+                    pq.pop();
+                }
+            }
+        }
+
+        long long ans = 0;
+        while (!pq.empty()) {
+            ans += pq.top();
+            pq.pop();
+        }
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+type MinHeap []int
+
+func (h MinHeap) Len() int           { return len(h) }
+func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] }
+func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *MinHeap) Push(x interface{}) {
+	*h = append(*h, x.(int))
+}
+func (h *MinHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}
+
+func maxSum(grid [][]int, limits []int, k int) int64 {
+	pq := &MinHeap{}
+	heap.Init(pq)
+	n := len(grid)
+
+	for i := 0; i < n; i++ {
+		nums := make([]int, len(grid[i]))
+		copy(nums, grid[i])
+		limit := limits[i]
+		sort.Ints(nums)
+
+		for j := 0; j < limit; j++ {
+			heap.Push(pq, nums[len(nums)-j-1])
+			if pq.Len() > k {
+				heap.Pop(pq)
+			}
+		}
+	}
+
+	var ans int64 = 0
+	for pq.Len() > 0 {
+		ans += int64(heap.Pop(pq).(int))
+	}
+
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function maxSum(grid: number[][], limits: number[], k: number): number {
+    const pq = new MinPriorityQueue();
+    const n = grid.length;
+    for (let i = 0; i < n; i++) {
+        const nums = grid[i];
+        const limit = limits[i];
+        nums.sort((a, b) => a - b);
+        for (let j = 0; j < limit; j++) {
+            pq.enqueue(nums[nums.length - j - 1]);
+            if (pq.size() > k) {
+                pq.dequeue();
+            }
+        }
+    }
+    let ans = 0;
+    while (!pq.isEmpty()) {
+        ans += pq.dequeue() as number;
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->
diff --git a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.cpp b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.cpp
new file mode 100644
index 0000000000000..31787a8865065
--- /dev/null
+++ b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.cpp	
@@ -0,0 +1,28 @@
+class Solution {
+public:
+    long long maxSum(vector<vector<int>>& grid, vector<int>& limits, int k) {
+        priority_queue<int, vector<int>, greater<int>> pq;
+        int n = grid.size();
+
+        for (int i = 0; i < n; ++i) {
+            vector<int> nums = grid[i];
+            int limit = limits[i];
+            ranges::sort(nums);
+
+            for (int j = 0; j < limit; ++j) {
+                pq.push(nums[nums.size() - j - 1]);
+                if (pq.size() > k) {
+                    pq.pop();
+                }
+            }
+        }
+
+        long long ans = 0;
+        while (!pq.empty()) {
+            ans += pq.top();
+            pq.pop();
+        }
+
+        return ans;
+    }
+};
diff --git a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.go b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.go
new file mode 100644
index 0000000000000..ecee6c1b7a278
--- /dev/null
+++ b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.go	
@@ -0,0 +1,42 @@
+type MinHeap []int
+
+func (h MinHeap) Len() int           { return len(h) }
+func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] }
+func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h *MinHeap) Push(x interface{}) {
+	*h = append(*h, x.(int))
+}
+func (h *MinHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}
+
+func maxSum(grid [][]int, limits []int, k int) int64 {
+	pq := &MinHeap{}
+	heap.Init(pq)
+	n := len(grid)
+
+	for i := 0; i < n; i++ {
+		nums := make([]int, len(grid[i]))
+		copy(nums, grid[i])
+		limit := limits[i]
+		sort.Ints(nums)
+
+		for j := 0; j < limit; j++ {
+			heap.Push(pq, nums[len(nums)-j-1])
+			if pq.Len() > k {
+				heap.Pop(pq)
+			}
+		}
+	}
+
+	var ans int64 = 0
+	for pq.Len() > 0 {
+		ans += int64(heap.Pop(pq).(int))
+	}
+
+	return ans
+}
diff --git a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.java b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.java
new file mode 100644
index 0000000000000..e3e6ea5725080
--- /dev/null
+++ b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public long maxSum(int[][] grid, int[] limits, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        int n = grid.length;
+        for (int i = 0; i < n; ++i) {
+            int[] nums = grid[i];
+            int limit = limits[i];
+            Arrays.sort(nums);
+            for (int j = 0; j < limit; ++j) {
+                pq.offer(nums[nums.length - j - 1]);
+                if (pq.size() > k) {
+                    pq.poll();
+                }
+            }
+        }
+        long ans = 0;
+        for (int x : pq) {
+            ans += x;
+        }
+        return ans;
+    }
+}
diff --git a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.py b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.py
new file mode 100644
index 0000000000000..7294af8e83b32
--- /dev/null
+++ b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.py	
@@ -0,0 +1,10 @@
+class Solution:
+    def maxSum(self, grid: List[List[int]], limits: List[int], k: int) -> int:
+        pq = []
+        for nums, limit in zip(grid, limits):
+            nums.sort()
+            for _ in range(limit):
+                heappush(pq, nums.pop())
+                if len(pq) > k:
+                    heappop(pq)
+        return sum(pq)
diff --git a/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.ts b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.ts
new file mode 100644
index 0000000000000..423fa62f909ec
--- /dev/null
+++ b/solution/3400-3499/3462.Maximum Sum With at Most K Elements/Solution.ts	
@@ -0,0 +1,20 @@
+function maxSum(grid: number[][], limits: number[], k: number): number {
+    const pq = new MinPriorityQueue();
+    const n = grid.length;
+    for (let i = 0; i < n; i++) {
+        const nums = grid[i];
+        const limit = limits[i];
+        nums.sort((a, b) => a - b);
+        for (let j = 0; j < limit; j++) {
+            pq.enqueue(nums[nums.length - j - 1]);
+            if (pq.size() > k) {
+                pq.dequeue();
+            }
+        }
+    }
+    let ans = 0;
+    while (!pq.isEmpty()) {
+        ans += pq.dequeue() as number;
+    }
+    return ans;
+}