Sure! Here is a test case generator for the given problem statement about painting the dominoes on a 2xN grid:

```python
import random
import string

def generate_valid_domino_placement(N):
    letters = string.ascii_letters
    used_letters = set()
    
    def get_new_letter():
        letter = random.choice(letters)
        while letter in used_letters:
            letter = random.choice(letters)
        used_letters.add(letter)
        return letter
    
    S1 = []
    S2 = []
    i = 0
    while i < N:
        if random.choice([True, False]):  # Decide to place vertical or horizontal domino
            if i + 1 < N and (i == 0 or S1[i-1] != S1[i-2] and S2[i-1] != S2[i-2]):
                # Place a horizontal domino
                letter = get_new_letter()
                S1.extend([letter, letter])
                S2.extend([letter, letter])
                i += 2
            else:
                # Place a vertical domino
                letter = get_new_letter()
                S1.append(letter)
                S2.append(letter)
                i += 1
        else:
            # Place a vertical domino
            letter = get_new_letter()
            S1.append(letter)
            S2.append(letter)
            i += 1
    
    return ''.join(S1[:N]), ''.join(S2[:N])

def tcgen():
    N = random.randint(1, 52)
    S1, S2 = generate_valid_domino_placement(N)
    return N, S1, S2

# Example usage:
N, S1, S2 = tcgen()
print(N)
print(S1)
print(S2)
```

### Explanation:
- **Function `generate_valid_domino_placement(N)`**: This function generates two strings `S1` and `S2` that represent a valid arrangement of dominoes on a 2xN grid.
  - It ensures that each domino is represented by the same letter in adjacent cells.
  - It randomly decides whether to place the dominos vertically (occupying one cell in each row) or horizontally (occupying two adjacent cells in a row), ensuring a valid placement.
- **Function `tcgen()`**: This function generates a random test case:
  - It generates a random number \( N \) (1 ≤ \( N \) ≤ 52).
  - It generates the two strings `S1` and `S2` representing the domino placement.
  - It returns \( N \), `S1`, and `S2`.

This generator will ensure that the constraints are met and the input is valid for the problem statement.