description: There is a grid, consisting of n rows and m columns. Each cell of the grid is either free or blocked. One of the free cells contains a lab. All the cells beyond the borders of the grid are also blocked.
  
  A crazy robot has escaped from this lab. It is currently in some free cell of the grid. You can send one of the following commands to the robot: "move right", "move down", "move left" or "move up". Each command means moving to a neighbouring cell in the corresponding direction.
  
  However, as the robot is crazy, it will do anything except following the command. Upon receiving a command, it will choose a direction such that it differs from the one in command and the cell in that direction is not blocked. If there is such a direction, then it will move to a neighbouring cell in that direction. Otherwise, it will do nothing.
  
  We want to get the robot to the lab to get it fixed. For each free cell, determine if the robot can be forced to reach the lab starting in this cell. That is, after each step of the robot a command can be sent to a robot such that no matter what different directions the robot chooses, it will end up in a lab.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
  
  The first line of each testcase contains two integers n and m (1 ≤ n, m ≤ 10^6; n ⋅ m ≤ 10^6) — the number of rows and the number of columns in the grid.
  
  The i-th of the next n lines provides a description of the i-th row of the grid. It consists of m elements of one of three types: 
  
    * '.' — the cell is free; 
    * '#' — the cell is blocked; 
    * 'L' — the cell contains a lab. 
  
  
  
  The grid contains exactly one lab. The sum of n ⋅ m over all testcases doesn't exceed 10^6.
  
  Output
  
  For each testcase find the free cells that the robot can be forced to reach the lab from. Given the grid, replace the free cells (marked with a dot) with a plus sign ('+') for the cells that the robot can be forced to reach the lab from. Print the resulting grid.
  
  Example
  
  Input
  
  
  4
  3 3
  ...
  .L.
  ...
  4 5
  #....
  ..##L
  ...#.
  .....
  1 1
  L
  1 9
  ....L..#.
  
  
  Output
  
  
  ...
  .L.
  ...
  #++++
  ..##L
  ...#+
  ...++
  L
  ++++L++#.
  
  Note
  
  In the first testcase there is no free cell that the robot can be forced to reach the lab from. Consider a corner cell. Given any direction, it will move to a neighbouring border grid that's not a corner. Now consider a non-corner free cell. No matter what direction you send to the robot, it can choose a different direction such that it ends up in a corner.
  
  In the last testcase, you can keep sending the command that is opposite to the direction to the lab and the robot will have no choice other than move towards the lab.
solution: import java.io.*;
  import java.util.*;
  
  
  public class CodeForces{
      /*-------------------------------------------EDITING CODE STARTS HERE-------------------------------------------*/
  
      public static void main(String[] args) throws IOException{
          openIO();
          int testCase = 1;
          testCase = sc.nextInt();
          for (int i = 1; i <= testCase; i++) solve(i);
          closeIO();
      }
      public static void solve(int tCase)throws IOException {
          int n = sc.nextInt();
          int m = sc.nextInt();
          char[][] grid = new char[n][m];
          int sx = -1;
          int sy = -1;
          for(var i = 0;i<n;i++){
              grid[i] = sc.next().toCharArray();
              for(var j = 0; j <m;j++)
                  if(grid[i][j] == 'L'){
                      sx = i; sy = j;
                  }
          }
          Queue<int[]> q = new ArrayDeque<>();
          q.add(new int[]{sx,sy});
          boolean [][] visited = new boolean[n][m];
          visited[sx][sy] = true;
          int[] dx = {1,-1,0,0};
          int[] dy = {0,0,1,-1};
          while(!q.isEmpty()){
              int[] curr = q.poll();
              int x = curr[0], y = curr[1];
              for(int i = 0;i<4;i++){
                  int nx = x + dx[i];
                  int ny = y + dy[i];
                  if(nx >= 0 && ny >=0 && nx < n && ny < m && !visited[nx][ny] && grid[nx][ny] =='.'){
                      int dotCount = 0;
                      for(int j=0;j<4;j++){
                          int nxx = nx + dx[j];
                          int nyy = ny + dy[j];
                          if(nxx >= 0 && nyy >=0 && nxx < n && nyy < m  && grid[nxx][nyy] =='.')dotCount++;
                      }
                      if(dotCount < 2){
                          grid[nx][ny] = '+';
                          visited[nx][ny] = true;
                          q.add(new int[]{nx,ny});
                      }
  //                    out.println(nx+" "+ny+" "+x+" "+y+" "+dotCount);
                  }
              }
          }
          for(char[] c : grid)out.println(String.valueOf(c));
      }
  
     
      /*-------------------------------------------EDITING CODE ENDS HERE-------------------------------------------*/
      static FastestReader sc;
      static PrintWriter out;
      private static void openIO() throws IOException{
          sc = new FastestReader();
          out = new PrintWriter(System.out);
      }
  
      /*------------------------------------------HELPER FUNCTION STARTS HERE------------------------------------------*/
  
      public static final int mod = (int) 1e9 +7;
      private static final int mod2 =  998244353;
      public static final int inf_int = (int) 2e9 + 10;
      public static  final long inf_long = (long) 4e18;
  
  
      public static int _digitCount(long num,int base){
          return (int)(1 + Math.log(num)/Math.log(base));
      }
      // time : O(r)
      public static int _ncr(int n,int r){
          if (r > n) return 0;
          long[]  inv = new long[r + 1];
          inv[0] = 1;
          if(r+1>=2)
              inv[1] = 1;
  
          // Getting the modular inversion
          // for all the numbers
          // from 2 to r with respect to mod
          for (int i = 2; i <= r; i++)
              inv[i] = mod - (mod / i) * inv[(mod % i)] % mod;
  
          int ans = 1;
  
          // for 1/(r!) part
          for (int i = 2; i <= r; i++)
              ans = (int) (((ans % mod) * (inv[i] % mod)) % mod);
  
          // for (n)*(n-1)*(n-2)*...*(n-r+1) part
          for (int i = n; i >= (n - r + 1); i--)
              ans =  (((ans % mod) * (i % mod)) % mod);
          return ans;
      }
  
      // euclidean algorithm time O(max (loga ,logb))
      public static long _gcd(long a, long b) {
          if (a == 0)
              return b;
          return _gcd(b % a, a);
      }
  
      public static long _lcm(long a, long b) {
          // lcm(a,b) * gcd(a,b) = a * b
          return (a / _gcd(a, b)) * b;
      }
  
  
      // binary exponentiation time O(logn)
      public static long _power(long x, long n) {
          long ans = 1;
          while (n > 0) {
              if ((n & 1) == 1) {
                  ans *= x;
                  ans %= mod;
                  n--;
              } else {
                  x *= x;
                  x %= mod;
                  n >>= 1;
              }
          }
          return ans;
      }
      //sieve/first divisor time : O(mx * log ( log (mx) ) )
      public static int[]  _seive(int mx){
          int[] firstDivisor = new int[mx+1];
          for(int i=0;i<=mx;i++)firstDivisor[i] = i;
          for(int i=2;i*i<=mx;i++)
              if(firstDivisor[i] == i)
                  for(int j = i*i;j<=mx;j+=i)
                      firstDivisor[j] = i;
          return firstDivisor;
      }
  
      private static boolean _isPrime(long x){
          for(long i=2;i*i<=x;i++)
              if(x%i==0)return false;
          return true;
      }
  
      public static void _sort(int[] arr,boolean isAscending){
          int n = arr.length;
          List<Integer> list = new ArrayList<>();
          for(int ele : arr)list.add(ele);
          Collections.sort(list);
          if(!isAscending)Collections.reverse(list);
          for(int i=0;i<n;i++)arr[i] = list.get(i);
      }
  
      public static void _sort(long[] arr,boolean isAscending){
          int n = arr.length;
          List<Long> list = new ArrayList<>();
          for(long ele : arr)list.add(ele);
          Collections.sort(list);
          if(!isAscending)Collections.reverse(list);
          for(int i=0;i<n;i++)arr[i] = list.get(i);
      }
      /*------------------------------------------HELPER FUNCTION ENDS HERE-------------------------------------------*/
  
      /*-------------------------------------------FAST INPUT STARTS HERE---------------------------------------------*/
  
      public static void closeIO() throws IOException{
          out.flush();
          out.close();
          sc.close();
      }
      private static final class FastestReader {
          private static final int BUFFER_SIZE = 1 << 16;
          private final DataInputStream din;
          private final byte[] buffer;
          private int bufferPointer, bytesRead;
  
          public FastestReader() {
              din = new DataInputStream(System.in);
              buffer = new byte[BUFFER_SIZE];
              bufferPointer = bytesRead = 0;
          }
  
          public FastestReader(String file_name) throws IOException {
              din = new DataInputStream(new FileInputStream(file_name));
              buffer = new byte[BUFFER_SIZE];
              bufferPointer = bytesRead = 0;
          }
  
          private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
  
          private int skip() throws IOException {
              int b;
              //noinspection StatementWithEmptyBody
              while ((b = read()) != -1 && isSpaceChar(b)) {}
              return b;
          }
  
          public String next() throws IOException {
              int b = skip();
              final StringBuilder sb = new StringBuilder();
              while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
                  sb.appendCodePoint(b);
                  b = read();
              }
              return sb.toString();
          }
  
          public int nextInt() throws IOException {
              int ret = 0;
              byte c = read();
              while (c <= ' ') {
                  c = read();
              }
              final boolean neg = c == '-';
              if (neg) { c = read(); }
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
  
              if (neg) { return -ret; }
              return ret;
          }
  
          public long nextLong() throws IOException {
              long ret = 0;
              byte c = read();
              while (c <= ' ') { c = read(); }
              final boolean neg = c == '-';
              if (neg) { c = read(); }
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
              if (neg) { return -ret; }
              return ret;
          }
  
          public double nextDouble() throws IOException {
              double ret = 0, div = 1;
              byte c = read();
              while (c <= ' ') { c = read(); }
              final boolean neg = c == '-';
              if (neg) { c = read(); }
  
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
  
              if (c == '.') {
                  while ((c = read()) >= '0' && c <= '9') {
                      ret += (c - '0') / (div *= 10);
                  }
              }
  
              if (neg) { return -ret; }
              return ret;
          }
  
          private void fillBuffer() throws IOException {
              bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
              if (bytesRead == -1) { buffer[0] = -1; }
          }
  
          private byte read() throws IOException {
              if (bufferPointer == bytesRead) { fillBuffer(); }
              return buffer[bufferPointer++];
          }
  
          public void close() throws IOException {
              din.close();
          }
      }
      /*---------------------------------------------FAST INPUT ENDS HERE ---------------------------------------------*/
  }