Given a grid of dimensions n rows and m columns, where each element initially contains an integer from 0 to k-1. The grid evolves over time, with each element undergoing the transformation (grid[i][j] + 1) % k after each unit of time. You are also provided with a series of queries, each defined by [t, val, lx, ly, rx, ry], the task is to determine, for each query, the number of elements in the given subgrid at time t that have the specified value val, where:
- t represents the time,
- val is the value to be checked,
- lx, ly are the coordinates of the top-left corner of the subgrid, and
- rx, ry are the coordinates of the bottom-right corner of the subgrid.
Note: The grid starts at time t=0 and the indices are 0-based. K values vary from 0 to 5
Examples:
Input: n = 2, m = 2, k = 3, grid = {{0, 1}, {2, 2}}, q = 1, queries = {{1, 0, 0, 0, 1, 1}}
Output: {2}
Explanation: The given query can be interpreted as
- t (time) = 1
- val (value) = 0
- lx, ly (coordinates of the top left corner of subgrid) = (0,0)
- rx, ry (coordinates of the bottom right corner of subgrid) = (1,1)
The count of 0s at time = 1 in the given subgrid is 2.
Input: n = 3, m = 3, k = 4, grid = {{0, 1, 1}, {1, 2, 3}, {0, 2, 1}}, q = 2, queries = {{0, 1, 0, 0, 2, 2}, {2, 2, 1, 1, 2, 2}}
Output: {4, 0}
Explanation:
- For query 1, count of val=1 is 4.
- For query 2, count of val=2 is 0.
Approach: This can be solved with the following idea:
As k value can be between 0 and 5, it's optimal to create a vector which will be storing count of each number at each cordinate. To answer queires we can calculate frequency of each number.
Below are the steps involved:
- Create a 2D vector having value assigned a vector of size 6.
- For each coordinate assign how many times each element has occured.
- Iterate for 6 elements each element occuring will be counted by top + left - diagonal(if under coordinates).
- For each query, see top left and bottom right, calculate freuency from vector intialized above.
- In vector ans, add how many elements are having value equal to val after t time and % k.
- Return ans.
Below is the implementation of the code:
// C++ code for the above approach:
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
// Function to find number of times a particular
// element ocurring in a submatrix
vector<int> k_Transformation(int n, int m, int k,
vector<vector<int> > grid,
int q,
vector<vector<int> > queries)
{
// Declare a 2D vector storing count of 6 elements
vector<vector<vector<int> > > pre(
n + 1,
vector<vector<int> >(m + 1, vector<int>(6, 0)));
// Iterate in grid
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// Increment the frequency of
// elemnent occuring
pre[i][j][grid[i][j]]++;
// Iterate for those 6 elements
for (int k = 0; k <= 5; k++) {
// Store frequency of each
// element upto this coordinate
if (i - 1 >= 0)
pre[i][j][k] += pre[i - 1][j][k];
if (j - 1 >= 0)
pre[i][j][k] += pre[i][j - 1][k];
if (i - 1 >= 0 && j - 1 >= 0)
pre[i][j][k] -= pre[i - 1][j - 1][k];
}
}
}
// Initialise a vector to store ans
vector<int> ans;
// Iterate in queries
for (auto i : queries) {
int t = i[0];
int val = i[1];
int l1 = i[2];
int r1 = i[3];
int l2 = i[4];
int r2 = i[5];
// Calculating for particular that
// submatrix mentioned
vector<int> cnt(6, 0);
for (int j = 0; j <= 5; j++) {
cnt[j] += pre[l2][r2][j];
if (l1 - 1 >= 0) {
cnt[j] -= pre[l1 - 1][r2][j];
}
if (r1 - 1 >= 0) {
cnt[j] -= pre[l2][r1 - 1][j];
}
if (l1 - 1 >= 0 && r1 - 1 >= 0) {
cnt[j] += pre[l1 - 1][r1 - 1][j];
}
}
// Check how many elements have value
// equal to val by doing mod k
int c = 0;
for (int j = 0; j <= 5; j++) {
if (((j + t) % k) == val) {
c += cnt[j];
}
}
ans.push_back(c);
}
// Return the vector ans
return ans;
}
// Driver code
int main()
{
int n = 2;
int m = 2;
int k = 3;
vector<vector<int> > grid = { { 0, 1 }, { 2, 2 } };
int q = 1;
vector<vector<int> > queries = { { 1, 0, 0, 0, 1, 1 } };
vector<int> ans
= k_Transformation(n, m, k, grid, q, queries);
for (auto a : ans) {
cout << a << " ";
}
return 0;
}
import java.util.ArrayList;
import java.util.List;
public class Main {
// Function to find number of times a particular
// element occurring in a submatrix
static List<Integer> kTransformation(int n, int m, int k,
List<List<Integer>> grid, int q, List<List<Integer>> queries) {
// Declare a 3D list storing count of 6 elements
List<List<List<Integer>>> pre = new ArrayList<>();
for (int i = 0; i <= n; i++) {
List<List<Integer>> temp1 = new ArrayList<>();
for (int j = 0; j <= m; j++) {
List<Integer> temp2 = new ArrayList<>();
for (int l = 0; l < 6; l++) {
temp2.add(0);
}
temp1.add(temp2);
}
pre.add(temp1);
}
// Iterate in grid
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// Increment the frequency of
// element occurring
pre.get(i).get(j).set(grid.get(i).get(j),
pre.get(i).get(j).get(grid.get(i).get(j)) + 1);
// Iterate for those 6 elements
for (int k1 = 0; k1 <= 5; k1++) {
// Store frequency of each
// element up to this coordinate
if (i - 1 >= 0)
pre.get(i).get(j).set(k1,
pre.get(i).get(j).get(k1) + pre.get(i - 1).get(j).get(k1));
if (j - 1 >= 0)
pre.get(i).get(j).set(k1,
pre.get(i).get(j).get(k1) + pre.get(i).get(j - 1).get(k1));
if (i - 1 >= 0 && j - 1 >= 0)
pre.get(i).get(j).set(k1,
pre.get(i).get(j).get(k1) - pre.get(i - 1).get(j - 1).get(k1));
}
}
}
// Initialise a list to store ans
List<Integer> ans = new ArrayList<>();
// Iterate in queries
for (List<Integer> i : queries) {
int t = i.get(0);
int val = i.get(1);
int l1 = i.get(2);
int r1 = i.get(3);
int l2 = i.get(4);
int r2 = i.get(5);
// Calculating for particular that
// submatrix mentioned
List<Integer> cnt = new ArrayList<>();
for (int j = 0; j <= 5; j++) {
cnt.add(pre.get(l2).get(r2).get(j));
if (l1 - 1 >= 0) {
cnt.set(j, cnt.get(j) - pre.get(l1 - 1).get(r2).get(j));
}
if (r1 - 1 >= 0) {
cnt.set(j, cnt.get(j) - pre.get(l2).get(r1 - 1).get(j));
}
if (l1 - 1 >= 0 && r1 - 1 >= 0) {
cnt.set(j, cnt.get(j) + pre.get(l1 - 1).get(r1 - 1).get(j));
}
}
// Check how many elements have value
// equal to val by doing mod k
int c = 0;
for (int j = 0; j <= 5; j++) {
if (((j + t) % k) == val) {
c += cnt.get(j);
}
}
ans.add(c);
}
// Return the list ans
return ans;
}
// Driver code
public static void main(String[] args) {
int n = 2;
int m = 2;
int k = 3;
List<List<Integer>> grid = List.of(List.of(0, 1), List.of(2, 2));
int q = 1;
List<List<Integer>> queries = List.of(List.of(1, 0, 0, 0, 1, 1));
List<Integer> ans = kTransformation(n, m, k, grid, q, queries);
for (int a : ans) {
System.out.print(a + " ");
}
}
}
// This code is contributed by shivamgupta0987654321
# Python Implementation
def k_transformation(n, m, k, grid, q, queries):
# Declare a 3D list storing count of 6 elements
pre = [[[0 for _ in range(6)] for _ in range(m+1)] for _ in range(n+1)]
# Iterate in grid
for i in range(n):
for j in range(m):
# Increment the frequency of element occurring
pre[i][j][grid[i][j]] += 1
# Iterate for those 6 elements
for k1 in range(6):
# Store frequency of each element up to this coordinate
if i - 1 >= 0:
pre[i][j][k1] += pre[i-1][j][k1]
if j - 1 >= 0:
pre[i][j][k1] += pre[i][j-1][k1]
if i - 1 >= 0 and j - 1 >= 0:
pre[i][j][k1] -= pre[i-1][j-1][k1]
# Initialise a list to store ans
ans = []
# Iterate in queries
for i in queries:
t = i[0]
val = i[1]
l1 = i[2]
r1 = i[3]
l2 = i[4]
r2 = i[5]
# Calculating for particular that submatrix mentioned
cnt = [pre[l2][r2][j] for j in range(6)]
if l1 - 1 >= 0:
cnt = [cnt[j] - pre[l1-1][r2][j] for j in range(6)]
if r1 - 1 >= 0:
cnt = [cnt[j] - pre[l2][r1-1][j] for j in range(6)]
if l1 - 1 >= 0 and r1 - 1 >= 0:
cnt = [cnt[j] + pre[l1-1][r1-1][j] for j in range(6)]
# Check how many elements have value equal to val by doing mod k
c = sum([cnt[j] for j in range(6) if (j + t) % k == val])
ans.append(c)
# Return the list ans
return ans
# Driver code
n = 2
m = 2
k = 3
grid = [[0, 1], [2, 2]]
q = 1
queries = [[1, 0, 0, 0, 1, 1]]
ans = k_transformation(n, m, k, grid, q, queries)
for a in ans:
print(a, end=" ")
# This code is contributed by Sakshi
// C# program for the above approach
using System;
using System.Collections.Generic;
public class GFG {
// Function to find the number of times a particular
// element occurs in a submatrix
static List<int>
K_Transformation(int n, int m, int k,
List<List<int> > grid, int q,
List<List<int> > queries)
{
// Declare a 3D list storing count of 6 elements
List<List<List<int> > > pre
= new List<List<List<int> > >();
for (int i = 0; i <= n; i++) {
pre.Add(new List<List<int> >());
for (int j = 0; j <= m; j++) {
pre[i].Add(new List<int>(new int[6]));
}
}
// Iterate in grid
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// Increment the frequency of the element
// occurring
pre[i][j][grid[i][j]]++;
// Iterate for those 6 elements
for (int l = 0; l <= 5; l++) {
// Store frequency of each element up to
// this coordinate
if (i - 1 >= 0)
pre[i][j][l] += pre[i - 1][j][l];
if (j - 1 >= 0)
pre[i][j][l] += pre[i][j - 1][l];
if (i - 1 >= 0 && j - 1 >= 0)
pre[i][j][l]
-= pre[i - 1][j - 1][l];
}
}
}
// Initialise a list to store ans
List<int> ans = new List<int>();
// Iterate in queries
foreach(var i in queries)
{
int t = i[0];
int val = i[1];
int l1 = i[2];
int r1 = i[3];
int l2 = i[4];
int r2 = i[5];
// Calculating for a particular submatrix
// mentioned
List<int> cnt = new List<int>(new int[6]);
for (int j = 0; j <= 5; j++) {
cnt[j] += pre[l2][r2][j];
if (l1 - 1 >= 0) {
cnt[j] -= pre[l1 - 1][r2][j];
}
if (r1 - 1 >= 0) {
cnt[j] -= pre[l2][r1 - 1][j];
}
if (l1 - 1 >= 0 && r1 - 1 >= 0) {
cnt[j] += pre[l1 - 1][r1 - 1][j];
}
}
// Check how many elements have value
// equal to val by doing mod k
int c = 0;
for (int j = 0; j <= 5; j++) {
if (((j + t) % k) == val) {
c += cnt[j];
}
}
ans.Add(c);
}
// Return the list ans
return ans;
}
// Driver code
static void Main()
{
int n = 2;
int m = 2;
int k = 3;
List<List<int> > grid
= new List<List<int> >{ new List<int>{ 0, 1 },
new List<int>{ 2, 2 } };
int q = 1;
List<List<int> > queries = new List<List<int> >{
new List<int>{ 1, 0, 0, 0, 1, 1 }
};
List<int> ans
= K_Transformation(n, m, k, grid, q, queries);
foreach(var a in ans) { Console.Write(a + " "); }
}
}
// This code is contributed by Susobhan Akhuli
// Javascript program for the above approach
// Function to find number of times a particular
// element occurring in a submatrix
function kTransformation(n, m, k, grid, q, queries) {
// Declare a 3D array storing count of 6 elements
let pre = new Array(n + 1).fill(0).map(() =>
new Array(m + 1).fill(0).map(() => new Array(6).fill(0))
);
// Iterate in grid
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
// Increment the frequency of
// element occurring
pre[i][j][grid[i][j]]++;
// Iterate for those 6 elements
for (let k1 = 0; k1 <= 5; k1++) {
// Store frequency of each
// element up to this coordinate
if (i - 1 >= 0)
pre[i][j][k1] += pre[i - 1][j][k1];
if (j - 1 >= 0)
pre[i][j][k1] += pre[i][j - 1][k1];
if (i - 1 >= 0 && j - 1 >= 0)
pre[i][j][k1] -= pre[i - 1][j - 1][k1];
}
}
}
// Initialise an array to store ans
let ans = [];
// Iterate in queries
for (let i of queries) {
let t = i[0];
let val = i[1];
let l1 = i[2];
let r1 = i[3];
let l2 = i[4];
let r2 = i[5];
// Calculating for a particular submatrix mentioned
let cnt = new Array(6).fill(0);
for (let j = 0; j <= 5; j++) {
cnt[j] = pre[l2][r2][j];
if (l1 - 1 >= 0) {
cnt[j] -= pre[l1 - 1][r2][j];
}
if (r1 - 1 >= 0) {
cnt[j] -= pre[l2][r1 - 1][j];
}
if (l1 - 1 >= 0 && r1 - 1 >= 0) {
cnt[j] += pre[l1 - 1][r1 - 1][j];
}
}
// Check how many elements have value
// equal to val by doing mod k
let c = 0;
for (let j = 0; j <= 5; j++) {
if (((j + t) % k) === val) {
c += cnt[j];
}
}
ans.push(c);
}
// Return the array ans
return ans;
}
// Driver code
let n = 2;
let m = 2;
let k = 3;
let grid = [[0, 1], [2, 2]];
let q = 1;
let queries = [[1, 0, 0, 0, 1, 1]];
let ans = kTransformation(n, m, k, grid, q, queries);
console.log(ans.join(' '));
// This code is contributed by Susobhan Akhuli
Output
2
Time Complexity: O(N * M)
Auxiliary Space: O(N * M)