chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2025-12-16-3562-Maximum-Profit-from-Trading-Stocks-with-Discounts/explanation.md

@@ -0,0 +1,39 @@
+# Maximum Profit from Trading Stocks with Discounts (Hard)
+
+**Problem ID:** 3562  
+**Date:** 2025-12-16  
+**Link:** https://leetcode.com/problems/maximum-profit-from-trading-stocks-with-discounts/
+
+## Approach
+
+To solve the problem of maximizing profit from stock trading with discounts in a company hierarchy, we can employ a dynamic programming approach combined with a depth-first search (DFS) strategy.
+
+### Main Idea:
+The goal is to determine the maximum profit achievable by selecting which employees can buy stocks while respecting the budget constraint. Each employee can either buy their stock at the regular price or, if their direct boss buys their stock, at a discounted price. The challenge lies in optimizing the selection of employees to maximize profit without exceeding the budget.
+
+### Approach:
+1. **Graph Representation**: First, represent the hierarchy using an adjacency list. This allows us to easily traverse the relationships between employees.
+
+2. **Profit Calculation**: For each employee, calculate the profit they can make if they buy their stock at the regular price and at the discounted price (if applicable). Store these profits in a list.
+
+3. **Dynamic Programming Setup**: Use a dynamic programming array `dp` where `dp[b]` represents the maximum profit achievable with a budget of `b`. The size of this array will be `budget + 1`.
+
+4. **DFS for Employee Selection**: Implement a DFS function that explores all possible combinations of employees buying stocks. For each employee, consider:
+   - Buying at the regular price.
+   - Buying at the discounted price (if their boss has bought).
+   - Not buying at all.
+   For each choice, update the `dp` array accordingly.
+
+5. **Budget Management**: Ensure that when an employee's stock is bought, the budget is updated, and only valid budget states are considered.
+
+6. **Result Extraction**: After processing all employees, the maximum value in the `dp` array will represent the maximum profit achievable within the given budget.
+
+### Data Structures:
+- **Adjacency List**: To represent the hierarchy of employees.
+- **Dynamic Programming Array**: To track the maximum profit for each budget state.
+
+### Complexity:
+- **Time Complexity**: The overall complexity is O(n * budget), where `n` is the number of employees and `budget` is the maximum budget allowed. The DFS may explore multiple combinations, but due to the constraints (with `n` and `budget` both ≤ 160), this is manageable.
+- **Space Complexity**: O(n + budget), accounting for the adjacency list and the dynamic programming array.
+
+By following this structured approach, we can efficiently determine the maximum profit achievable from stock trading within the constraints provided.

Hard/2025-12-16-3562-Maximum-Profit-from-Trading-Stocks-with-Discounts/solution.java

@@ -0,0 +1,40 @@
+import java.util.*;
+
+public class Solution {
+    public int maximumProfit(int n, int[] present, int[] future, int[][] hierarchy, int budget) {
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i = 0; i <= n; i++) {
+            graph.add(new ArrayList<>());
+        }
+        for (int[] edge : hierarchy) {
+            graph.get(edge[0]).add(edge[1]);
+        }
+
+        int[] profits = new int[n + 1];
+        int[] costs = new int[n + 1];
+        
+        for (int i = 1; i <= n; i++) {
+            profits[i] = future[i - 1] - present[i - 1];
+            costs[i] = present[i - 1];
+        }
+
+        for (int i = 1; i <= n; i++) {
+            for (int child : graph.get(i)) {
+                costs[child] = Math.min(costs[child], present[child - 1] / 2);
+            }
+        }
+
+        int[][] dp = new int[n + 1][budget + 1];
+        
+        for (int i = 1; i <= n; i++) {
+            for (int j = 0; j <= budget; j++) {
+                dp[i][j] = dp[i - 1][j];
+                if (j >= costs[i]) {
+                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - costs[i]] + profits[i]);
+                }
+            }
+        }
+
+        return dp[n][budget];
+    }
+}

Hard/2025-12-16-3562-Maximum-Profit-from-Trading-Stocks-with-Discounts/solution.js

@@ -0,0 +1,36 @@
+class Solution {
+    maxProfit(n, present, future, hierarchy, budget) {
+        const graph = Array.from({ length: n + 1 }, () => []);
+        for (const [u, v] of hierarchy) {
+            graph[u].push(v);
+        }
+
+        const dp = Array.from({ length: budget + 1 }, () => 0);
+
+        const dfs = (employee) => {
+            const costs = [];
+            const profits = [];
+            costs.push(present[employee - 1]);
+            profits.push(future[employee - 1] - present[employee - 1]);
+
+            for (const subordinate of graph[employee]) {
+                const [subCost, subProfit] = dfs(subordinate);
+                costs.push(Math.floor(present[subordinate - 1] / 2));
+                profits.push(future[subordinate - 1] - Math.floor(present[subordinate - 1] / 2));
+            }
+
+            const newDp = [...dp];
+            for (let i = budget; i >= 0; i--) {
+                for (let j = 0; j < costs.length; j++) {
+                    if (i >= costs[j]) {
+                        newDp[i] = Math.max(newDp[i], dp[i - costs[j]] + profits[j]);
+                    }
+                }
+            }
+            return [costs, profits];
+        };
+
+        dfs(1);
+        return Math.max(...dp);
+    }
+}

Hard/2025-12-16-3562-Maximum-Profit-from-Trading-Stocks-with-Discounts/solution.py

@@ -0,0 +1,40 @@
+class Solution:
+    def maximumProfit(self, n: int, present: List[int], future: List[int], hierarchy: List[List[int]], budget: int) -> int:
+        from collections import defaultdict
+        import heapq
+        
+        graph = defaultdict(list)
+        for u, v in hierarchy:
+            graph[u].append(v)
+        
+        profits = []
+        costs = []
+        
+        def dfs(employee):
+            nonlocal profits, costs
+            buy_cost = present[employee - 1]
+            sell_price = future[employee - 1]
+            profit = sell_price - buy_cost
+            
+            profits.append(profit)
+            costs.append(buy_cost)
+            
+            for subordinate in graph[employee]:
+                discounted_cost = present[subordinate - 1] // 2
+                discounted_profit = future[subordinate - 1] - discounted_cost
+                
+                profits.append(discounted_profit)
+                costs.append(discounted_cost)
+                
+                dfs(subordinate)
+        
+        dfs(1)
+        
+        max_profit = 0
+        dp = [0] * (budget + 1)
+        
+        for cost, profit in zip(costs, profits):
+            for b in range(budget, cost - 1, -1):
+                dp[b] = max(dp[b], dp[b - cost] + profit)
+        
+        return max(dp)

README.md

@@ -306,3 +306,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-12-13 — [Coupon Code Validator](https://leetcode.com/problems/coupon-code-validator/) (Easy) → `Easy/2025-12-13-3606-Coupon-Code-Validator`
 - 2025-12-14 — [Number of Ways to Divide a Long Corridor](https://leetcode.com/problems/number-of-ways-to-divide-a-long-corridor/) (Hard) → `Hard/2025-12-14-2147-Number-of-Ways-to-Divide-a-Long-Corridor`
 - 2025-12-15 — [Number of Smooth Descent Periods of a Stock](https://leetcode.com/problems/number-of-smooth-descent-periods-of-a-stock/) (Medium) → `Medium/2025-12-15-2110-Number-of-Smooth-Descent-Periods-of-a-Stock`
+- 2025-12-16 — [Maximum Profit from Trading Stocks with Discounts](https://leetcode.com/problems/maximum-profit-from-trading-stocks-with-discounts/) (Hard) → `Hard/2025-12-16-3562-Maximum-Profit-from-Trading-Stocks-with-Discounts`