Haskell, 265 bytes

import Data.Maybe import Data.List i=isJust (#)=map a=all h=head j=fromJust t([]:_)=[];t x=(h#x):t(tail#x) v b=a(a(\z->any(a id)$t$(zipWith(==)$j$h z)#(j#z)))$map(filter(i.h).groupBy((.i).(==).i))b f b=v b&&v(t b)&&(a((==1).length)$group$sort$concatMap catMaybes b) 

Attempt This Online!

05AB1E, 71 69 bytes

ø«ε0¡ε€Sø€ËàyD¢*]˜PI˜áD¢4‹PIa©˜ƶIgäΔ2Fø0δ.ø}2Fø€ü3}®*εεÅsyøÅs«à]˜0KËP 

Input as a matrix of 2-char strings, with 0 as gaps. Outputs a 05AB1E truthy/falsey result, so 1 for truthy, or 0 or a positive integer for falsey.

Try it online or verify all test cases.

Explanation:

Step 1: Verify that each connected portion in a row or column is valid, where valid means they're either all the same shape and/or the same color, and in addition there aren't any duplicated pieces in a connected row/column.

ø # Zip/transpose; swapping rows/columns of the (implicit) input-matrix « # Merge this list of columns to the (implicit) input-list of rows ε # Map over each inner row/column: 0¡ # Split it on 0s (the gaps) ε # Map over each connected portion: €S # Split each 2-char string to a pair of characters ø # Zip/transpose; swapping rows/columns €Ë # Check for each inner list whether they're all the same à # Pop and get the maximum, to check if this is truthy for either y # Push the current connected portion again D # Duplicate it ¢ # Pop both, and count how many times each piece occurs * # Multiply the earlier check to each count in the list ] # Close the nested maps ˜ # Flatten the list of list of list of checks P # Check if everything was truthy by taking the product 

Try just this first step online or verify it for all test cases.

Step 2: Check that each individual piece does not occur more than 3 times:

I # Push the input-matrix again ˜ # Flatten it á # Remove all gaps by only keeping the letters D # Duplicate it ¢ # Pop both, and count how many times each piece occurs 4‹ # Check for each that it's smaller than 4 P # Check if everything was truthy by taking the product 

Try just this second step online or verify it for all test cases.

Step 3: Flood-fill the matrix to check if everything is a single connected island (which I've done before in this answer and this answer of mine):

I # Push the input-matrix yet again a # Convert all pieces to 1s with the is_alphabetic builtin © # Store this matrix of 1s/0s in variable `®` (without popping) ˜ # Flatten it ƶ # Multiply each value by its 1-based index Igä # Mold it back to a matrix matching the input: I # Push the input g # Pop and push the length (the amount of rows) ä # Split the list into that many equal-sized parts Δ # Loop until the result no longer changes: 2Fø0δ.ø} # Add a border of 0s around the matrix: 2F } # Loop 2 times: ø # Zip/transpose; swapping rows/columns δ # Map over each inner list: 0 .ø # Surround it with both a leading and trailing 0 2Fø€ü3} # Then split it into overlapping 3x3 blocks: 2F # Loop 2 times again: ø # Zip/transpose; swapping rows/columns again € # Map over each inner list again: ü3 # Split this list into overlapping triplets ®* # Multiply this matrix of 3x3 blocks and matrix `®` together, # so all 3x3 blocks at the 0-positions will become a block of 0s εεÅsyøÅs«à # Get the largest value from the horizontal/vertical cross of each # 3x3 block: εε # Nested map over each 3x3 block: Ås # Pop and push its middle row y # Push the 3x3 block again ø # Zip/transpose; swapping rows/columns Ås # Pop and push its middle row as well (the middle column) « # Merge the middle row and column together to a single list à # Pop and push its maximum ] # Close the nested maps and flood-fill loop ˜ # Flatten the resulting flood-filled matrix 0K # Remove all 0s (the gaps) Ë # Check if all remaining values are the same, so we have a single island 

Try just this third step online or verify it for all test cases.

Step 4: Combine all three checks of the previous steps, and output the result:

P # Simply take the product of all three values on the stack # (which is output implicitly as result) 

J, ^{90 87 85 78} 74 bytes

((#@~."1@|:e.~1,#)@#~*/@,&,[:g+/@])(,:&(-/~)0j1&*)(g=.+./ .*^:_~)"[email protected]:@1 

Try it online!

argument encoding

We take the list positions (encoded as complex numbers) as the right arg, and the list of pieces as the left arg. For example, for the board:

rc,gc,bc __,gs,__ __,gf,__ 

the left and right arguments would look like this (boxed for clarity):

┌──┬─────────────────┐ │rc│0 0j1 0j2 1j1 2j1│ │gc│ │ │bc│ │ │gs│ │ │gf│ │ └──┴─────────────────┘ 

idea

The high-level idea is the interesting part, so I'll focus on that.

1. Find all horizontally connected pieces. To do this, we create an adjacency matrix of all the positions, where adjacency is defined by the distance between two elements being in the set _1 0 1:

    0 0j1 0j2 1j1 2j1 +----------------------- 0 |1 1 0 0 0 0j1 |1 1 1 0 0 0j2 |0 1 1 0 0 1j1 |0 0 0 1 0 2j1 |0 0 0 0 1 

   And then take the transitive closure of that matrix "or-multiplied" by itself until a fixed point. The result shows all the horizontal connections:

    1 1 1 0 0 <- 0 is connected to 0, 0j1, 0j2 1 1 1 0 0 <- 0j1 is connected to 0, 0j1, 0j2 1 1 1 0 0 <- 0j2 is connected to 0, 0j1, 0j2 0 0 0 1 0 <- 1j1 is only connected to itself 0 0 0 0 1 <- 2j1 is only connected to itself 

2. Find all vertically connected pieces. To do this, we reuse the logic in step 1, by first multiplying every position by 0j1, which has the effect of rotating the entire board 45 degress left. Now vertical connections will be horizontal ones. The resulting final matrix this time is:

    1 0 0 0 0 0 1 0 1 1 0 0 1 0 0 0 1 0 1 1 0 1 0 1 1 

3. Next, we use the rows from the previous steps as masks to define the groups of pieces we need to validate:

    ┌──┬──┬──┬──┬──┐ │rc│gc│bc│gc│gc│ <- Vertically connected pieces │ │gs│ │gs│gs│ │ │gf│ │gf│gf│ ├──┼──┼──┼──┼──┤ │rc│rc│rc│gs│gf│ <- Horizontally connected pieces │gc│gc│gc│ │ │ │bc│bc│bc│ │ │ └──┴──┴──┴──┴──┘ 

4. For each group, we validate that one property is all the same, and that the other property is all different. This part should have been easier to golf but the best approach I came up with was (#@~."1@|:e.~1,#). This takes the transpose of the input:

    ggg csf 

   and takes the length of the uniq of each row, giving: 1 3. We then check if both 1 and "input length" are members of that list.

5. Finally, we check that all elements are connected. Here we use our adjacency matrix trick a third time, except now adjacency is defined as a horizontal or vertical connection:

    1 1 0 0 0 1 1 1 1 0 0 1 1 0 0 0 1 0 1 1 0 0 0 1 1 

   and we check that its transitive closure becomes the matrix consisting of all ones:

    1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1