Problem p03748 - Generation 2

Orig Description

Score : 900 points
Problem StatementJoisino has a lot of red and blue bricks and a large box.
She will build a tower of these bricks in the following manner.
First, she will pick a total of N bricks and put them into the box.
Here, there may be any number of bricks of each color in the box, as long as there are N bricks in total.
Particularly, there may be zero red bricks or zero blue bricks.
Then, she will repeat an operation M times, which consists of the following three steps:
Take out an arbitrary brick from the box.
Put one red brick and one blue brick into the box.
Take out another arbitrary brick from the box.
After the M operations, Joisino will build a tower by stacking the 2 \times M bricks removed from the box, in the order they are taken out.
She is interested in the following question: how many different sequences of colors of these 2 \times M bricks are possible?
Write a program to find the answer.
Since it can be extremely large, print the count modulo 10^9+7.
Constraints
1 \leq N \leq 3000
1 \leq M \leq 3000
InputInput is given from Standard Input in the following format:
N M
OutputPrint the count of the different possible sequences of colors of 2 \times M bricks that will be stacked, modulo 10^9+7.
Sample Input 12 3
Sample Output 156
A total of six bricks will be removed from the box. The only impossible sequences of colors of these bricks are the ones where the colors of the second, third, fourth and fifth bricks are all the same. Therefore, there are 2^6 - 2 \times 2 \times 2 = 56 possible sequences of colors.
Sample Input 21000 10
Sample Output 21048576
Sample Input 31000 3000
Sample Output 3693347555

Extracted Specification

An integer N (1 ≤ N ≤ 3000), representing some quantity or size.
An integer M (1 ≤ M ≤ 3000), representing some quantity or size.

### Example Input:

```
2
3
```

### Function Signature:
Write a function f(N, M) that takes in the input.
def f(N: int, M: int):
    '''
    N: an integer
    M: an integer
    '''

Test Case Generator

To create a test case generator for this problem, we can follow the same pattern as the previous example. We'll generate random values for \(N\) and \(M\) within their respective constraints. Here's the Python code to generate such test cases:

```python
import random

def tcgen():
    # Constraints
    N = random.randint(1, 3000)
    M = random.randint(1, 3000)
    
    return N, M

# Example usage:
for _ in range(5):
    print(tcgen())
```

This code will generate random values for \(N\) and \(M\) within the given constraints (1 ≤ \(N\) ≤ 3000 and 1 ≤ \(M\) ≤ 3000). Each call to `tcgen` will produce a new pair of values.

### Explanation:
1. **N**: Represents the total number of bricks initially put into the box.
2. **M**: Represents the number of operations to be performed, where each operation consists of removing a brick, adding a red and a blue brick, and then removing another brick.

### Example Usage:
Running the `tcgen` function will produce output like:
```
(2856, 1234)
(1731, 2420)
(187, 1990)
(1321, 545)
(899, 2087)
```

Each tuple represents a valid test case for the problem described. These values can be used as inputs to test the solution to the problem.

Extract Arguments

def extract_arguments(fh):
    N, M = map(int, fh.readline().strip().split())
    return N, M