In this HackerEarth A strange matrix problem solution You are given a matrix A containing N rows and M columns and an integer C.

Initially, all cells are assigned some value less or equal to C. A[i][j] is the value of the ith row and jth column.

Each second all cell's value is increased by 1 but it can increase maximum up to C after that value of A[i][j] is unchanged.

On the 0th second, you are at (1,1) cell and want to go to (N,M) cell.

At any point in time, you can jump to any adjacent cell. If you are at (i,j), then you can go to any of the adjacent cells, (i-1,j), (i+1,j), (i,j+1), and (i,j-1). You can move to the adjacent cells only on one condition :

You can move to any adjacent cell if and only if the value of the cell, where you are standing, is equal to the value of the adjacent cell and you can not go outside of the matrix

Your task is to determine the minimum time to reach (N,M) from the cell.


HackerEarth A strange matrix problem solution


HackerEarth A strange matrix problem solution.

#include<bits/stdc++.h>

using namespace std;
using ll = long long;
using ld = long double;

#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

#define pb push_back
#define mp make_pair
#define F first
#define S second
#define pll pair<int , int>
#define int long long int
#define endl "\n"


#define ALL(v) v.begin(),v.end()
#define ALLR(v) v.rbegin(),v.rend()
#define pii 3.14159265358979323
#define inf LLONG_MAX
#define ones(x) __builtin_popcount(x)
#define fill(a,b) memset(a,b,sizeof(a))
#define mod 1000000007
#define hell 998244353

ll mod_pow(ll a,ll b,ll m)
{
ll res = 1;
while(b)
{
if(b&1)
{
res=(res*a) % m;
}
a=(a*a) % m;
b>>=1;
}
return res;
}

ll mod_inverse(int a , int m)
{
return mod_pow(a , m - 2 , m);
}

vector<vector<int>> b;

int n , m , h;

void dfs(int i , int j , vector<vector<int>> & vis , vector<vector<int>> & a) {
vis[i][j] = 1;

if(i - 1 >= 0 && a[i - 1][j] == a[i][j] && !vis[i - 1][j]) {
dfs(i - 1, j , vis , a);
}
if(j - 1 >= 0 && a[i][j - 1] == a[i][j] && !vis[i][j - 1]) {
dfs(i , j - 1 , vis , a);
}
if(j + 1 < m && a[i][j + 1] == a[i][j] && !vis[i][j + 1]) {
dfs(i , j + 1 , vis , a);
}
if(i + 1 < n && a[i + 1][j] == a[i][j] && !vis[i + 1][j]) {
dfs(i + 1, j , vis , a);
}
}

void solve()
{
cin >> n >> m >> h;

int l = 0;
int r = 1e9;
int ans;

b.resize(n);

for(int i = 0; i < n; ++i) {
b[i].resize(m);
for(int j = 0; j < m; ++j) {
cin >> b[i][j];
}
}

while(l <= r) {
int mid = (l + r) / 2;

vector<vector<int>> vis(n , vector<int>(m , 0));

vector<vector<int>> a = b;

for(int i = 0; i < n; ++i) {
for(int j = 0; j < m; ++j) {
a[i][j] = min(h , a[i][j] + mid);
}
}

dfs(0 , 0 , vis , a);

if(vis[n - 1][m - 1] == 1) {
ans = mid;
r = mid - 1;
}
else {
l = mid + 1;
}
}

cout << ans << endl;
}

signed main() {
fast;

int t = 1;

//cin >> t;

while(t--) {
solve();
}

return 0;
}

Second solution

import sys

sys.setrecursionlimit(300000)
n, m, c = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
lo = -1
hi = c


def check(t):
seen = [[False] * m for _ in range(n)]

def dfs(x, y, val):
if x < 0 or x >= n or y < 0 or y >= m or seen[x][y] or min(c, a[x][y] + t) != val:
return False
seen[x][y] = True
if x == n - 1 and y == m - 1:
return True
return dfs(x - 1, y, val) or dfs(x + 1, y, val) or dfs(x, y - 1, val) or dfs(x, y + 1, val)

return dfs(0, 0, min(c, a[0][0] + t))


while hi - lo > 1:
mid = (lo + hi) // 2
if check(mid):
hi = mid
else:
lo = mid
print(hi)