We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Student Attendance Record II

Difficulty: Hard

Problem Description

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^9 + 7.

Key Insights

  • The attendance records can be constructed using dynamic programming.
  • Use states to represent the number of records with no absences, one absence, and the last occurrence of 'L' to keep track of consecutive lates.
  • The recurrence relations should account for valid transitions between states based on the last character added (either 'P', 'A', or 'L').
  • The constraints of the problem necessitate efficient calculation due to potentially large n (up to 100,000).

Space and Time Complexity

Time Complexity: O(n)
Space Complexity: O(1) (or O(n) if we store all computed values)

Solution

To solve this problem, we can use dynamic programming to track the count of valid attendance records based on the number of days and the conditions provided. We create a DP table to store the number of records with varying characteristics:

  • dp[i][0] for records of length i with 0 'A's.
  • dp[i][1] for records of length i with 1 'A'.
  • We also need to keep track of the last occurrence of 'L' to ensure we do not have three consecutive 'L's.

The algorithm iteratively builds up the count of valid records by considering the addition of 'P', 'A', and 'L', while ensuring to check for the constraints of absences and lates.

Code Solutions

MOD = 10**9 + 7

def checkRecord(n):
    if n == 0:
        return 1

    # dp[i][j] will store the number of valid records of length i with j absences
    dp = [[0] * 2 for _ in range(n + 1)]
    dp[0][0] = 1  # Base case: empty record

    # Fill dp for 0 and 1 absences
    for i in range(1, n + 1):
        dp[i][0] = (dp[i - 1][0] + dp[i - 1][1]) % MOD  # Adding 'P'
        dp[i][1] = dp[i - 1][0] % MOD  # Adding 'A'

    # Now consider the 'L's
    total = (dp[n][0] + dp[n][1]) % MOD
    for i in range(1, n + 1):
        total = (total + dp[i][0] + dp[i][1]) % MOD

    return total

# Example usage
print(checkRecord(2))  # Output: 8
← Back to All Questions