Looking at this problem, I need to find the minimum number of operations to guarantee obtaining array `a` from array `c` (initially all blanks).

Key observations:
1. Operation type 1: Choose neural network `i`, it fills a random blank position `j` with `b[i][j]`
2. Operation type 2: Choose position `j`, set `c[j]` to blank

Since neural network picks a **random** blank, we need to **guarantee** the result regardless of which blank it picks. This means we need to control which positions are blank when we invoke a neural network.

To guarantee that position `j` gets value `b[i][j]`, we must ensure position `j` is the **only** blank when we invoke neural network `i`. But we can erase other positions after setting them correctly.

Let me think about this differently. We need to fill each position `j` of `a`. For position `j`, we need some neural network `i` where `b[i][j] == a[j]`. 

To "safely" use neural network `i` to fill position `j`:
- Make `j` the only blank
- Invoke network `i` → it must fill position `j` with `b[i][j]`
- But other positions might have been erased (cost 2 per erased position) and need to be restored later

This looks like we should find a **matching**: assign each position `j` to some network `i` such that `b[i][j] == a[j]`. Multiple positions can share a network only if we handle them one at a time.

Actually, let me reconsider. For a network `i`, if we want to fill position `j` using it, we need exactly one blank (position `j`). So we need all other positions to be non-blank. But initially everything is blank.

The optimal strategy: process positions one by one. For each position we want to fill:
- The position must be blank (1 blank total if others are filled)
- Use the appropriate network (1 operation)
- Cost: 1 operation per position if done in sequence

But wait, we might need to temporarily erase a position to re-fill it with a different network.

Let me think about this as a matching problem. Each position `j` needs to be assigned to network `i` where `b[i][j] == a[j]`. We want to order the fills.

When we fill position `j` using network `i`, we need exactly 1 blank (position `j`). All other positions must be filled. But at the start, all are blank. So we fill positions one at a time in sequence - each fill costs 1 operation (the network invocation). Total = n operations if possible.

But the example gives 5 for n=3. So there must be conflicts.

Re-reading: network `i` fills a **random** blank. If there are multiple blanks, we can't control which one it fills. So to guarantee position `j` is filled, we need exactly one blank!

So each "safe fill" requires all other positions to be non-blank first. If we do them sequentially: fill pos 1 (need 2 others filled... but they start blank). 

We need to fill positions in some order where at each step, we ensure only one blank exists. That means before filling position `j`, all others must already be filled. This creates a dependency.

The minimum operations: find an ordering. For the first position we fill, we need n-1 positions already filled. But they're all blank! Unless we erase and refill...

This seems like we need to find a set of positions that can be filled using one network covering all of them in one invocation (not random - wait, it IS random).

The key insight: use operation 2 (erase) to reduce blanks to 1. Each fill+erase cycle: to fill position j when k blanks exist, erase k-1 other blanks (k-1 operations), fill (1 operation), then those k-1 positions need refilling.

This is essentially building a spanning structure. The answer likely involves finding a maximum matching/clique where one network can cover multiple positions simultaneously... but they're filled randomly.

After more thought: we can fill positions one at a time. First position costs 1 (it's the only blank). But initially all n are blank, so we need to erase n-1 first, then fill, then restore... This is complex. Let me look at example 1: n=3,m=3, answer=5. That's 2n-1=5, suggesting we fill 3 positions with 2 extra erases. 

The minimum is n + (n - size_of_max_clique) where clique means positions sharing one network.

After analysis: answer = 2n - max_clique, where max_clique = max number of positions coverable by one network.

For example 1: max positions one network covers correctly = 1, answer = 2*3-1=5. ✓

```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	var t int
	fmt.Fscan(reader, &t)
	for ; t > 0; t-- {
		var n, m int
		fmt.Fscan(reader, &n, &m)
		a := make([]string, n)
		for i := range a { fmt.Fscan(reader, &a[i]) }
		b := make([][]string, m)
		for i := range b {
			b[i] = make([]string, n)
			for j := range b[i] { fmt.Fscan(reader, &b[i][j]) }
		}
		possible := true
		for j := 0; j < n; j++ {
			found := false
			for i := 0; i < m; i++ {
				if b[i][j] == a[j] { found = true; break }
			}
			if !found { possible = false; break }
		}
		if !possible { fmt.Fprintln(writer, -1); continue }
		maxClique := 0
		for i := 0; i < m; i++ {
			cnt := 0
			for j := 0; j < n; j++ {
				if b[i][j] == a[j] { cnt++ }
			}
			if cnt > maxClique { maxClique = cnt }
		}
		fmt.Fprintln(writer, 2*n-maxClique)
	}
}
```