# Color a grid such that all same color cells are connected either horizontally or vertically

Given three integers R, C, N, and an array arr[] of size N. The task is to color all cells of a grid of R rows and C columns such that all same color cells are connected either horizontally or vertically. N represents the colors numbered from 1 to N and arr[] denotes the quantity of each color. The total quantity of color is exactly equal to the total number of cells of the grid.

Approach:

Input: R = 3, C = 5, N = 5, arr[] = {1, 2, 3, 4, 5}
Output:
1 4 4 4 3
2 5 4 5 3
2 5 5 5 3
Explanation: Available colors are 1(count = 1), 2(count = 2), 3(count = 3) etc.
For color 5: we can reach all color 5s by going horizontally or vertically through the same color 5.
Similarly for color 3, the rightmost row contains all 3 etc.
Similarly, for the rest of the colors 1, 2, 4.
Below is an invalid grid:
1 4 3 4 4
2 5 4 5 3
2 5 5 5 3
This is because the connection for the colors 3 and 4 has been broken by the invalid position of 3
in the position(0, 2).We can no longer traverse through all the 4s or all the 3s, horizontally or vertically, by passing through the respective 3s and 4s only.

Input: R = 2, C = 2, N = 3, arr[] = {2, 1, 1}
Output:
1 1
2 3

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

At first glance, it might seem that graph algorithms are required. However, we are going to follow an optimised greedy algorithm.

1. Create a new 2D array which will be our final grid. Let us call it dp[][].
2. Traverse the color array A[]
3. For each color i having A[i] quantities
• If the row is an odd numbered row, fill the dp array from left to right
• Else if it is an even row, fill it from right to left
4. If the quantity of a color is used up, move on to the next color greedily
5. ```Arrow directions for filling the dp array:
------->
<-------
-------->
<--------```

Example: R = 3, C = 5, N = 5, A = [1, 2, 3, 4, 5]

```1 2 2 3 3
[row 0 -> fill from left to right]
4 4 4 4 3
[row 1 -> fill from right to left]
5 5 5 5 5 [row 2 -> fill from left to right]```

Below is the implementation of the above approach:

 `// C++ Program to Color a grid ` `// such that all same color cells ` `// are connected either ` `// horizontally or vertically ` ` `  `#include ` `using` `namespace` `std; ` ` `  `void` `solve(vector<``int``>& arr, ` `           ``int` `r, ``int` `c) ` `{ ` `    ``// Current color ` `    ``int` `idx = 1; ` ` `  `    ``// final grid ` `    ``int` `dp[r]; ` ` `  `    ``for` `(``int` `i = 0; i < r; i++) { ` ` `  `        ``// if even row ` `        ``if` `(i % 2 == 0) { ` ` `  `            ``// traverse from left to ` `            ``// right ` `            ``for` `(``int` `j = 0; j < c; j++) { ` ` `  `                ``// if color has been exhausted ` `                ``//, move to the next color ` `                ``if` `(arr[idx - 1] == 0) ` `                    ``idx++; ` ` `  `                ``// color the grid at ` `                ``// this position ` `                ``dp[i][j] = idx; ` ` `  `                ``// reduce the color count ` `                ``arr[idx - 1]--; ` `            ``} ` `        ``} ` `        ``else` `{ ` ` `  `            ``// traverse from right to ` `            ``// left for odd rows ` `            ``for` `(``int` `j = c - 1; j >= 0; j--) { ` `                ``if` `(arr[idx - 1] == 0) ` `                    ``idx++; ` `                ``dp[i][j] = idx; ` `                ``arr[idx - 1]--; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// print the grid ` `    ``for` `(``int` `i = 0; i < r; ++i) { ` `        ``for` `(``int` `j = 0; j < c; ++j) { ` `            ``cout << dp[i][j] << ``" "``; ` `        ``} ` `        ``cout << endl; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `r = 3, c = 5; ` `    ``int` `n = 5; ` `    ``vector<``int``> arr ` `        ``= { 1, 2, 3, 4, 5 }; ` `    ``solve(arr, r, c); ` `    ``return` `0; ` `} `

 `// Java program to color a grid            ` `// such that all same color cells            ` `// are connected either            ` `// horizontally or vertically            ` `import` `java.util.*;     ` ` `  `class` `GFG{           ` `            `  `static` `void` `solve(List arr, ` `                  ``int` `r, ``int` `c)            ` `{  ` `     `  `    ``// Current color            ` `    ``int` `idx = ``1``;            ` `            `  `    ``// Final grid            ` `    ``int``[][] dp = ``new` `int``[r];            ` `            `  `    ``for``(``int` `i = ``0``; i < r; i++) ` `    ``{            ` `         `  `        ``// If even row            ` `        ``if` `(i % ``2` `== ``0``) ` `        ``{ ` `             `  `            ``// Traverse from left to            ` `            ``// right            ` `            ``for``(``int` `j = ``0``; j < c; j++) ` `            ``{ ` `                 `  `                ``// If color has been exhausted  ` `                ``//, move to the next color  ` `                ``if` `(arr.get(idx - ``1``) == ``0``)       ` `                    ``idx++;  ` `                 `  `                ``// Color the grid at  ` `                ``// this position ` `                ``dp[i][j] = idx;  ` `                 `  `                ``// Reduce the color count  ` `                ``arr.set(idx - ``1``, ` `                ``arr.get(idx - ``1``) - ``1``);  ` `            ``} ` `        ``} ` `        ``else` `        ``{ ` `             `  `            ``// Traverse from right to  ` `            ``// left for odd rows  ` `            ``for``(``int` `j = c - ``1``; j >= ``0``; j--) ` `            ``{ ` `                ``if` `(arr.get(idx - ``1``) == ``0``)       ` `                    ``idx++;  ` `             `  `                ``dp[i][j] = idx;  ` `             `  `                ``arr.set(idx - ``1``,  ` `                ``arr.get(idx - ``1``) - ``1``);  ` `            ``}           ` `        ``}            ` `    ``}            ` `            `  `    ``// Print the grid            ` `    ``for``(``int` `i = ``0``; i < r; ++i)  ` `    ``{            ` `        ``for``(``int` `j = ``0``; j < c; ++j) ` `        ``{            ` `            ``System.out.print(dp[i][j] + ``" "``);            ` `        ``}            ` `        ``System.out.println();            ` `    ``}            ` `}           ` `        `  `// Driver Code           ` `public` `static` `void` `main (String[] args) ` `{           ` `    ``int` `r = ``3``, c = ``5``;            ` `    ``int` `n = ``5``;            ` `    ``List arr = Arrays.asList(``1``, ``2``, ``3``, ``4``, ``5``);  ` `     `  `    ``solve(arr, r, c);            ` `}           ` `} ` ` `  `// This code is contributed by offbeat `

 `# Python3 program to color a grid ` `# such that all same color cells ` `# are connected either ` `# horizontally or vertically ` `def` `solve(arr, r, c): ` `     `  `    ``# Current color ` `    ``idx ``=` `1` ` `  `    ``# Final grid ` `    ``dp ``=` `[[``0` `for` `i ``in` `range``(c)] ` `             ``for` `i ``in` `range``(r)] ` ` `  `    ``for` `i ``in` `range``(r): ` ` `  `        ``# If even row ` `        ``if` `(i ``%` `2` `=``=` `0``): ` ` `  `            ``# Traverse from left to ` `            ``# right ` `            ``for` `j ``in` `range``(c): ` ` `  `                ``# If color has been exhausted, ` `                ``# move to the next color ` `                ``if` `(arr[idx ``-` `1``] ``=``=` `0``): ` `                    ``idx ``+``=` `1` ` `  `                ``# Color the grid at ` `                ``# this position ` `                ``# print(i,j) ` `                ``dp[i][j] ``=` `idx ` ` `  `                ``# Reduce the color count ` `                ``arr[idx ``-` `1``] ``-``=` `1` `        ``else``: ` ` `  `            ``# Traverse from right to ` `            ``# left for odd rows ` `            ``for` `j ``in` `range``(c ``-` `1``, ``-``1``, ``-``1``): ` `                ``if` `(arr[idx ``-` `1``] ``=``=` `0``): ` `                    ``idx ``+``=` `1` `                     `  `                ``dp[i][j] ``=` `idx ` `                ``arr[idx ``-` `1``] ``-``=` `1` ` `  `    ``# Print the grid ` `    ``for` `i ``in` `range``(r): ` `        ``for` `j ``in` `range``(c): ` `            ``print``(dp[i][j], end ``=` `" "``) ` ` `  `        ``print``() ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``r ``=` `3` `    ``c ``=` `5` `    ``n ``=` `5` `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5` `] ` `     `  `    ``solve(arr, r, c) ` ` `  `# This code is contributed by mohit kumar 29 `

 `// C# program to color a grid          ` `// such that all same color cells          ` `// are connected either          ` `// horizontally or vertically          ` `using` `System;  ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG{          ` `             `  `static` `void` `solve(List<``int``> arr, ` `                ``int` `r, ``int` `c)          ` `{  ` `     `  `    ``// Current color          ` `    ``int` `idx = 1;          ` `             `  `    ``// Final grid          ` `    ``int``[,] dp = ``new` `int``[r, c];          ` `             `  `    ``for``(``int` `i = 0; i < r; i++) ` `    ``{          ` `         `  `        ``// If even row          ` `        ``if` `(i % 2 == 0) ` `        ``{ ` `             `  `            ``// Traverse from left to          ` `            ``// right          ` `            ``for``(``int` `j = 0; j < c; j++) ` `            ``{ ` `                 `  `                ``// If color has been exhausted,  ` `                ``// move to the next color  ` `                ``if` `(arr[idx - 1] == 0)      ` `                    ``idx++;  ` `                 `  `                ``// Color the grid at  ` `                ``// this position ` `                ``dp[i, j] = idx;  ` `                 `  `                ``// Reduce the color count  ` `                ``arr[idx - 1] = arr[idx - 1] - 1;  ` `            ``} ` `        ``} ` `        ``else` `        ``{ ` `             `  `            ``// Traverse from right to  ` `            ``// left for odd rows  ` `            ``for``(``int` `j = c - 1; j >= 0; j--) ` `            ``{ ` `                ``if` `(arr[idx - 1] == 0)      ` `                    ``idx++;  ` `             `  `                ``dp[i, j] = idx;  ` `                ``arr[idx - 1] = arr[idx - 1] - 1;  ` `            ``}          ` `        ``}          ` `    ``}          ` `             `  `    ``// Print the grid          ` `    ``for``(``int` `i = 0; i < r; ++i)  ` `    ``{          ` `        ``for``(``int` `j = 0; j < c; ++j) ` `        ``{          ` `            ``Console.Write(dp[i, j] + ``" "``);          ` `        ``}          ` `        ``Console.Write(``'\n'``);          ` `    ``}          ` `}          ` `         `  `// Driver Code          ` `public` `static` `void` `Main (``string``[] args) ` `{          ` `    ``int` `r = 3, c = 5;          ` `    ``//int n = 5;     ` `     `  `    ``List<``int``> arr = ``new` `List<``int``>(); ` `    ``arr.Add(1);  ` `    ``arr.Add(2); ` `    ``arr.Add(3); ` `    ``arr.Add(4); ` `    ``arr.Add(5); ` `     `  `    ``solve(arr, r, c);          ` `}          ` `} ` ` `  `// This code is contributed by rutvik_56 `

Output:
```1 2 2 3 3
4 4 4 4 3
5 5 5 5 5
```

Time Complexity: O(R * C), where R = rows, C = columns
Auxiliary Space: O(R * C), where R = rows, C = columns