Citadel·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

Jun 2026

Summary

Citadel software engineer interview with a classic DP stock trading problem. Nothing too surprising if you've done your LC hard prep, but the constraint on k transactions is the part that trips people up.

Questions Asked (1)

Given an integer k and a prices array, find the maximum profit you can make with at most k buy-sell transactions, where you can only hold one share at a time.

Algorithms & Data Structures

Author's notes

The three-dimensional DP state is what gets you: day, number of transactions used, and whether you're currently holding.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the problem constraints and edge cases, then propose a dynamic programming solution that tracks the maximum profit for each transaction count and holding state. Optimize space and time by using rolling arrays and considering the relationship between k and the number of days.

Pro tip: Mention that if k is at least half the number of days, the problem reduces to unlimited transactions, allowing a simpler greedy solution. This shows you understand the problem's structure and can optimize accordingly.

1. Clarify requirements and edge cases

Ask about constraints: size of prices array, range of k, whether k can exceed the number of possible transactions, and if prices can be empty. Confirm that only one share can be held at a time.

2. Define DP state and recurrence

Define dp[i][j][0] as max profit up to day i with at most j transactions and no stock held, and dp[i][j][1] with stock held. Write recurrences: dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + price[i]), dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0] - price[i]).

3. Optimize space and handle large k

Reduce space to O(k) by using rolling arrays for the previous day. If k >= n/2, switch to the greedy unlimited transactions solution to avoid O(nk) time when k is large.

4. Implement and test

Code the DP with careful initialization (e.g., dp[0][j][0]=0, dp[0][j][1]=-inf). Test with edge cases: empty array, k=0, increasing/decreasing prices, and k larger than possible transactions.

5. Analyze complexity and discuss trade-offs

State time complexity O(nk) and space O(k). Discuss alternative approaches like state machine DP or divide-and-conquer if applicable, and explain why DP is suitable here.

Key Points to Mention

Dynamic programming with states for day, transactions used, and holding status.
Space optimization using rolling arrays to reduce from O(nk) to O(k).
Special case when k >= n/2: reduce to unlimited transactions and solve greedily in O(n).
Initialization details: dp[0][j][0] = 0, dp[0][j][1] = -infinity, and handling j=0.
Time complexity O(nk) and space complexity O(k), with trade-offs for large k.
Edge cases: empty prices, k=0, and prices with no profit.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.