Gegeven twee matrixen een En B van grootte n*m . De taak is om het vereiste te vinden aantal transformatiestappen zodat beide matrices gelijk worden. Afdrukken -1 als dit niet mogelijk is.
De transformatie stap is als volgt:
- Selecteer een willekeurige matrix uit twee matrices.
- Kies een van beide rij/kolom van de geselecteerde matrix.
- Verhoog elk element van de selectie rij/kolom door 1.
Voorbeelden:
Invoer:
een[][] = [[1 1]
[1 1]]tekenreeks intb[][] = [[1 2]
[3 4]]Uitvoer : 3
Uitleg :
[[1 1] -> [[1 2] -> [[1 2] -> [[1 2]
[1 1]] [1 2]] [2 3]] [3 4]]
Invoer :
een[][] = [[1 1]
[1 0]]b[][] = [[1 2]
[3 4]]npm schone cacheUitvoer : -1
Uitleg : Geen enkele transformatie zal a en b gelijk maken.
Benadering:
Het idee is dat oplopend elke rij/kolom in matrix een is gelijkwaardig aan afnemend dezelfde rij/kolom in matrix b .
Dit betekent dat we, in plaats van beide matrices bij te houden, met hun verschil kunnen werken (a[i][j] - b[i][j]). Wanneer we een rij verhogen in ' A' alle elementen in die rij worden met 1 verhoogd, wat hetzelfde is als alle elementen in die rij van de verschilmatrix met 1 toenemen. Op dezelfde manier verhogen we een kolom in ' A' het komt overeen met het verhogen van alle elementen in die kolom van de verschilmatrix met 1.
Hierdoor kunnen we het probleem transformeren naar het werken met slechts één matrix.
Bepaal of er een oplossing bestaat of niet:
1 miljoen nummer
Na het maken van de verschilmatrix voor elke cel een[i][j] (exclusief de eerste rij en eerste kolom) controleren we of
a[i][j] - a[i][0] - a[0][j] + a[0][0] = 0.
Als deze vergelijking voor geen enkele cel geldt, kunnen we onmiddellijk concluderen dat er geen oplossing bestaat.
Waarom werkt dit?
Denk na over hoe rij en kolom operaties hebben invloed op elke cel: wanneer we presteren X bewerkingen op rij i En En bewerkingen op kolom J een[i][j] verandert met (x + y) een[ik][0] verandert door x (alleen rijbewerkingen) a[0][j] verandert door y (alleen kolombewerkingen) en a[0][0] wordt beïnvloed door noch rij i, noch kolom j operaties. Daarom (x + y) - x - y + 0 = 0 moet gelden voor elke geldige oplossing. Als deze vergelijking voor geen enkele cel geldt, betekent dit dat geen enkele reeks rij- en kolombewerkingen de ene matrix in de andere kan transformeren.
Bereken het aantal benodigde transformaties:
C++Om het aantal benodigde transformaties te berekenen, hoeven we alleen maar naar de eerste rij En eerste kolom omdat:
- Wij sommen eerst op |a[i][0]| voor alle i (elk eerste kolomelement) omdat dit aangeeft hoeveel rijbewerkingen we nodig hebben. Voor elke rij i hebben we |a[i][0]| nodig bewerkingen om dat rij-element nul te maken.
- Dan vatten we samen |a[0][j] - a[0][0]| voor alle j (elk eerste rij-element minus eerste element) omdat dit de benodigde aanvullende kolombewerkingen vertegenwoordigt. We trekken a[0][0] af om te voorkomen dat deze twee keer wordt geteld, omdat rijbewerkingen dit element al hebben beïnvloed.
- De som van deze twee geeft ons de minimaal aantal handelingen nodig omdat rijbewerkingen de eerste kolomverschillen afhandelen en kolombewerkingen de resterende verschillen in de eerste rij afhandelen.
// C++ program to find number of transformation // to make two Matrix Equal #include
// Java program to find number of transformation // to make two Matrix Equal import java.util.*; class GfG { static int countOperations(int[][] a int[][] b) { int n = a.length; int m = a[0].length; // Create difference matrix (a = a - b) for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { a[i][j] -= b[i][j]; } } // Check if transformation is possible using the // property a[i][j] - a[i][0] - a[0][j] + a[0][0] // should be 0 for (int i = 1; i < n; i++) { for (int j = 1; j < m; j++) { if (a[i][j] - a[i][0] - a[0][j] + a[0][0] != 0) { return -1; } } } int result = 0; // Add operations needed for first column for (int i = 0; i < n; i++) { result += Math.abs(a[i][0]); } // Add operations needed for // first row (excluding a[0][0]) for (int j = 0; j < m; j++) { result += Math.abs(a[0][j] - a[0][0]); } return result; } public static void main(String[] args) { int[][] a = { { 1 1 } { 1 1 } }; int[][] b = { { 1 2 } { 3 4 } }; System.out.println(countOperations(a b)); } }
# Python program to find number of transformation # to make two Matrix Equal def countOperations(a b): n = len(a) m = len(a[0]) # Create difference matrix (a = a - b) for i in range(n): for j in range(m): a[i][j] -= b[i][j] # Check if transformation is possible using the property # a[i][j] - a[i][0] - a[0][j] + a[0][0] should be 0 for i in range(1 n): for j in range(1 m): if a[i][j] - a[i][0] - a[0][j] + a[0][0] != 0: return -1 result = 0 # Add operations needed for first column for i in range(n): result += abs(a[i][0]) # Add operations needed for # first row (excluding a[0][0]) for j in range(m): result += abs(a[0][j] - a[0][0]) return result if __name__ == '__main__': a = [ [1 1] [1 1] ] b = [ [1 2] [3 4] ] print(countOperations(a b))
// C# program to find number of transformation // to make two Matrix Equal using System; class GfG { static int countOperations(int[ ] a int[ ] b) { int n = a.GetLength(0); int m = a.GetLength(1); // Create difference matrix (a = a - b) for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { a[i j] -= b[i j]; } } // Check if transformation is possible using the // property a[i j] - a[i 0] - a[0 j] + a[0 0] // should be 0 for (int i = 1; i < n; i++) { for (int j = 1; j < m; j++) { if (a[i j] - a[i 0] - a[0 j] + a[0 0] != 0) { return -1; } } } int result = 0; // Add operations needed for first column for (int i = 0; i < n; i++) { result += Math.Abs(a[i 0]); } // Add operations needed for // first row (excluding a[0 0]) for (int j = 0; j < m; j++) { result += Math.Abs(a[0 j] - a[0 0]); } return result; } static void Main(string[] args) { int[ ] a = { { 1 1 } { 1 1 } }; int[ ] b = { { 1 2 } { 3 4 } }; Console.WriteLine(countOperations(a b)); } }
// JavaScript program to find number of transformation // to make two Matrix Equal function countOperations(a b) { let n = a.length; let m = a[0].length; // Create difference matrix (a = a - b) for (let i = 0; i < n; i++) { for (let j = 0; j < m; j++) { a[i][j] -= b[i][j]; } } // Check if transformation is possible using the // property a[i][j] - a[i][0] - a[0][j] + a[0][0] should // be 0 for (let i = 1; i < n; i++) { for (let j = 1; j < m; j++) { if (a[i][j] - a[i][0] - a[0][j] + a[0][0] !== 0) { return -1; } } } let result = 0; // Add operations needed for first column for (let i = 0; i < n; i++) { result += Math.abs(a[i][0]); } // Add operations needed for // first row (excluding a[0][0]) for (let j = 0; j < m; j++) { result += Math.abs(a[0][j] - a[0][0]); } return result; } //Driver code let a = [ [ 1 1 ] [ 1 1 ] ]; let b = [ [ 1 2 ] [ 3 4 ] ]; console.log(countOperations(a b));
Uitvoer
3
Tijdcomplexiteit: O(n*m)
Hulpruimte: O(1)
veerlaarsarchitectuurQuiz maken