Maximum decimal value path in a binary matrix
Last Updated :
24 Mar, 2023
Given binary square matrix [n*n]. Find maximum integer value in a path from top left to bottom right. We compute integer value using bits of traversed path. We start at index [0,0] and end at index [n-1][n-1]. from index [i, j], we can move [i, j+1] or [i+1, j].
Examples:
Input : mat[][] = {{1, 1, 0, 1},
{0, 1, 1, 0},
{1, 0, 0, 1},
{1, 0, 1, 1}}
Output : 111
Explanation :
Path : (0,0) -> (0,1) -> (1,1) -> (1,2) ->
(2,2) -> (3,2) ->(3,3)
Decimal value : 1*(2^0) + 1*(2^1) + 1*(2^2) + 1*(2^3) +
0*(2^4) + 1*(2^5) + 1*(2^6) = 111
The above problem can be recursively defined as below:
// p indicates power of 2, initially p = i = j = 0
MaxDecimalValue(mat, i, j, p)
// If i or j is our of boundary
If i >= n || j >= n
return 0
// Compute rest of matrix find maximum decimal value
result max(MaxDecimalValue(mat, i, j+1, p+1),
MaxDecimalValue(mat, i+1, j, p+1))
If mat[i][j] == 1
return power(2, p) + result
Else
return result
Below is the implementation of above recursive algorithm.
C++
#include<bits/stdc++.h>
using namespace std;
#define N 4
long long int maxDecimalValue( int mat[][N], int i, int j,
int p)
{
if (i >= N || j >= N )
return 0;
int result = max(maxDecimalValue(mat, i, j+1, p+1),
maxDecimalValue(mat, i+1, j, p+1));
if (mat[i][j] == 1)
return pow (2, p) + result;
else
return result;
}
int main()
{
int mat[][4] = {{ 1 ,1 ,0 ,1 },
{ 0 ,1 ,1 ,0 },
{ 1 ,0 ,0 ,1 },
{ 1 ,0 ,1 ,1 },
};
cout << maxDecimalValue(mat, 0, 0, 0) << endl;
return 0;
}
|
Java
class GFG {
static final int N = 4 ;
static int maxDecimalValue( int mat[][], int i, int j,
int p) {
if (i >= N || j >= N) {
return 0 ;
}
int result = Math.max(maxDecimalValue(mat, i, j + 1 , p + 1 ),
maxDecimalValue(mat, i + 1 , j, p + 1 ));
if (mat[i][j] == 1 ) {
return ( int ) (Math.pow( 2 , p) + result);
} else {
return result;
}
}
public static void main(String[] args) {
int mat[][] = {{ 1 , 1 , 0 , 1 },
{ 0 , 1 , 1 , 0 },
{ 1 , 0 , 0 , 1 },
{ 1 , 0 , 1 , 1 },};
System.out.println(maxDecimalValue(mat, 0 , 0 , 0 ));
}
}
|
Python3
N = 4
def maxDecimalValue(mat, i, j, p):
if i > = N or j > = N:
return 0
result = max (
maxDecimalValue(mat, i, j + 1 , p + 1 ),
maxDecimalValue(mat, i + 1 , j, p + 1 ))
if mat[i][j] = = 1 :
return pow ( 2 , p) + result
else :
return result
mat = [ [ 1 , 1 , 0 , 1 ],
[ 0 , 1 , 1 , 0 ],
[ 1 , 0 , 0 , 1 ],
[ 1 , 0 , 1 , 1 ] ]
print (maxDecimalValue(mat, 0 , 0 , 0 ))
|
C#
using System;
class GFG {
static int N = 4;
static int maxDecimalValue( int [,] mat, int i,
int j, int p)
{
if (i >= N || j >= N) {
return 0;
}
int result = Math.Max(maxDecimalValue(mat, i, j + 1, p + 1),
maxDecimalValue(mat, i + 1, j, p + 1));
if (mat[i,j] == 1)
{
return ( int ) (Math.Pow(2, p) + result);
} else
{
return result;
}
}
public static void Main() {
int [,] mat = {{1, 1, 0, 1},
{0, 1, 1, 0},
{1, 0, 0, 1},
{1, 0, 1, 1},};
Console.Write(maxDecimalValue(mat, 0, 0, 0));
}
}
|
PHP
<?php
function maxDecimalValue( $mat , $i ,
$j , $p )
{
$N =4;
if ( $i >= $N || $j >= $N )
return 0;
$result = max(maxDecimalValue( $mat , $i ,
$j + 1, $p + 1),
maxDecimalValue( $mat , $i + 1,
$j , $p + 1));
if ( $mat [ $i ][ $j ] == 1)
return pow(2, $p ) + $result ;
else
return $result ;
}
$mat = array ( array (1 ,1 ,0 ,1),
array (0 ,1 ,1 ,0),
array (1 ,0 ,0 ,1),
array (1 ,0 ,1 ,1));
echo maxDecimalValue( $mat , 0, 0, 0) ;
?>
|
Javascript
<script>
let N = 4;
function maxDecimalValue(mat, i, j, p)
{
if (i >= N || j >= N)
{
return 0;
}
let result = Math.max(maxDecimalValue(mat, i, j + 1,
p + 1),
maxDecimalValue(mat, i + 1, j,
p + 1));
if (mat[i][j] == 1)
{
return (Math.pow(2, p) + result);
}
else
{
return result;
}
}
let mat = [ [ 1, 1, 0, 1 ],
[ 0, 1, 1, 0 ],
[ 1, 0, 0, 1 ],
[ 1, 0, 1, 1 ] ];
document.write(maxDecimalValue(mat, 0, 0, 0));
</script>
|
Output:
111
The time complexity of above recursive solution is exponential.
Space Complexity:O(1),since no extra space required.
Here matrix [3][3]
(2 2)
/ \
(1 2) (2 1)
/ \ / \
(0 2) (1 1) (1 1) (2 1)
/ \ / \ / \ / \
. . . . . . . .
. . . . . . . . and so no
If we see recursion tree of above recursive solution, we can observe overlapping sub-problems. Since the problem has overlapping subproblems, we can solve it efficiently using Dynamic Programming. Below is Dynamic Programming based solution.
Below is the implementation of above problem using Dynamic Programming
C++
#include<bits/stdc++.h>
using namespace std;
#define N 4
long long int MaximumDecimalValue( int mat[][N], int n)
{
int dp[n][n];
memset (dp, 0, sizeof (dp));
if (mat[0][0] == 1)
dp[0][0] = 1 ;
for ( int i=1; i<n; i++)
{
if (mat[0][i] == 1)
dp[0][i] = dp[0][i-1] + pow (2, i);
else
dp[0][i] = dp[0][i-1];
}
for ( int i = 1 ; i <n ; i++ )
{
if (mat[i][0] == 1)
dp[i][0] = dp[i-1][0] + pow (2, i);
else
dp[i][0] = dp[i-1][0];
}
for ( int i=1 ; i < n ; i++ )
{
for ( int j=1 ; j < n ; j++ )
{
if (mat[i][j] == 1)
dp[i][j] = max(dp[i][j-1], dp[i-1][j]) +
pow (2, i+j);
else
dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
}
}
return dp[n-1][n-1];
}
int main()
{
int mat[][4] = {{ 1 ,1 ,0 ,1 },
{ 0 ,1 ,1 ,0 },
{ 1 ,0 ,0 ,1 },
{ 1 ,0 ,1 ,1 },
};
cout << MaximumDecimalValue(mat, 4) << endl;
return 0;
}
|
Java
public class GFG {
final static int N = 4 ;
static int MaximumDecimalValue( int mat[][], int n) {
int dp[][] = new int [n][n];
if (mat[ 0 ][ 0 ] == 1 ) {
dp[ 0 ][ 0 ] = 1 ;
}
for ( int i = 1 ; i < n; i++) {
if (mat[ 0 ][i] == 1 ) {
dp[ 0 ][i] = ( int ) (dp[ 0 ][i - 1 ] + Math.pow( 2 , i));
}
else {
dp[ 0 ][i] = dp[ 0 ][i - 1 ];
}
}
for ( int i = 1 ; i < n; i++) {
if (mat[i][ 0 ] == 1 ) {
dp[i][ 0 ] = ( int ) (dp[i - 1 ][ 0 ] + Math.pow( 2 , i));
}
else {
dp[i][ 0 ] = dp[i - 1 ][ 0 ];
}
}
for ( int i = 1 ; i < n; i++) {
for ( int j = 1 ; j < n; j++) {
if (mat[i][j] == 1 ) {
dp[i][j] = ( int ) (Math.max(dp[i][j - 1 ], dp[i - 1 ][j])
+ Math.pow( 2 , i + j));
} else {
dp[i][j] = Math.max(dp[i][j - 1 ], dp[i - 1 ][j]);
}
}
}
return dp[n - 1 ][n - 1 ];
}
public static void main(String[] args) {
int mat[][] = {{ 1 , 1 , 0 , 1 },
{ 0 , 1 , 1 , 0 },
{ 1 , 0 , 0 , 1 },
{ 1 , 0 , 1 , 1 },};
System.out.println(MaximumDecimalValue(mat, 4 ));
}
}
|
Python3
N = 4
def MaximumDecimalValue(mat, n):
dp = [[ 0 for i in range (n)] for i in range (n)]
if (mat[ 0 ][ 0 ] = = 1 ):
dp[ 0 ][ 0 ] = 1
for i in range ( 1 ,n):
if (mat[ 0 ][i] = = 1 ):
dp[ 0 ][i] = dp[ 0 ][i - 1 ] + 2 * * i
else :
dp[ 0 ][i] = dp[ 0 ][i - 1 ]
for i in range ( 1 ,n):
if (mat[i][ 0 ] = = 1 ):
dp[i][ 0 ] = dp[i - 1 ][ 0 ] + 2 * * i
else :
dp[i][ 0 ] = dp[i - 1 ][ 0 ]
for i in range ( 1 ,n):
for j in range ( 1 ,n):
if (mat[i][j] = = 1 ):
dp[i][j] = max (dp[i][j - 1 ], dp[i - 1 ][j]) + ( 2 * * (i + j))
else :
dp[i][j] = max (dp[i][j - 1 ], dp[i - 1 ][j])
return dp[n - 1 ][n - 1 ]
if __name__ = = '__main__' :
mat = [[ 1 , 1 , 0 , 1 ],
[ 0 , 1 , 1 , 0 ],
[ 1 , 0 , 0 , 1 ],
[ 1 , 0 , 1 , 1 ]]
print (MaximumDecimalValue(mat, 4 ))
|
C#
using System;
public class GFG {
readonly static int N = 4;
static int MaximumDecimalValue( int [,]mat, int n) {
int [,]dp = new int [n,n];
if (mat[0,0] == 1) {
dp[0,0] = 1;
}
for ( int i = 1; i < n; i++) {
if (mat[0,i] == 1) {
dp[0,i] = ( int ) (dp[0,i - 1] + Math.Pow(2, i));
}
else {
dp[0,i] = dp[0,i - 1];
}
}
for ( int i = 1; i < n; i++) {
if (mat[i,0] == 1) {
dp[i,0] = ( int ) (dp[i - 1,0] + Math.Pow(2, i));
}
else {
dp[i,0] = dp[i - 1,0];
}
}
for ( int i = 1; i < n; i++) {
for ( int j = 1; j < n; j++) {
if (mat[i,j] == 1) {
dp[i,j] = ( int ) (Math.Max(dp[i,j - 1], dp[i - 1,j])
+ Math.Pow(2, i + j));
} else {
dp[i,j] = Math.Max(dp[i,j - 1], dp[i - 1,j]);
}
}
}
return dp[n - 1,n - 1];
}
public static void Main() {
int [,]mat = {{1, 1, 0, 1},
{0, 1, 1, 0},
{1, 0, 0, 1},
{1, 0, 1, 1},};
Console.Write(MaximumDecimalValue(mat, 4));
}
}
|
Javascript
<script>
let N = 4;
function MaximumDecimalValue(mat,n)
{
let dp= new Array(n);
for (let i = 0; i < n; i++)
{
dp[i] = new Array(n);
for (let j = 0; j < n; j++)
{
dp[i][j] = 0;
}
}
if (mat[0][0] == 1) {
dp[0][0] = 1;
}
for (let i = 1; i < n; i++)
{
if (mat[0][i] == 1)
{
dp[0][i] = dp[0][i - 1] + Math.pow(2, i);
}
else
{
dp[0][i] = dp[0][i - 1];
}
}
for (let i = 1; i < n; i++)
{
if (mat[i][0] == 1)
{
dp[i][0] = Math.floor(dp[i - 1][0] + Math.pow(2, i));
}
else
{
dp[i][0] = dp[i - 1][0];
}
}
for (let i = 1; i < n; i++)
{
for (let j = 1; j < n; j++)
{
if (mat[i][j] == 1)
{
dp[i][j] = Math.floor(Math.max(dp[i][j - 1], dp[i - 1][j])
+ Math.pow(2, i + j));
}
else
{
dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
}
}
}
return dp[n - 1][n - 1];
}
let mat = [[ 1 ,1 ,0 ,1 ],
[ 0 ,1 ,1 ,0 ],
[ 1 ,0 ,0 ,1 ],
[ 1 ,0 ,1 ,1 ]];
document.write(MaximumDecimalValue(mat, 4))
</script>
|
Output:
111
Time Complexity : O(n2)
Auxiliary space : O(n2)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...