import java.io.; import java.util.; import java.util.stream.*;

class Result {

public static String gridSearch(List<String> G, List<String> P) {
    int R = G.size();
    int C = G.get(0).length();
    int r = P.size();
    int c = P.get(0).length();

    for (int i = 0; i <= R - r; i++) {
        for (int j = 0; j <= C - c; j++) {
            boolean found = true;
            for (int k = 0; k < r; k++) {
                if (!G.get(i + k).substring(j, j + c).equals(P.get(k))) {
                    found = false;
                    break;
                }
            }
            if (found) return "YES";
        }
    }
    return "NO";
}

}

public class Solution { public static void main(String[] args) throws IOException { BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

    int t = Integer.parseInt(bufferedReader.readLine().trim());

    for (int tItr = 0; tItr < t; tItr++) {
        String[] firstMultipleInput = bufferedReader.readLine().trim().split(" ");
        int R = Integer.parseInt(firstMultipleInput[0]);
        int C = Integer.parseInt(firstMultipleInput[1]);

        List<String> G = new ArrayList<>();
        for (int i = 0; i < R; i++) {
            G.add(bufferedReader.readLine());
        }

        String[] secondMultipleInput = bufferedReader.readLine().trim().split(" ");
        int r = Integer.parseInt(secondMultipleInput[0]);
        int c = Integer.parseInt(secondMultipleInput[1]);

        List<String> P = new ArrayList<>();
        for (int i = 0; i < r; i++) {
            P.add(bufferedReader.readLine());
        }

        String result = Result.gridSearch(G, P);
        bufferedWriter.write(result);
        bufferedWriter.newLine();
    }

    bufferedReader.close();
    bufferedWriter.close();
}

}

Here my solution

function gridSearch($G, $P) {
    // Write your code here
    $xG = count($G);
    $yG = strlen($G[0]);
    $xP = count($P);
    $yP = strlen($P[0]);
    
    for($x=0; $x<=$xG-$xP; $x++) {
        for ($y=0; $y<=$yG-$yP; $y++) {
            $matchLines = 0;
            for($i=0; $i<$xP; $i++) {
                if(substr($G[$i+$x], $y, $yP) !== $P[$i]) break;
                $matchLines++;
            }
            
            if($matchLines === $xP) return "YES";
        }
    }
    
    return "NO";
}

Tip for C++ implementation: Use pass by reference for passing the grids. This will help clear the largest input, test case 5.

Here is my solution in PHP

    $prows = count($P);
    $grows = count($G);
    $firstRow = array();
    $firstIndex = array();
    
    $result = 'NO';
    for ($i=0; $i <=$grows-($prows-1) ; $i++) { 
        $rowIndex = array();
        $offset = 0;
        while(($str = strpos($G[$i], $P[0],$offset))!== false)
        {
            $rowIndex[] = $str;
            $offset = $str+1;

        }
        $firstRow[$i] = $rowIndex;
    }

 
     foreach ($firstRow as $key => $value) {
         // code...
        if($result == 'YES')
        {
            break;
        }
        if($grows - ($key) >= $prows)
        {
            foreach ($value as $key1 => $value1) {
                 $keyIndex =  $value1;
                 $newKey = 0;
                 $lastIndex = $key+$prows-1;
                
                      for ($i=$key+1; $i <($key+$prows) ; $i++) { 
                         
                      $newKey+=1;
                      
                      $str = strpos($G[$i], $P[$newKey],$value1);
                     
                if ($str !== false && $str == $keyIndex) {
                        if($i == $lastIndex)
                         {
                           $result = 'YES';
                            break;
                         }
                }
               else
               {
                break;
               }

             
           }
           
            }
         
         
   
        }
        else
        {
            continue;
        }
     }    
 return $result;

never says it should be exactly under... reputation management experts it states if the patterns is found in the string... it is found, they are not at the same indexes except IPTV, but I didn't found that requirement in the specifications.