Sure, here's a test case generator for the "G: Restricted DFS" problem statement:

```python
import random

def generate_tree(N):
    edges = []
    for i in range(2, N + 1):
        edges.append((random.randint(1, i - 1), i))
    return edges

def tcgen():
    # Generate a random number of vertices within the given constraints
    N = random.randint(1, 3 * 10**5)
    
    # Generate a list of N integers, each in the range [0, 10^9]
    A = [random.randint(0, 10**9) for _ in range(N)]
    
    # Generate N-1 edges to form a tree
    edges = generate_tree(N)
    
    return N, A, edges

# Example usage:
if __name__ == "__main__":
    N, A, edges = tcgen()
    print(N)
    print(" ".join(map(str, A)))
    for u, v in edges:
        print(u, v)
```

### Explanation:
1. **Number of Vertices (N)**: Randomly generates an integer \( N \) between 1 and 300,000.
2. **List of Integers (A)**: Creates a list of \( N \) random integers, each ranging from 0 to 1,000,000,000.
3. **Tree Edges**: To form a valid tree, we start from vertex 2 to \( N \) and connect each vertex to a random vertex from the previously created vertices. This approach ensures there are no cycles and the graph remains a tree.

### Example Output:
```
3
1 2 3
1 2
1 3
```

This ensures that you get a valid tree structure and adheres to the constraints given. You can call `tcgen()` to generate a variety of test cases for this problem.