Student Attendance Record II - Practice Coding Problems

Student Attendance Record II - Problem

Dynamic Programming Hard

A school wants to determine how many different valid attendance records of length n are possible for awarding perfect attendance certificates.

Each day in an attendance record is marked with one of three characters:

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

To qualify for an attendance award, a student must meet both criteria:

Be absent ('A') for strictly fewer than 2 days total (0 or 1 absence)
Never be 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 the award. Since the answer can be very large, return it modulo 10⁹ + 7.

Example: For n = 2, valid records include "PP", "AP", "PA", "LP", "PL", "AL", "LA", "LL" (8 total).

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: 8

💡 Note: Valid 2-day records: "PP", "AP", "PA", "LP", "PL", "AL", "LA", "LL". All have ≤1 absence and no 3+ consecutive lates.

example_2.py — Single Day

$ Input: n = 1

› Output: 3

💡 Note: Valid 1-day records: "P", "A", "L". All single characters automatically satisfy both criteria.

example_3.py — Edge Case

$ Input: n = 10101

› Output: 183236316

💡 Note: For large n, the answer involves complex DP calculations and must be returned modulo 10^9 + 7.

Constraints

1 ≤ n ≤ 10⁵
Answer fits in 32-bit integer after taking modulo
Must handle large n efficiently

Visualization

Tap to expand

Understanding the Visualization

State Definition

Each state tracks: current day, total absences (0 or 1), consecutive lates (0, 1, or 2)

Valid Transitions

From each state, we can add P (always), A (if no prior absence), or L (if <2 consecutive)

Count Accumulation

Instead of generating sequences, we count how many ways to reach each valid state

Final Answer

Sum all ways to reach any valid final state after n days

Key Takeaway

🎯 Key Insight: Transform the problem from sequence generation to state counting using DP, reducing complexity from O(3^n) to O(n)

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses dynamic programming with state tracking. We maintain states representing (position, absence_count, consecutive_late_count) and count valid transitions. This avoids generating all 3^n sequences and achieves O(n) time complexity with careful state management.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (State Tracking)	O(n)	O(n)	Track attendance states (absence count, consecutive lates) using DP
Brute Force (Generate All Sequences)	O(3^n)	O(n)	Generate all possible attendance sequences and validate each one

Dynamic Programming (State Tracking) — Algorithm Steps

Define DP state as dp[i][j][k] = count of valid sequences of length i, j absences, k consecutive lates
Initialize base case: dp[0][0][0] = 1
For each position, try adding A, L, or P
Update states based on transitions
Sum all valid final states where j < 2 and k < 3

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with dp[0][0][0] = 1 (empty sequence)

Transitions

For each state, try adding A, L, P with constraints

Build Up

Accumulate valid sequences at each position

Final Sum

Sum all valid final states

Code -

solution.c — C

#include <stdio.h>

#define MOD 1000000007

int checkRecord(int n) {
    // dp[i][j][k] = count of sequences of length i, j absences, k consecutive lates
    long long dp[n + 1][2][3];
    
    // Initialize all to 0
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 3; k++) {
                dp[i][j][k] = 0;
            }
        }
    }
    
    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'
                dp[i + 1][j][0] = (dp[i + 1][j][0] + dp[i][j][k]) % MOD;
                
                // Add 'A'
                if (j == 0) {
                    dp[i + 1][1][0] = (dp[i + 1][1][0] + dp[i][j][k]) % MOD;
                }
                
                // Add 'L'
                if (k < 2) {
                    dp[i + 1][j][k + 1] = (dp[i + 1][j][k + 1] + dp[i][j][k]) % MOD;
                }
            }
        }
    }
    
    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", checkRecord(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We have at most 2 * 3 * n states, and each transition is O(1)

✓ Linear Growth

Space Complexity

O(n)

DP table size is 2 * 3 * n, can be optimized to O(1) with rolling array

⚡ Linearithmic Space

41.2K Views

Medium Frequency

~35 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

Dynamic Programming (State Tracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler