```python
def tri(n):
    """Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in 
    the last couple centuries. However, what people don't know is Tribonacci sequence.
    Tribonacci sequence is defined by the recurrence:
    tri(1) = 3
    tri(n) = 1 + n / 2, if n is even.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
    For example:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8 
    You are given a non-negative integer number n, you have to a return a list of the 
    first n + 1 numbers of the Tribonacci sequence.
    Examples:
    tri(3) = [1, 3, 2, 8]
    """
    # We need to compute tri(0), tri(1), ..., tri(n)
    # tri(0) is not explicitly defined, but from the example tri(3) = [1, 3, 2, 8],
    # we can infer that tri(0) = 1.
    # Let's verify: tri(1) = 3, tri(2) = 2, tri(3) = 8, tri(4) = 3
    # tri(3) = tri(2) + tri(1) + tri(4) = 2 + 3 + 3 = 8 ✓
    # tri(4) = 1 + 4/2 = 3 ✓
    # tri(2) = 1 + 2/2 = 2 ✓
    # tri(1) = 3 ✓
    # tri(0) = 1 (from the example output [1, 3, 2, 8])
    
    if n < 0:
        return []
    
    # We need to compute values up to n, but for odd n, we need tri(n+1).
    # So we need to compute up to n+1 at least.
    # Let's compute all values from 0 to n+1.
    
    # Initialize a dictionary or list for computed values
    # We'll compute iteratively.
    
    # First, let's figure out the base cases:
    # tri(0) = 1
    # tri(1) = 3
    # tri(2) = 2
    # tri(4) = 3
    
    # For odd n, tri(n) depends on tri(n+1), which creates a dependency.
    # We need to solve this carefully.
    
    # Let's compute values from 0 upward.
    # For even n: tri(n) = 1 + n/2
    # For odd n: tri(n) = tri(n-1) + tri(n-2) + tri(n+1)
    
    # The issue is that for odd n, we need tri(n+1), which is even, so tri(n+1) = 1 + (n+1)/2.
    # So for odd n, tri(n) = tri(n-1) + tri(n-2) + (1 + (n+1)/2)
    
    # Let's verify with n=3:
    # tri(3) = tri(2) + tri(1) + tri(4)
    # tri(4) = 1 + 4/2 = 3
    # tri(3) = 2 + 3 + 3 = 8 ✓
    
    # So for odd n, we can compute tri(n) once we have tri(n-1), tri(n-2), and tri(n+1).
    # tri(n+1) for odd n is even, so tri(n+1) = 1 + (n+1)/2.
    
    # Let's compute from 0 to n.
    # We need tri(0) = 1, tri(1) = 3.
    # For n >= 2:
    #   if n is even: tri(n) = 1 + n/2
    #   if n is odd: tri(n) = tri(n-1) + tri(n-2) + tri(n+1)
    #     but tri(n+1) = 1 + (n+1)/2 (since n+1 is even)
    
    # So for odd n >= 3:
    #   tri(n) = tri(n-1) + tri(n-2) + 1 + (n+1)/2
    
    # Let's verify n=3:
    # tri(3) = tri(2) + tri(1) + 1 + (3+1)/2 = 2 + 3 + 1 + 2 = 8 ✓
    
    # n=5:
    # tri(5) = tri(4) + tri(3) + 1 + (5+1)/2 = 3 + 8 + 1 + 3 = 15
    
    # n=1: tri(1) = 3 (given)
    # n=0: tri(0) = 1 (inferred from example)
    
    # Let's compute the list from 0 to n.
    
    result = [0] * (n + 1)
    
    if n >= 0:
        result[0] = 1
    if n >= 1:
        result[1] = 3
    if n >= 2:
        result[2] = 2
    
    for i in range(3, n + 1):
        if i % 2 == 0:
            result[i] = 1 + i // 2
        else:
            # i is odd, i >= 3
            # tri(i) = tri(i-1) + tri(i-2) + tri(i+1)
            # tri(i+1) = 1 + (i+1)//2
            result[i] = result[i - 1] + result[i - 2] + 1 + (i + 1) // 2
    
    return result
```