N-th Tribonacci Number

N-th Tribonacci Number - Problem

The Tribonacci sequence T_n is defined as follows:

T₀ = 0
T₁ = 1
T₂ = 1
T_n+3 = T_n + T_n+1 + T_n+2 for n ≥ 0

Given n, return the value of T_n.

Note: This is a variation of the famous Fibonacci sequence where each term is the sum of the three preceding ones instead of two.

Input & Output

Example 1 — Small Value

$ Input: n = 4

› Output: 4

💡 Note: T(4) = T(1) + T(2) + T(3) = 1 + 1 + 2 = 4. The sequence is: T(0)=0, T(1)=1, T(2)=1, T(3)=2, T(4)=4.

Example 2 — Base Case

$ Input: n = 0

› Output: 0

💡 Note: T(0) = 0 by definition. This is one of the base cases.

Example 3 — Another Base Case

$ Input: n = 2

› Output: 1

💡 Note: T(2) = 1 by definition. Both T(1) and T(2) equal 1 as base cases.

Constraints

0 ≤ n ≤ 37
The answer is guaranteed to fit in a 32-bit integer

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 a Amazon 8

The key insight is that Tribonacci numbers follow a pattern where each term equals the sum of the three preceding terms. The optimal approach uses space-optimized dynamic programming with only 3 variables instead of storing all values. Time: O(n), Space: O(1).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Create an array to store all Tribonacci values from 0 to n. Fill the array iteratively, where each position uses the three previous values. This avoids recursion entirely.

Memoized Recursion

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

Use a hash map or array to store previously calculated Tribonacci values. When a recursive call is made, first check if the result is already cached before computing it.

Recursive Brute Force

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

Calculate T(n) by recursively calling T(n-1) + T(n-2) + T(n-3). This follows the mathematical definition exactly but recalculates the same values multiple times.

Space-Optimized DP

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

Since each Tribonacci number only depends on the previous 3 values, we don't need to store the entire array. Use 3 variables to keep track of the last 3 computed values and slide the window as we compute each new value.

Bottom-Up Dynamic Programming — Algorithm Steps

Create array of size n+1
Initialize base cases: dp[0]=0, dp[1]=1, dp[2]=1
Fill array: dp[i] = dp[i-1] + dp[i-2] + dp[i-3] for i from 3 to n

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

Initialize dp[0]=0, dp[1]=1, dp[2]=1

Fill Array

Each dp[i] = sum of previous 3 values

Result

dp[n] contains the final answer

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int solution(int n) {
    if (n == 0) return 0;
    if (n == 1 || n == 2) return 1;
    
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    dp[0] = 0;
    dp[1] = 1;
    dp[2] = 1;
    
    for (int i = 3; i <= n; i++) {
        dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
    }
    
    int result = dp[n];
    free(dp);
    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 from 3 to n, each iteration does constant work

✓ Linear Growth

Space Complexity

O(n)

DP array stores all values from T(0) to T(n)

⚡ Linearithmic Space

180.0K Views

Medium Frequency

~15 min Avg. Time

2.2K 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