Open In App

Queries in a Matrix

Last Updated : 23 Dec, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

Given two integers m and n, that describes the order m*n of a matrix mat[][], initially filled with integers from 1 to m*n sequentially in a row-major order. Also, there is a 2d array query[][] consisting of q queries, which contains three integers each, where the first integer t describes the type of query and the next two integers x and y describe the row or column that needs to be operated. The task is to process these q queries manipulating mat[][]. Every query is one of the following three types:

  • [1, x, y]: swap the xth and yth rows of mat[][].
  • [2, x, y]: swap the xth and yth columns of mat[][].
  • [3, x, y]: print the element at xth row and yth column of mat[][].

Examples: 

Input: m = 3, n = 3
query[][] = [[1, 0, 1],
[3, 0, 0],
[3, 1, 0],
[2, 0, 1],
[3, 0, 0],
[3, 1, 0]]

Output: 4 1 5 2

Explanation: Initially the matrix is:
mat[][] = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
First Operation [1, 0, 1]: We need to swap row 0 and row 1.
After this operation, matrix becomes:
mat[][] =[[4, 5, 6],
[1, 2, 3],
[7, 8, 9]]
For the next two operation, we are required to print the elements at given cells.
Fourth Operation [2, 0, 1]: We need to swap column 0 and column 1.
After this operation matrix becomes:
mat[][] =[[5, 4, 6],
[2, 1, 3],
[8, 7, 9]]
For the next two operation, we are required to print the elements at given cells.

Table of Content

[Naive Approach] - O(q*n) Time and O(m*n) Space

The idea is to create a matrix mat[][] of order m*n, initially filled with integers from 1 to m*n sequentially in a row-major order. For the queries of type 1 and 2, i.e. swap, traverse required row or column and swap the each of its elements. And for the query of type 3, i.e. print, we simply print the element at specified index.

C++ 
// C++ Program to perform queries in a matrix.
#include <bits/stdc++.h>
using namespace std;

// function to swap rows of the matrix.
void swapRows(vector<vector<int>> &mat, int r1, int r2) {
    for (int i = 0; i < mat[0].size(); i++) {
        swap(mat[r1][i], mat[r2][i]);
    }
}

// function to swap columns of the matrix.
void swapCols(vector<vector<int>> &mat, int c1, int c2) {
    for (int i = 0; i < mat.size(); i++) {
        swap(mat[i][c1], mat[i][c2]);
    }
}

// function to operate queries.
void solveQueries(int m, int n, vector<vector<int>> &query) {

    // create a matrix or order m*n, filled with
    // values from 1 to m*n.
    vector<vector<int>> mat(m, vector<int>(n));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            mat[i][j] = (i * n) + j + 1;
        }
    }

    // perform the queries on the matrix.
    for (int i = 0; i < query.size(); i++) {

        // if query is of type 1
        // swap the rows.
        if (query[i][0] == 1) {
            swapRows(mat, query[i][1], query[i][2]);
        }

        // if query is of type 2
        // swap the columns.
        else if (query[i][0] == 2) {
            swapCols(mat, query[i][1], query[i][2]);
        }

        // if query is of type 3
        // print the value at the given index.
        else {
            cout << mat[query[i][1]][query[i][2]] << " ";
        }
    }
}

int main() {
    int m = 3, n = 3;
    vector<vector<int>> query = {{1, 0, 1},
                                 {3, 0, 0},
                                 {3, 1, 0},
                                 {2, 0, 1},
                                 {3, 0, 0},
                                 {3, 1, 0}};
    solveQueries(m, n, query);
    return 0;
}
Java 
// Java Program to perform queries in a matrix.
import java.util.*;

class GfG {

    // function to swap rows of the matrix.
    static void swapRows(int[][] mat, int r1, int r2) {
        for (int i = 0; i < mat[0].length; i++) {
            int temp = mat[r1][i];
            mat[r1][i] = mat[r2][i];
            mat[r2][i] = temp;
        }
    }

    // function to swap columns of the matrix.
    static void swapCols(int[][] mat, int c1, int c2) {
        for (int i = 0; i < mat.length; i++) {
            int temp = mat[i][c1];
            mat[i][c1] = mat[i][c2];
            mat[i][c2] = temp;
        }
    }

    // function to operate queries.
    static void solveQueries(int m, int n, int[][] query) {

        // create a matrix or order m*n, filled with
        // values from 1 to m*n.
        int[][] mat = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                mat[i][j] = (i * n) + j + 1;
            }
        }

        // perform the queries on the matrix.
        for (int i = 0; i < query.length; i++) {

            // if query is of type 1
            // swap the rows.
            if (query[i][0] == 1) {
                swapRows(mat, query[i][1], query[i][2]);
            }

            // if query is of type 2
            // swap the columns.
            else if (query[i][0] == 2) {
                swapCols(mat, query[i][1], query[i][2]);
            }

            // if query is of type 3
            // print the value at the given index.
            else {
                System.out.print(mat[query[i][1]][query[i][2]] + " ");
            }
        }
    }

    public static void main(String[] args) {
        int m = 3, n = 3;
        int[][] query = {
            {1, 0, 1},
            {3, 0, 0},
            {3, 1, 0},
            {2, 0, 1},
            {3, 0, 0},
            {3, 1, 0}
        };
        solveQueries(m, n, query);
    }
}
Python 
# Python Program to perform queries in a matrix.

# function to swap rows of the matrix.
def swapRows(mat, r1, r2):
    mat[r1], mat[r2] = mat[r2], mat[r1]

# function to swap columns of the matrix.
def swapCols(mat, c1, c2):
    for row in mat:
        row[c1], row[c2] = row[c2], row[c1]

# function to operate queries.
def solveQueries(m, n, query):
  
    # create a matrix of order m*n, filled with
    # values from 1 to m*n.
    mat = [[(i * n) + j + 1 for j in range(n)] for i in range(m)]

    # perform the queries on the matrix.
    for q in query:
      
        # if query is of type 1
        # swap the rows.
        if q[0] == 1:
            swapRows(mat, q[1], q[2])

        # if query is of type 2
        # swap the columns.
        elif q[0] == 2:
            swapCols(mat, q[1], q[2])

        # if query is of type 3
        # print the value at the given index.
        else:
            print(mat[q[1]][q[2]], end=" ")

if __name__ == "__main__":
    m, n = 3, 3
    query = [
        [1, 0, 1],
        [3, 0, 0],
        [3, 1, 0],
        [2, 0, 1],
        [3, 0, 0],
        [3, 1, 0]
    ]
    solveQueries(m, n, query)
C# 
// C# Program to perform queries in a matrix.
using System;

class GfG {

    // function to swap rows of the matrix.
    static void SwapRows(int[,] mat, int r1, int r2) {
        for (int i = 0; i < mat.GetLength(1); i++) {
            int temp = mat[r1, i];
            mat[r1, i] = mat[r2, i];
            mat[r2, i] = temp;
        }
    }

    // function to swap columns of the matrix.
    static void SwapCols(int[,] mat, int c1, int c2) {
        for (int i = 0; i < mat.GetLength(0); i++) {
            int temp = mat[i, c1];
            mat[i, c1] = mat[i, c2];
            mat[i, c2] = temp;
        }
    }

    // function to operate queries.
    static void SolveQueries(int m, int n, int[][] query) {

        // create a matrix or order m*n, filled with
        // values from 1 to m*n.
        int[,] mat = new int[m, n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                mat[i, j] = (i * n) + j + 1;
            }
        }

        // perform the queries on the matrix.
        for (int i = 0; i < query.Length; i++) {

            // if query is of type 1
            // swap the rows.
            if (query[i][0] == 1) {
                SwapRows(mat, query[i][1], query[i][2]);
            }

            // if query is of type 2
            // swap the columns.
            else if (query[i][0] == 2) {
                SwapCols(mat, query[i][1], query[i][2]);
            }

            // if query is of type 3
            // print the value at the given index.
            else {
                Console.Write(mat[query[i][1], query[i][2]] + " ");
            }
        }
    }

    static void Main(string[] args) {
        int m = 3, n = 3;
        int[][] query = {
            new int[] { 1, 0, 1 },
            new int[] { 3, 0, 0 },
            new int[] { 3, 1, 0 },
            new int[] { 2, 0, 1 },
            new int[] { 3, 0, 0 },
            new int[] { 3, 1, 0 }
        };
        SolveQueries(m, n, query);
    }
}
JavaScript 
// JavaScript Program to perform queries in a matrix.

// function to swap rows of the matrix.
function swapRows(mat, r1, r2) {
    [mat[r1], mat[r2]] = [mat[r2], mat[r1]];
}

// function to swap columns of the matrix.
function swapCols(mat, c1, c2) {
    for (let i = 0; i < mat.length; i++) {
        [mat[i][c1], mat[i][c2]] = [mat[i][c2], mat[i][c1]];
    }
}

// function to operate queries.
function solveQueries(m, n, query) {

    // create a matrix or order m*n, filled with
    // values from 1 to m*n.
    const mat = Array.from({ length: m }, (_, i) =>
        Array.from({ length: n }, (_, j) => i * n + j + 1)
    );

    // perform the queries on the matrix.
    for (const q of query) {
    
        // if query is of type 1
        // swap the rows.
        if (q[0] === 1) {
            swapRows(mat, q[1], q[2]);
        }

        // if query is of type 2
        // swap the columns.
        else if (q[0] === 2) {
            swapCols(mat, q[1], q[2]);
        }

        // if query is of type 3
        // print the value at the given index.
        else {
            console.log(mat[q[1]][q[2]] + " ");
        }
    }
}

// driver code
const m = 3, n = 3;
const query = [
    [1, 0, 1],
    [3, 0, 0],
    [3, 1, 0],
    [2, 0, 1],
    [3, 0, 0],
    [3, 1, 0],
];
solveQueries(m, n, query);

Output
4 1 5 2

Time Complexity: O(q*n), required to perform q queries of type 1 and 2.
Auxiliary Space: O(m*n), auxiliary space required to create matrix mat[][] of order m*n.

[Expected Approach] - O(q) Time and O(m + n) Space

The element at any position mat[x][y] in the matrix can be described as mat[x][y] = (n*x) + y + 1, where n is the count of columns. Instead of modifying the matrix directly, we can use two auxiliary arrays, rows[m] and cols[n]. The rows array is initialized with values from 0 to m-1, representing the indices of the rows, and the cols array is initialized with values from 0 to n-1, representing the indices of the columns.

To process a query of type 1, which swaps rows x and y, we simply swap the values of rows[x] and rows[y]. Similarly, for a query of type 2, which swaps columns x and y, we swap the values of cols[x] and cols[y]. For a query of type 3, which print the value at position (x, y), we calculate the position using the formula, mat[x][y] = rows[x]*n + cols[y] + 1.

Below is implementation of above idea:

C++ 
// C++ Program to perform queries in a matrix.
#include <bits/stdc++.h>
using namespace std;

// function to operate queries.
void solveQueries(int m, int n, vector<vector<int>> &query) {

    // create two arrays rows and cols
    // and fill the value from 0 to size-1
    vector<int> rows(m), cols(n);
    for(int i = 0; i < m; i++) {
        rows[i] = i;
    }
    for(int i = 0; i < n; i++) {
        cols[i] = i;
    }

    // perform the queries on the matrix.
    for (int i = 0; i < query.size(); i++) {

        // if query is of type 1
        // swap the rows.
        if (query[i][0] == 1) {
            swap(rows[query[i][1]], rows[query[i][2]]);
        }

        // if query is of type 2
        // swap the columns.
        else if (query[i][0] == 2) {
            swap(cols[query[i][1]], cols[query[i][2]]);
        }

        // if query is of type 3
        // print the value at the given index.
        else {
            cout<< (rows[query[i][1]] * n) + cols[query[i][2]] + 1 << " ";
        }
    }
}

int main() {
    int m = 3, n = 3;
    vector<vector<int>> query = {{1, 0, 1},
                                 {3, 0, 0},
                                 {3, 1, 0},
                                 {2, 0, 1},
                                 {3, 0, 0},
                                 {3, 1, 0}};
    solveQueries(m, n, query);
    return 0;
}
Java 
// Java Program to perform queries in a matrix.
import java.util.*;

class GfG {

    // function to operate queries.
    static void solveQueries(int m, int n, int[][] query) {

        // create two arrays rows and cols
        // and fill the value from 0 to size-1
        int[] rows = new int[m];
        int[] cols = new int[n];
        for (int i = 0; i < m; i++) {
            rows[i] = i;
        }
        for (int i = 0; i < n; i++) {
            cols[i] = i;
        }

        // perform the queries on the matrix.
        for (int i = 0; i < query.length; i++) {

            // if query is of type 1
            // swap the rows.
            if (query[i][0] == 1) {
                int temp = rows[query[i][1]];  
                rows[query[i][1]] = rows[query[i][2]];
                rows[query[i][2]] = temp;
            }

            // if query is of type 2
            // swap the columns.
            else if (query[i][0] == 2) {
                int temp = cols[query[i][1]];
                cols[query[i][1]] = cols[query[i][2]];
                cols[query[i][2]] = temp;
            }

            // if query is of type 3
            // print the value at the given index.
            else {
                System.out.print((rows[query[i][1]]*n + 
                                  cols[query[i][2]] + 1) + " ");
            }
        }
    }

    public static void main(String[] args) {
        int m = 3, n = 3;
        int[][] query = {
            {1, 0, 1},
            {3, 0, 0},
            {3, 1, 0},
            {2, 0, 1},
            {3, 0, 0},
            {3, 1, 0}
        };
        solveQueries(m, n, query);
    }
}
Python 
# Python Program to perform queries in a matrix.

# function to operate queries.
def solveQueries(m, n, query):
  
    # create two arrays rows and cols
    # and fill the value from 0 to size-1
    rows = [i for i in range(m)]
    cols = [i for i in range(n)]

    # perform the queries on the matrix.
    for q in query:
      
        # if query is of type 1
        # swap the rows.
        if q[0] == 1:
            rows[q[1]], rows[q[2]] = rows[q[2]], rows[q[1]] 

        # if query is of type 2
        # swap the columns.
        elif q[0] == 2:
            cols[q[1]], cols[q[2]] = cols[q[2]], cols[q[1]]

        # if query is of type 3
        # print the value at the given index.
        else:
            print((rows[q[1]] * n) + cols[q[2]] + 1, end=" ")

if __name__ == "__main__":
    m, n = 3, 3
    query = [
        [1, 0, 1],
        [3, 0, 0],
        [3, 1, 0],
        [2, 0, 1],
        [3, 0, 0],
        [3, 1, 0]
    ]
    solveQueries(m, n, query)
C# 
// C# Program to perform queries in a matrix.
using System;

class GfG {

    // function to operate queries.
    static void SolveQueries(int m, int n, int[][] query) {

        // create two arrays rows and cols
        // and fill the value from 0 to size-1
        int[] rows = new int[m];
        int[] cols = new int[n];
        for(int i = 0; i < m; i++) {
            rows[i] = i;
        }
        for(int i = 0; i < n; i++) {
            cols[i] = i;
        }

        // perform the queries on the matrix.
        for (int i = 0; i < query.Length; i++) {

            // if query is of type 1
            // swap the rows.
            if (query[i][0] == 1) {
                int temp = rows[query[i][1]];  
                rows[query[i][1]] = rows[query[i][2]];
                rows[query[i][2]] = temp;
            }

            // if query is of type 2
            // swap the columns.
            else if (query[i][0] == 2) {
                int temp = cols[query[i][1]];
                cols[query[i][1]] = cols[query[i][2]];
                cols[query[i][2]] = temp;
            }

            // if query is of type 3
            // print the value at the given index.
            else {
                Console.Write((rows[query[i][1]]*n + cols[query[i][2]] + 1) + " ");
            }
        }
    }

    static void Main(string[] args) {
        int m = 3, n = 3;
        int[][] query = {
            new int[] { 1, 0, 1 },
            new int[] { 3, 0, 0 },
            new int[] { 3, 1, 0 },
            new int[] { 2, 0, 1 },
            new int[] { 3, 0, 0 },
            new int[] { 3, 1, 0 }
        };
        SolveQueries(m, n, query);
    }
}
JavaScript 
// JavaScript Program to perform queries in a matrix.

// function to operate queries.
function solveQueries(m, n, query) {

    // create two arrays rows and cols
    // and fill the value from 0 to size-1
    let rows = new Array(m);
    let cols = new Array(n);
    for (let i = 0; i < m; i++) {
        rows[i] = i;
    }
    for (let i = 0; i < n; i++) {
        cols[i] = i;
    }

    // perform the queries on the matrix.
    for (const q of query) {
    
        // if query is of type 1
        // swap the rows.
        if (q[0] === 1) {
            [rows[q[1]], rows[q[2]]] = [rows[q[2]], rows[q[1]]];
        }

        // if query is of type 2
        // swap the columns.
        else if (q[0] === 2) {
            [cols[q[1]], cols[q[2]]] = [cols[q[2]], cols[q[1]]];
        }

        // if query is of type 3
        // print the value at the given index.
        else {
            process.stdout.write(((rows[q[1]] * n) + cols[q[2]] + 1) + " ");
        }
    }
}

const m = 3, n = 3;
const query = [
    [1, 0, 1],
    [3, 0, 0],
    [3, 1, 0],
    [2, 0, 1],
    [3, 0, 0],
    [3, 1, 0],
];
solveQueries(m, n, query);

Output
4 1 5 2

Time Complexity: O(q), q = number of queries 
Auxiliary Space: O(m + n), auxiliary space required to create two arrays.


Next Article
Find pairs with given sum such that elements of pair are in different rows

S

Shashank Mishra ( Gullu )
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox