Maximum strength in a Matrix after performing specified operations
Given a matrix of N * M containing {0, 1, #}. The task is to find the maximum value of strength based on following rules:
- Initial strength is zero.
- If you encounter a 0, Strength decreases by 2.
- If you encounter a 1, Strength increases by 5.
- If you encounter a #, Jumps to the start of a new row without losing any strength.
Note: You have to traverse every row of the matrix in top-down order from left to right.
Example:
Input:
{{1, 0, 1, 0},
{0, #, 0, 0},
{1, 1, 0, 0},
{0, #, 1, 0}}
Output: 14
Explanation:
Here you starts with strength S = 0.
For the first row {1, 0, 1, 0}:
After {1} -> S = S + 5 = 5
After {0} -> S = S - 2 = 3
After {1} -> S = S + 5 = 8
After {0} -> S = S - 2 = 6
For the Second row {0, #, 0, 0}:
After {0} -> S = S - 2 = 4
After {#} -> Jump to next row.
For the Third row {1, 1, 0, 0}:
After {1} -> S = S + 5 = 9
After {1} -> S = S + 5 = 14
After {0} -> S = S - 2 = 12
After {0} -> S = S - 2 = 10
For the Fourth row {0, #, 1, 0}:
After {0} -> S = S - 2 = 8
After {#} -> Jump to next row.
So, The maximum value of S is 14
Approach:
- Traverse the matrix mat[][] from i = [0, N], j = [0, M] and check:
If mat[i][j] = 0 then, S = S - 2.
If mat[i][j] = 1 then, S = S + 5.
If mat[i][j] = # then, jump to the next row.
-
- At every step store maximum value of strength till now and Print the strength at the end.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void MaxStrength( char mat[100][100],
int n, int m)
{
int S = 0;
int ans = 0;
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
char Curr = mat[i][j];
if (Curr == '1' ) {
S += 5;
}
if (Curr == '0' ) {
S -= 2;
}
if (Curr == '#' ) {
break ;
}
ans = max(ans, S);
}
}
cout << ans;
return ;
}
int main()
{
int N = 4;
int M = 4;
char Mat[100][100]{ { '1' , '0' , '1' , '0' },
{ '0' , '#' , '0' , '0' },
{ '1' , '1' , '0' , '0' },
{ '0' , '#' , '1' , '0' } };
MaxStrength(Mat, N, M);
return 0;
}
|
Java
import java.io.*;
class GFG{
static void MaxStrength( char [][] mat,
int n, int m)
{
int S = 0 ;
int ans = 0 ;
for ( int i = 0 ; i < n; i++)
{
for ( int j = 0 ; j < m; j++)
{
char Curr = mat[i][j];
if (Curr == '1' )
{
S += 5 ;
}
if (Curr == '0' )
{
S -= 2 ;
}
if (Curr == '#' )
{
break ;
}
ans = Math.max(ans, S);
}
}
System.out.println(ans);
return ;
}
public static void main (String[] args)
{
int N = 4 ;
int M = 4 ;
char [][] Mat = { { '1' , '0' , '1' , '0' },
{ '0' , '#' , '0' , '0' },
{ '1' , '1' , '0' , '0' },
{ '0' , '#' , '1' , '0' } };
MaxStrength(Mat, N, M);
}
}
|
Python3
def MaxStrength(mat, n, m):
S = 0
ans = 0
for i in range (n):
for j in range (m):
Curr = mat[i][j]
if (Curr = = '1' ):
S + = 5
if (Curr = = '0' ):
S - = 2
if (Curr = = '#' ):
break
ans = max (ans, S)
print (ans)
return
if __name__ = = '__main__' :
N = 4 ;
M = 4 ;
Mat = [ [ '1' , '0' , '1' , '0' ],
[ '0' , '#' , '0' , '0' ],
[ '1' , '1' , '0' , '0' ],
[ '0' , '#' , '1' , '0' ] ]
MaxStrength(Mat, N, M)
|
C#
using System;
class GFG{
static void MaxStrength( char [,] mat,
int n, int m)
{
int S = 0;
int ans = 0;
for ( int i = 0; i < n; i++)
{
for ( int j = 0; j < m; j++)
{
char Curr = mat[i, j];
if (Curr == '1' )
{
S += 5;
}
if (Curr == '0' )
{
S -= 2;
}
if (Curr == '#' )
{
break ;
}
ans = Math.Max(ans, S);
}
}
Console.WriteLine(ans);
return ;
}
public static void Main(String[] args)
{
int N = 4;
int M = 4;
char [,] Mat = { { '1' , '0' , '1' , '0' },
{ '0' , '#' , '0' , '0' },
{ '1' , '1' , '0' , '0' },
{ '0' , '#' , '1' , '0' } };
MaxStrength(Mat, N, M);
}
}
|
Javascript
<script>
function MaxStrength(mat, n, m)
{
var S = 0;
var ans = 0;
for ( var i = 0; i < n; i++) {
for ( var j = 0; j < m; j++) {
var Curr = mat[i][j];
if (Curr == '1' ) {
S += 5;
}
if (Curr == '0' ) {
S -= 2;
}
if (Curr == '#' ) {
break ;
}
ans = Math.max(ans, S);
}
}
document.write( ans);
return ;
}
var N = 4;
var M = 4;
var Mat = [ [ '1' , '0' , '1' , '0' ],
[ '0' , '#' , '0' , '0' ],
[ '1' , '1' , '0' , '0' ],
[ '0' , '#' , '1' , '0' ] ];
MaxStrength(Mat, N, M);
</script>
|
Time Complexity: O(n*m) where n is rows and m is columns.
Space Complexity: O(1) as no extra space has been used.
Last Updated :
22 Feb, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...