Skip to content
Related Articles
Maximum mirrors which can transfer light from bottom to right
• Difficulty Level : Medium
• Last Updated : 23 Jul, 2019

A square matrix is given in which each cell represents either a blank or an obstacle. We can place mirrors at blank positionl. All mirrors will be situated at 45 degree, i.e. they can transfer light from bottom to right if no obstacle is there in their path.
In this question we need to count how many such mirrors can be placed in square matrix which can transfer light from bottom to right.
Examples:

``` Output for above example is 2.

In above diagram, mirror at (3, 1) and (5, 5) are able
to send light from bottom to right so total possible
mirror count is 2.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We can solve this problem by checking position of such mirrors in matrix, the mirror which can transfer light from bottom to right will not have any obstacle in their path i.e.
if a mirror is there at index (i, j) then
there will be no obstacle at index (k, j) for all k, i < k <= N
there will be no obstacle at index (i, k) for all k, j < k <= N
Keeping above two equations in mind, we can find rightmost obstacle at every row in one iteration of given matrix and we can find bottommost obstacle at every column in another iteration of given matrix. After storing these indices in separate array we can check at each index whether it satisfies no obstacle condition or not and then increase the count accordingly.
Below is implemented solution on above concept which requires O(N^2) time and O(N) extra space.

## C++

 `// C++ program to find how many mirror can transfer``// light from bottom to right``#include ``using` `namespace` `std;`` ` `// method returns number of mirror which can transfer``// light from bottom to right``int` `maximumMirrorInMatrix(string mat[], ``int` `N)``{``    ``// To store first obstacles horizontaly (from right)``    ``// and vertically (from bottom)``    ``int` `horizontal[N], vertical[N];`` ` `    ``// initialize both array as -1, signifying no obstacle``    ``memset``(horizontal, -1, ``sizeof``(horizontal));``    ``memset``(vertical, -1, ``sizeof``(vertical));`` ` `    ``// looping matrix to mark column for obstacles``    ``for` `(``int` `i=0; i=0; j--)``        ``{``            ``if` `(mat[i][j] == ``'B'``)``                ``continue``;`` ` `            ``// mark rightmost column with obstacle``            ``horizontal[i] = j;``            ``break``;``        ``}``    ``}`` ` `    ``// looping matrix to mark rows for obstacles``    ``for` `(``int` `j=0; j=0; i--)``        ``{``            ``if` `(mat[i][j] == ``'B'``)``                ``continue``;`` ` `            ``// mark leftmost row with obstacle``            ``vertical[j] = i;``            ``break``;``        ``}``    ``}`` ` `    ``int` `res = 0; ``// Initialize result`` ` `    ``// if there is not obstacle on right or below,``    ``// then mirror can be placed to transfer light``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``for` `(``int` `j = 0; j < N; j++)``        ``{``            ``/* if i > vertical[j] then light can from bottom``               ``if j > horizontal[i] then light can go to right */``            ``if` `(i > vertical[j] && j > horizontal[i])``            ``{``                ``/* uncomment this code to print actual mirror``                   ``position also``                ``cout << i << " " << j << endl; */``                ``res++;``            ``}``        ``}``    ``}`` ` `    ``return` `res;``}`` ` `//  Driver code to test above method``int` `main()``{``    ``int` `N = 5;`` ` `    ``//  B - Blank     O - Obstacle``    ``string mat[N] = {``"BBOBB"``,``                     ``"BBBBO"``,``                     ``"BBBBB"``,``                     ``"BOOBO"``,``                     ``"BBBOB"``                    ``};`` ` `    ``cout << maximumMirrorInMatrix(mat, N) << endl;`` ` `    ``return` `0;``}`

## Java

 `// Java program to find how many mirror can transfer``// light from bottom to right``import` `java.util.*;`` ` `class` `GFG ``{`` ` `    ``// method returns number of mirror which can transfer``    ``// light from bottom to right``    ``static` `int` `maximumMirrorInMatrix(String mat[], ``int` `N) ``    ``{``        ``// To store first obstacles horizontaly (from right)``        ``// and vertically (from bottom)``        ``int``[] horizontal = ``new` `int``[N];``        ``int``[] vertical = ``new` `int``[N];`` ` `        ``// initialize both array as -1, signifying no obstacle``        ``Arrays.fill(horizontal, -``1``);``        ``Arrays.fill(vertical, -``1``);``         ` `        ``// looping matrix to mark column for obstacles``        ``for` `(``int` `i = ``0``; i < N; i++) ``        ``{``            ``for` `(``int` `j = N - ``1``; j >= ``0``; j--) ``            ``{``                ``if` `(mat[i].charAt(j) == ``'B'``)``                ``{``                    ``continue``;``                ``}`` ` `                ``// mark rightmost column with obstacle``                ``horizontal[i] = j;``                ``break``;``            ``}``        ``}`` ` `        ``// looping matrix to mark rows for obstacles``        ``for` `(``int` `j = ``0``; j < N; j++) ``        ``{``            ``for` `(``int` `i = N - ``1``; i >= ``0``; i--) ``            ``{``                ``if` `(mat[i].charAt(j) == ``'B'``) ``                ``{``                    ``continue``;``                ``}`` ` `                ``// mark leftmost row with obstacle``                ``vertical[j] = i;``                ``break``;``            ``}``        ``}`` ` `        ``int` `res = ``0``; ``// Initialize result`` ` `        ``// if there is not obstacle on right or below,``        ``// then mirror can be placed to transfer light``        ``for` `(``int` `i = ``0``; i < N; i++)``        ``{``            ``for` `(``int` `j = ``0``; j < N; j++) ``            ``{``                ``/* if i > vertical[j] then light can from bottom``                ``if j > horizontal[i] then light can go to right */``                ``if` `(i > vertical[j] && j > horizontal[i])``                ``{``                    ``/* uncomment this code to print actual mirror``                    ``position also``                    ``cout << i << " " << j << endl; */``                    ``res++;``                ``}``            ``}``        ``}`` ` `        ``return` `res;``    ``}`` ` `// Driver code``public` `static` `void` `main(String[] args) ``{``    ``int` `N = ``5``;`` ` `    ``// B - Blank     O - Obstacle``    ``String mat[] = {``"BBOBB"``,``        ``"BBBBO"``,``        ``"BBBBB"``,``        ``"BOOBO"``,``        ``"BBBOB"``    ``};`` ` `    ``System.out.println(maximumMirrorInMatrix(mat, N));``}``}`` ` `/* This code is contributed by PrinciRaj1992 */`

## C#

 `// C# program to find how many mirror can transfer``// light from bottom to right``using` `System;``     ` `class` `GFG ``{`` ` `    ``// method returns number of mirror which can transfer``    ``// light from bottom to right``    ``static` `int` `maximumMirrorInMatrix(String []mat, ``int` `N) ``    ``{``        ``// To store first obstacles horizontaly (from right)``        ``// and vertically (from bottom)``        ``int``[] horizontal = ``new` `int``[N];``        ``int``[] vertical = ``new` `int``[N];`` ` `        ``// initialize both array as -1, signifying no obstacle``        ``for` `(``int` `i = 0; i < N; i++) ``        ``{``            ``horizontal[i]=-1;``            ``vertical[i]=-1;``        ``}``         ` `        ``// looping matrix to mark column for obstacles``        ``for` `(``int` `i = 0; i < N; i++) ``        ``{``            ``for` `(``int` `j = N - 1; j >= 0; j--) ``            ``{``                ``if` `(mat[i][j] == ``'B'``)``                ``{``                    ``continue``;``                ``}`` ` `                ``// mark rightmost column with obstacle``                ``horizontal[i] = j;``                ``break``;``            ``}``        ``}`` ` `        ``// looping matrix to mark rows for obstacles``        ``for` `(``int` `j = 0; j < N; j++) ``        ``{``            ``for` `(``int` `i = N - 1; i >= 0; i--) ``            ``{``                ``if` `(mat[i][j] == ``'B'``) ``                ``{``                    ``continue``;``                ``}`` ` `                ``// mark leftmost row with obstacle``                ``vertical[j] = i;``                ``break``;``            ``}``        ``}`` ` `        ``int` `res = 0; ``// Initialize result`` ` `        ``// if there is not obstacle on right or below,``        ``// then mirror can be placed to transfer light``        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``for` `(``int` `j = 0; j < N; j++) ``            ``{``                ``/* if i > vertical[j] then light can from bottom``                ``if j > horizontal[i] then light can go to right */``                ``if` `(i > vertical[j] && j > horizontal[i])``                ``{``                    ``/* uncomment this code to print actual mirror``                    ``position also``                    ``cout << i << " " << j << endl; */``                    ``res++;``                ``}``            ``}``        ``}`` ` `        ``return` `res;``    ``}`` ` `// Driver code``public` `static` `void` `Main(String[] args) ``{``    ``int` `N = 5;`` ` `    ``// B - Blank     O - Obstacle``    ``String []mat = {``"BBOBB"``,``        ``"BBBBO"``,``        ``"BBBBB"``,``        ``"BOOBO"``,``        ``"BBBOB"``    ``};`` ` `    ``Console.WriteLine(maximumMirrorInMatrix(mat, N));``}``}`` ` `// This code is contributed by Princi Singh`

Output:

```2
```

This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up