Related Articles

Print matrix elements from top-left to bottom right in diagonally upward manner

• Difficulty Level : Easy
• Last Updated : 17 Jun, 2021

Given a vectors of vectors arr[], the task is to print the elements of arr[] in the diagonally upwards order as illustrated below.

Examples:

Input: arr[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
Output: 1 4 2 7 5 3 8 6 9
Explanation:
Below is the illustration of how diagonally upward order is printed:

Input: arr[][] = {{1, 2, 3, 4, 5}, {6, 7}, {8}, {9, 10, 11}, {12, 13, 14, 15, 16}}
Output: 1 6 28 7 3 9 4 12 10 5 13 11 14 15 16
Explanation:
Below is the illustration of how diagonally upward order is printed:

Approach: The idea is based on the observation that all elements in a particular upward diagonal have a sum equal to the (row index + column index). Follow the steps to solve the problem:

• Initialize a vector of vectors v to store the elements in the desired format.
• Iterate over the matrix arr[][] using variables i and j and for each i and j push arr[i][j] to v[i + j].
• After the above steps, reverse every row in the v.
• Now, print all elements in stored in v row-wise to get the desired result.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to traverse the matrix``// diagonally upwards``void` `printDiagonalTraversal(``    ``vector >& nums)``{``    ``// Stores the maximum size of vector``    ``// from all row of matrix nums[][]``    ``int` `max_size = nums.size();` `    ``for` `(``int` `i = 0; i < nums.size(); i++) {``        ``if` `(max_size < nums[i].size()) {``            ``max_size = nums[i].size();``        ``}``    ``}` `    ``// Store elements in desired order``    ``vector > v(2 * max_size - 1);` `    ``// Store every element on the basis``    ``// of sum of index (i + j)``    ``for` `(``int` `i = 0; i < nums.size(); i++) {` `        ``for` `(``int` `j = 0;``             ``j < nums[i].size(); j++) {``            ``v[i + j].push_back(nums[i][j]);``        ``}``    ``}` `    ``// Print the stored result``    ``for` `(``int` `i = 0; i < v.size(); i++) {` `        ``// Reverse all sublist``        ``reverse(v[i].begin(), v[i].end());` `        ``for` `(``int` `j = 0; j < v[i].size(); j++)``            ``cout << v[i][j] << ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``// Given vector of vectors arr``    ``vector > arr``        ``= { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };` `    ``// Function Call``    ``printDiagonalTraversal(arr);` `    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `// Function to traverse the matrix``// diagonally upwards``static` `void` `printDiagonalTraversal(``int``[][] nums)``{``    ` `    ``// Stores the maximum size of vector``    ``// from all row of matrix nums[][]``    ``int` `max_size = nums[``0``].length;``  ` `    ``// Store elements in desired order``    ``ArrayList<``    ``ArrayList> v = ``new` `ArrayList<``                                ``ArrayList>();``                                ` `    ``for``(``int` `i = ``0``; i < ``2` `* max_size - ``1``; i++)``    ``{``        ``v.add(``new` `ArrayList());``    ``}``  ` `    ``// Store every element on the basis``    ``// of sum of index (i + j)``    ``for``(``int` `i = ``0``; i < nums[``0``].length; i++)``    ``{``        ``for``(``int` `j = ``0``; j < nums[``0``].length; j++)``        ``{``            ``v.get(i + j).add(nums[i][j]);``        ``}``    ``}``  ` `    ``// Print the stored result``    ``for``(``int` `i = ``0``; i < v.size(); i++)``    ``{``         ` `        ``// Print in reverse order``        ``for``(``int` `j = v.get(i).size() - ``1``;``                ``j >= ``0``; j--)``        ``{``            ``System.out.print(v.get(i).get(j) + ``" "``);``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given vector of vectors arr``    ``int``[][] arr = { { ``1``, ``2``, ``3` `},``                    ``{ ``4``, ``5``, ``6` `},``                    ``{ ``7``, ``8``, ``9` `} };``     ` `    ``// Function Call``    ``printDiagonalTraversal(arr);``}``}` `// This code is contributed by divyeshrabadiya07`

Python3

 `# Python3 program for the above approach` `# Function to traverse the matrix``# diagonally upwards``def` `printDiagonalTraversal(nums):``    ` `    ``# Stores the maximum size of vector``    ``# from all row of matrix nums[][]``    ``max_size ``=` `len``(nums)` `    ``for` `i ``in` `range``(``len``(nums)):``        ``if` `(max_size < ``len``(nums[i])):``            ``max_size ``=` `len``(nums[i])` `    ``# Store elements in desired order``    ``v ``=` `[[] ``for` `i ``in` `range``(``2` `*` `max_size ``-` `1``)]` `    ``# Store every element on the basis``    ``# of sum of index (i + j)``    ``for` `i ``in` `range``(``len``(nums)):``        ``for` `j ``in` `range``(``len``(nums[i])):``            ``v[i ``+` `j].append(nums[i][j])` `    ``# Print the stored result``    ``for` `i ``in` `range``(``len``(v)):` `        ``# Reverse all sublist``        ``v[i] ``=` `v[i][::``-``1``]` `        ``for` `j ``in` `range``(``len``(v[i])):``            ``print``(v[i][j], end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given vector of vectors arr``    ``arr ``=` `[ [ ``1``, ``2``, ``3` `],``            ``[ ``4``, ``5``, ``6` `],``            ``[ ``7``, ``8``, ``9` `] ]` `    ``# Function Call``    ``printDiagonalTraversal(arr)` `# This code is contributed by mohit kumar 29`

C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic; ` `class` `GFG{``    ` `// Function to traverse the matrix``// diagonally upwards``static` `void` `printDiagonalTraversal(``int``[,] nums)``{``    ` `    ``// Stores the maximum size of vector``    ``// from all row of matrix nums[][]``    ``int` `max_size = nums.GetLength(0);`` ` `    ``// Store elements in desired order``    ``List> v = ``new` `List>();``    ``for``(``int` `i = 0; i < 2 * max_size - 1; i++)``    ``{``        ``v.Add(``new` `List<``int``>());``    ``}`` ` `    ``// Store every element on the basis``    ``// of sum of index (i + j)``    ``for``(``int` `i = 0; i < nums.GetLength(0); i++)``    ``{``        ``for``(``int` `j = 0; j < nums.GetLength(0); j++)``        ``{``            ``v[i + j].Add(nums[i, j]);``        ``}``    ``}`` ` `    ``// Print the stored result``    ``for``(``int` `i = 0; i < v.Count; i++)``    ``{``        ` `        ``// print in reverse order``        ``for``(``int` `j = v[i].Count - 1; j >= 0; j--)``        ``{``            ``Console.Write(v[i][j] + ``" "``);``        ``}``    ``}``}` `// Driver Code``static` `void` `Main()``{``    ` `    ``// Given vector of vectors arr``    ``int``[,] arr = { { 1, 2, 3 },``                   ``{ 4, 5, 6 },``                   ``{ 7, 8, 9 } };``    ` `    ``// Function Call``    ``printDiagonalTraversal(arr);``}``}` `// This code is contributed by divyesh072019`

Javascript

 ``
Output:
`1 4 2 7 5 3 8 6 9`

Time Complexity: O(N*M), where N is the size of the given matrix and M is maximum size of any row in the matrix.
Auxiliary Space: O(N*M)

Alternate Approach: The above problem can be also be solved by using queue. Follow the steps to solve the problem:

• Initialize a queue Q, and insert the index of the first cell of arr[][], i.e., (0, 0).
• Initialize a vector v to store the elements in the desired format.
• While q is not empty, do the following:
• Pop the element at front of the queue and push it in v.
• Push the index of the current cell just below it, only if the current cell is the first in its row.
• Push the index of its right neighbor cell if it exists.
• After the above steps, print all elements stored in v.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to traverse the matrix``// diagonally upwards``void` `printDiagonalTraversal(``    ``vector >& nums)``{``    ``// Store the number of rows``    ``int` `m = nums.size();` `    ``// Initialize queue``    ``queue > q;` `    ``// Push the index of first element``    ``// i.e., (0, 0)``    ``q.push({ 0, 0 });` `    ``while` `(!q.empty()) {` `        ``// Get the front element``        ``pair<``int``, ``int``> p = q.front();` `        ``// Pop the element at the front``        ``q.pop();``        ``cout << nums[p.first][p.second]``             ``<< ``" "``;` `        ``// Insert the element below``        ``// if the current element is``        ``// in first column``        ``if` `(p.second == 0``            ``&& p.first + 1 < m) {``            ``q.push({ p.first + 1,``                     ``p.second });``        ``}` `        ``// Insert the right neighbour``        ``// if it exists``        ``if` `(p.second + 1 < nums[p.first].size())``            ``q.push({ p.first,``                     ``p.second + 1 });``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given vector of vectors arr``    ``vector > arr``        ``= { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };` `    ``// Function call``    ``printDiagonalTraversal(arr);` `    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `    ``static` `class` `pair``    ``{``        ``int` `first, second;``        ``public` `pair(``int` `first, ``int` `second) ``        ``{``            ``this``.first = first;``            ``this``.second = second;``        ``}   ``    ``}``  ` `// Function to traverse the matrix``// diagonally upwards``static` `void` `printDiagonalTraversal(``    ``int` `[][]nums)``{``  ` `    ``// Store the number of rows``    ``int` `m = nums.length;` `    ``// Initialize queue``    ``Queue q = ``new` `LinkedList<>();` `    ``// Push the index of first element``    ``// i.e., (0, 0)``    ``q.add(``new` `pair( ``0``, ``0` `));` `    ``while` `(!q.isEmpty()) {` `        ``// Get the front element``        ``pair p = q.peek();` `        ``// Pop the element at the front``        ``q.remove();``        ``System.out.print(nums[p.first][p.second]``            ``+ ``" "``);` `        ``// Insert the element below``        ``// if the current element is``        ``// in first column``        ``if` `(p.second == ``0``            ``&& p.first + ``1` `< m) {``            ``q.add(``new` `pair( p.first + ``1``,``                     ``p.second ));``        ``}` `        ``// Insert the right neighbour``        ``// if it exists``        ``if` `(p.second + ``1` `< nums[p.first].length)``            ``q.add(``new` `pair(  p.first,``                     ``p.second + ``1` `));``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``// Given vector of vectors arr``    ``int``[][] arr``        ``= { { ``1``, ``2``, ``3` `}, { ``4``, ``5``, ``6` `}, { ``7``, ``8``, ``9` `} };` `    ``// Function call``    ``printDiagonalTraversal(arr);` `}``}` `// This code is contributed by Amit Katiyar`

Python3

 `# Python3 program for the above approach` `# Function to traverse the matrix``# diagonally upwards``def` `printDiagonalTraversal(nums):` `    ``# Store the number of rows``    ``m ``=` `len``(nums)` `    ``# Initialize queue``    ``q ``=` `[]` `    ``# Push the index of first element``    ``# i.e., (0, 0)``    ``q.append([ ``0``, ``0` `])` `    ``while` `(``len``(q) !``=` `0``):` `        ``# Get the front element``        ``p ``=` `q[``0``]` `        ``# Pop the element at the front``        ``q.pop(``0``);``        ``print``(nums[p[``0``]][p[``1``]], end ``=` `" "``)` `        ``# Insert the element below``        ``# if the current element is``        ``# in first column``        ``if` `(p[``1``] ``=``=` `0``            ``and` `p[``0``] ``+` `1` `< m):``            ``q.append([ p[``0``]``+` `1``,``                     ``p[``1``] ]);``        ` `        ``# Insert the right neighbour``        ``# if it exists``        ``if` `(p[``1``] ``+` `1` `< ``len``(nums[p[``0``]])):``            ``q.append([ p[``0``],``                     ``p[``1``] ``+` `1` `]);` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``# Given vector of vectors arr``    ``arr ``=` `[[ ``1``, ``2``, ``3` `], [ ``4``, ``5``, ``6` `] ,[ ``7``, ``8``, ``9` `]]` `    ``# Function call``    ``printDiagonalTraversal(arr);` `    ``# This code is contributed by chitranayal`

C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``public` `class` `GFG``{``    ``class` `pair``    ``{``        ``public` `int` `first, second;``        ``public` `pair(``int` `first, ``int` `second) ``        ``{``            ``this``.first = first;``            ``this``.second = second;``        ``}   ``    ``}``  ` `// Function to traverse the matrix``// diagonally upwards``static` `void` `printDiagonalTraversal(``    ``int` `[,]nums)``{``  ` `    ``// Store the number of rows``    ``int` `m = nums.GetLength(0);` `    ``// Initialize queue``    ``Queue q = ``new` `Queue();` `    ``// Push the index of first element``    ``// i.e., (0, 0)``    ``q.Enqueue(``new` `pair(0, 0));``    ``while` `(q.Count != 0)``    ``{` `        ``// Get the front element``        ``pair p = q.Peek();` `        ``// Pop the element at the front``        ``q.Dequeue();``        ``Console.Write(nums[p.first,p.second]``            ``+ ``" "``);` `        ``// Insert the element below``        ``// if the current element is``        ``// in first column``        ``if` `(p.second == 0``            ``&& p.first + 1 < m)``        ``{``            ``q.Enqueue(``new` `pair( p.first + 1,``                     ``p.second ));``        ``}` `        ``// Insert the right neighbour``        ``// if it exists``        ``if` `(p.second + 1 < nums.GetLength(1))``            ``q.Enqueue(``new` `pair(  p.first,``                     ``p.second + 1 ));``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ` `    ``// Given vector of vectors arr``    ``int``[,] arr``        ``= { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };` `    ``// Function call``    ``printDiagonalTraversal(arr);``}``}` `// This code is contributed by shikhasingrajput`

Javascript

 ``
Output:
`1 4 2 7 5 3 8 6 9`

Time Complexity: O(N*M), where N is the size of the given matrix and M is maximum size of any row in the matrix.
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Participate in the Scholorship Test for First-Step-to-DSA Course for Class 9 to 12 students.

My Personal Notes arrow_drop_up