Student Attendance Record II

Student Attendance Record II - Problem

Dynamic Programming Hard

An attendance record for a student can be represented as a string where each character signifies whether the student was absent, late, or present on that day. The record only contains the following three characters:

'A': Absent
'L': Late
'P': Present

Any student is eligible for an attendance award if they meet both of the following criteria:

The student was absent ('A') for strictly fewer than 2 days total
The student was never late ('L') for 3 or more consecutive days

Given an integer n, return the number of possible attendance records of length n that make a student eligible for an attendance award.

The answer may be very large, so return it modulo 10⁹ + 7.

Input & Output

Example 1 — Small Case

$ Input: n = 2

› Output: 8

💡 Note: Valid 2-character strings: PP, PL, PA, LP, LL, LA, AP, AL. Invalid: AA (2 absents), LLL would be invalid if n=3

Example 2 — Minimum Size

$ Input: n = 1

› Output: 3

💡 Note: All single characters are valid: P, L, A (none violate the constraints)

Example 3 — Larger Input

$ Input: n = 10101

› Output: 183236316

💡 Note: Large input demonstrating modular arithmetic is required due to exponential growth

Constraints

1 ≤ n ≤ 10⁵
Answer fits in 32-bit integer after modulo operation

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8 a Amazon 12

The key insight is to track attendance state (absent count + consecutive late days) while building valid records. Best approach is bottom-up DP with state transitions for each character choice. Time: O(n), Space: O(n).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n) Space: O(n)

Create a 3D DP table where dp[i][j][k] represents the number of valid attendance strings of length i, with j absents used (0 or 1), and k consecutive lates at the end (0, 1, or 2). Fill the table bottom-up.

Brute Force Recursion

⏱️ Time: O(3ⁿ) Space: O(n)

Try all 3^n possible combinations of 'A', 'L', 'P' for each position. For each complete string, check if it satisfies both criteria: less than 2 absents and no 3+ consecutive lates.

Memoization (Top-Down DP)

⏱️ Time: O(n) Space: O(n)

Use the same recursive approach but store results for each state (position, absent_count, consecutive_late). This eliminates redundant calculations when the same state is reached through different paths.

Bottom-Up Dynamic Programming — Algorithm Steps

Initialize base case: dp[0][0][0] = 1
For each position, calculate transitions for P, A, L
Sum all valid final states where absent count < 2

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base case dp[0][0][0] = 1

Fill Table

For each state, compute transitions P/A/L

Sum Results

Add all valid final states

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

#define MOD 1000000007

int solution(int n) {
    // dp[i][j][k] = valid strings of length i, j absents, k consecutive lates
    static long long dp[100005][2][3];
    memset(dp, 0, sizeof(dp));
    
    // Base case
    dp[0][0][0] = 1;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 3; k++) {
                if (dp[i][j][k] == 0) continue;
                
                // Add 'P' - Present
                dp[i + 1][j][0] = (dp[i + 1][j][0] + dp[i][j][k]) % MOD;
                
                // Add 'A' - Absent
                if (j == 0) {
                    dp[i + 1][1][0] = (dp[i + 1][1][0] + dp[i][j][k]) % MOD;
                }
                
                // Add 'L' - Late
                if (k < 2) {
                    dp[i + 1][j][k + 1] = (dp[i + 1][j][k + 1] + dp[i][j][k]) % MOD;
                }
            }
        }
    }
    
    // Sum all valid final states
    long long result = 0;
    for (int j = 0; j < 2; j++) {
        for (int k = 0; k < 3; k++) {
            result = (result + dp[n][j][k]) % MOD;
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through n positions with constant work per state

✓ Linear Growth

Space Complexity

O(n)

3D DP table with dimensions n×2×3

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler