Move from brute-force thinking to an efficient approach using dynamic programming strategy.
On day 1, one person discovers a secret.
You are given an integer delay, which means that each person will share the secret with a new person every day, starting from delay days after discovering the secret. You are also given an integer forget, which means that each person will forget the secret forget days after discovering it. A person cannot share the secret on the same day they forgot it, or on any day afterwards.
Given an integer n, return the number of people who know the secret at the end of day n. Since the answer may be very large, return it modulo 109 + 7.
Example 1:
Input: n = 6, delay = 2, forget = 4 Output: 5 Explanation: Day 1: Suppose the first person is named A. (1 person) Day 2: A is the only person who knows the secret. (1 person) Day 3: A shares the secret with a new person, B. (2 people) Day 4: A shares the secret with a new person, C. (3 people) Day 5: A forgets the secret, and B shares the secret with a new person, D. (3 people) Day 6: B shares the secret with E, and C shares the secret with F. (5 people)
Example 2:
Input: n = 4, delay = 1, forget = 3 Output: 6 Explanation: Day 1: The first person is named A. (1 person) Day 2: A shares the secret with B. (2 people) Day 3: A and B share the secret with 2 new people, C and D. (4 people) Day 4: A forgets the secret. B, C, and D share the secret with 3 new people. (6 people)
Constraints:
2 <= n <= 10001 <= delay < forget <= nProblem summary: On day 1, one person discovers a secret. You are given an integer delay, which means that each person will share the secret with a new person every day, starting from delay days after discovering the secret. You are also given an integer forget, which means that each person will forget the secret forget days after discovering it. A person cannot share the secret on the same day they forgot it, or on any day afterwards. Given an integer n, return the number of people who know the secret at the end of day n. Since the answer may be very large, return it modulo 109 + 7.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Dynamic Programming
6 2 4
4 1 3
Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2327: Number of People Aware of a Secret
class Solution {
public int peopleAwareOfSecret(int n, int delay, int forget) {
final int mod = (int) 1e9 + 7;
int m = (n << 1) + 10;
long[] d = new long[m];
long[] cnt = new long[m];
cnt[1] = 1;
for (int i = 1; i <= n; ++i) {
if (cnt[i] > 0) {
d[i] = (d[i] + cnt[i]) % mod;
d[i + forget] = (d[i + forget] - cnt[i] + mod) % mod;
int nxt = i + delay;
while (nxt < i + forget) {
cnt[nxt] = (cnt[nxt] + cnt[i]) % mod;
++nxt;
}
}
}
long ans = 0;
for (int i = 1; i <= n; ++i) {
ans = (ans + d[i]) % mod;
}
return (int) ans;
}
}
// Accepted solution for LeetCode #2327: Number of People Aware of a Secret
func peopleAwareOfSecret(n int, delay int, forget int) int {
m := (n << 1) + 10
d := make([]int, m)
cnt := make([]int, m)
mod := int(1e9) + 7
cnt[1] = 1
for i := 1; i <= n; i++ {
if cnt[i] == 0 {
continue
}
d[i] = (d[i] + cnt[i]) % mod
d[i+forget] = (d[i+forget] - cnt[i] + mod) % mod
nxt := i + delay
for nxt < i+forget {
cnt[nxt] = (cnt[nxt] + cnt[i]) % mod
nxt++
}
}
ans := 0
for i := 1; i <= n; i++ {
ans = (ans + d[i]) % mod
}
return ans
}
# Accepted solution for LeetCode #2327: Number of People Aware of a Secret
class Solution:
def peopleAwareOfSecret(self, n: int, delay: int, forget: int) -> int:
m = (n << 1) + 10
d = [0] * m
cnt = [0] * m
cnt[1] = 1
for i in range(1, n + 1):
if cnt[i]:
d[i] += cnt[i]
d[i + forget] -= cnt[i]
nxt = i + delay
while nxt < i + forget:
cnt[nxt] += cnt[i]
nxt += 1
mod = 10**9 + 7
return sum(d[: n + 1]) % mod
// Accepted solution for LeetCode #2327: Number of People Aware of a Secret
impl Solution {
pub fn people_aware_of_secret(n: i32, delay: i32, forget: i32) -> i32 {
let n = n as usize;
let delay = delay as usize;
let forget = forget as usize;
let m = (n << 1) + 10;
let modulo: i64 = 1_000_000_007;
let mut d = vec![0i64; m];
let mut cnt = vec![0i64; m];
cnt[1] = 1;
for i in 1..=n {
if cnt[i] > 0 {
d[i] = (d[i] + cnt[i]) % modulo;
d[i + forget] = (d[i + forget] - cnt[i] + modulo) % modulo;
let mut nxt = i + delay;
while nxt < i + forget {
cnt[nxt] = (cnt[nxt] + cnt[i]) % modulo;
nxt += 1;
}
}
}
let mut ans: i64 = 0;
for i in 1..=n {
ans = (ans + d[i]) % modulo;
}
ans as i32
}
}
// Accepted solution for LeetCode #2327: Number of People Aware of a Secret
function peopleAwareOfSecret(n: number, delay: number, forget: number): number {
const mod = 1e9 + 7;
const m = (n << 1) + 10;
const d: number[] = Array(m).fill(0);
const cnt: number[] = Array(m).fill(0);
cnt[1] = 1;
for (let i = 1; i <= n; ++i) {
if (cnt[i] > 0) {
d[i] = (d[i] + cnt[i]) % mod;
d[i + forget] = (d[i + forget] - cnt[i] + mod) % mod;
let nxt = i + delay;
while (nxt < i + forget) {
cnt[nxt] = (cnt[nxt] + cnt[i]) % mod;
++nxt;
}
}
}
let ans = 0;
for (let i = 1; i <= n; ++i) {
ans = (ans + d[i]) % mod;
}
return ans;
}
Use this to step through a reusable interview workflow for this problem.
Pure recursion explores every possible choice at each step. With two choices per state (take or skip), the decision tree has 2ⁿ leaves. The recursion stack uses O(n) space. Many subproblems are recomputed exponentially many times.
Each cell in the DP table is computed exactly once from previously solved subproblems. The table dimensions determine both time and space. Look for the state variables — each unique combination of state values is one cell. Often a rolling array can reduce space by one dimension.
Review these before coding to avoid predictable interview regressions.
Wrong move: An incomplete state merges distinct subproblems and caches incorrect answers.
Usually fails on: Correctness breaks on cases that differ only in hidden state.
Fix: Define state so each unique subproblem maps to one DP cell.