Paths with maximum number of ‘a’ from (1, 1) to (X, Y) vertically or horizontally
Last Updated :
13 Jun, 2022
Given a N X N matrix consisting of characters. Also given are Q queries, where each query contains a co-ordinate (X, Y). For every query, find all paths from (1, 1) to (X, Y) by either moving vertically or horizontally and take the path which has the maximum number of in it. The task is to print the number of non-‘a’-characters along that path.
Examples:
Input: mat[][] = {{'a', 'b', 'a'},
{'a', 'c', 'd'},
{'b', 'a', 'b'}}
Queries:
X = 1, Y = 3
X = 3, Y = 3
Output:
1st query: 1
2nd query: 2
Query-1: There is only one path from (1, 1) to (1, 3)
i.e., "aba" and the number of characters
which are not 'a' is 1.
Query-2: The path which has the maximum number of 'a'
in it is "aabab", hence non 'a'
characters are 2.
The problem is a variant of Min-Cost path Dp problem. We need to pre-compute the DP[][] array and then the answer will be DP[X][Y], hence every query can be answered in O(1). If the index position (1, 1) character is not ‘a’, then increase the dp[1][1] value by 1. Then simply iterate for rows and columns, and do a min-cost DP considering ‘a’ as 1 and non-‘a’ character as 0. Since the DP[][] array stores the min-cost path from (1, 1) to any index (i, j), hence the query can be answered in O(1).
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
const int n = 3;
int dp[n][n];
void answerQueries(pair< int , int > queries[], int q)
{
for ( int i = 0; i < q; i++) {
int x = queries[i].first;
x--;
int y = queries[i].second;
y--;
cout << dp[x][y] << endl;
}
}
void pre_compute( char a[][n])
{
if (a[0][0] == 'a' )
dp[0][0] = 0;
else
dp[0][0] = 1;
for ( int row = 0; row < n; row++) {
for ( int col = 0; col < n; col++) {
if (row != 0 || col != 0)
dp[row][col] = INT_MAX;
if (row != 0) {
dp[row][col] = min(dp[row][col],
dp[row - 1][col]);
}
if (col != 0) {
dp[row][col] = min(dp[row][col],
dp[row][col - 1]);
}
if (a[row][col] != 'a' && (row != 0 || col != 0))
dp[row][col] += 1;
}
}
}
int main()
{
char a[][3] = { { 'a' , 'b' , 'a' },
{ 'a' , 'c' , 'd' },
{ 'b' , 'a' , 'b' } };
pair< int , int > queries[] = { { 1, 3 }, { 3, 3 } };
int q = 2;
pre_compute(a);
answerQueries(queries, q);
}
|
Java
class GFG
{
static class pair
{
int first, second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
}
static int n = 3 ;
static int [][]dp = new int [n][n];
static void answerQueries(pair queries[], int q)
{
for ( int i = 0 ; i < q; i++)
{
int x = queries[i].first;
x--;
int y = queries[i].second;
y--;
System.out.println(dp[x][y]);
}
}
static void pre_compute( char a[][])
{
if (a[ 0 ][ 0 ] == 'a' )
dp[ 0 ][ 0 ] = 0 ;
else
dp[ 0 ][ 0 ] = 1 ;
for ( int row = 0 ; row < n; row++)
{
for ( int col = 0 ; col < n; col++)
{
if (row != 0 || col != 0 )
dp[row][col] = Integer.MAX_VALUE;
if (row != 0 )
{
dp[row][col] = Math.min(dp[row][col],
dp[row - 1 ][col]);
}
if (col != 0 )
{
dp[row][col] = Math.min(dp[row][col],
dp[row][col - 1 ]);
}
if (a[row][col] != 'a' && (row != 0 || col != 0 ))
dp[row][col] += 1 ;
}
}
}
public static void main(String[] args)
{
char a[][] = {{ 'a' , 'b' , 'a' },
{ 'a' , 'c' , 'd' },
{ 'b' , 'a' , 'b' }};
pair queries[] = { new pair( 1 , 3 ),
new pair( 3 , 3 ) };
int q = 2 ;
pre_compute(a);
answerQueries(queries, q);
}
}
|
Python3
n = 3
dp = [[ 0 for i in range (n)]
for j in range (n)]
def answerQueries(queries, q):
for i in range (q):
x = queries[i][ 0 ]
x - = 1
y = queries[i][ 1 ]
y - = 1
print (dp[x][y])
def pre_compute(a):
if a[ 0 ][ 0 ] = = 'a' :
dp[ 0 ][ 0 ] = 0
else :
dp[ 0 ][ 0 ] = 1
for row in range (n):
for col in range (n):
if (row ! = 0 or col ! = 0 ):
dp[row][col] = 9999
if (row ! = 0 ):
dp[row][col] = min (dp[row][col],
dp[row - 1 ][col])
if (col ! = 0 ):
dp[row][col] = min (dp[row][col],
dp[row][col - 1 ])
if (a[row][col] ! = 'a' and (row ! = 0 or
col ! = 0 )):
dp[row][col] + = 1
if __name__ = = '__main__' :
a = [ ( 'a' , 'b' , 'a' ),
( 'a' , 'c' , 'd' ),
( 'b' , 'a' , 'b' ) ]
queries = [ ( 1 , 3 ), ( 3 , 3 ) ]
q = 2
pre_compute(a)
answerQueries(queries, q)
|
C#
using System;
class GFG
{
class pair
{
public int first, second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
}
static int n = 3;
static int [,]dp = new int [n, n];
static void answerQueries(pair []queries, int q)
{
for ( int i = 0; i < q; i++)
{
int x = queries[i].first;
x--;
int y = queries[i].second;
y--;
Console.WriteLine(dp[x, y]);
}
}
static void pre_compute( char [,]a)
{
if (a[0, 0] == 'a' )
dp[0, 0] = 0;
else
dp[0, 0] = 1;
for ( int row = 0; row < n; row++)
{
for ( int col = 0; col < n; col++)
{
if (row != 0 || col != 0)
dp[row, col] = int .MaxValue;
if (row != 0)
{
dp[row, col] = Math.Min(dp[row, col],
dp[row - 1, col]);
}
if (col != 0)
{
dp[row, col] = Math.Min(dp[row, col],
dp[row, col - 1]);
}
if (a[row, col] != 'a' &&
(row != 0 || col != 0))
dp[row, col] += 1;
}
}
}
public static void Main(String[] args)
{
char [,]a = {{ 'a' , 'b' , 'a' },
{ 'a' , 'c' , 'd' },
{ 'b' , 'a' , 'b' }};
pair []queries = { new pair(1, 3),
new pair(3, 3) };
int q = 2;
pre_compute(a);
answerQueries(queries, q);
}
}
|
Javascript
<script>
class pair
{
constructor(first,second)
{
this .first = first;
this .second = second;
}
}
let n = 3;
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;
}
}
function answerQueries(queries,q)
{
for (let i = 0; i < q; i++)
{
let x = queries[i].first;
x--;
let y = queries[i].second;
y--;
document.write(dp[x][y]+ "<br>" );
}
}
function pre_compute(a)
{
if (a[0][0] == 'a' )
dp[0][0] = 0;
else
dp[0][0] = 1;
for (let row = 0; row < n; row++)
{
for (let col = 0; col < n; col++)
{
if (row != 0 || col != 0)
dp[row][col] = Number.MAX_VALUE;
if (row != 0)
{
dp[row][col] = Math.min(dp[row][col],
dp[row - 1][col]);
}
if (col != 0)
{
dp[row][col] = Math.min(dp[row][col],
dp[row][col - 1]);
}
if (a[row][col] != 'a' && (row != 0 || col != 0))
dp[row][col] += 1;
}
}
}
let a=[[ 'a' , 'b' , 'a' ],
[ 'a' , 'c' , 'd' ],
[ 'b' , 'a' , 'b' ]];
let queries = [ new pair( 1, 3 ),
new pair(3, 3 ) ];
let q = 2;
pre_compute(a);
answerQueries(queries, q);
</script>
|
Time Complexity: O(N2) for pre-computation and O(1) for each query.
Auxiliary Space: O(N2)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...