Givet två matriser a och b av storlek n*m . Uppgiften är att hitta det som krävs antal transformationssteg så att båda matriserna blir lika. Skriva ut -1 om detta inte är möjligt.
De omvandling steget är som följer:
- Välj valfri matris av två matriser.
- Välj antingen rad/kolumn av den valda matrisen.
- Öka varje element i markeringen rad/kolumn vid 1.
Exempel:
Input:
a[][] = [[1 1]
[1 1]]rensa npm-cacheb[][] = [[1 2]
[3 4]]Produktion : 3
Förklaring :
[[1 1] -> [[1 2] -> [[1 2] -> [[1 2]
[1 1]] [1 2]] [2 3]] [3 4]]
Input :
a[][] = [[1 1]
[1 0]]b[][] = [[1 2]
[3 4]]npm ren cacheProduktion : -1
Förklaring : Ingen transformation kommer att göra a och b lika.
Närma sig:
Tanken är den ökar valfri rad/kolumn in matris a motsvarar minskar samma rad/kolumn in matris b .
Det betyder att istället för att spåra båda matriserna kan vi arbeta med deras skillnad (a[i][j] - b[i][j]). När vi ökar en rad i ' a' alla element i den raden ökar med 1, vilket är samma sak som att alla element i den raden i differensmatrisen ökar med 1. På samma sätt när vi ökar en kolumn i ' a' det motsvarar att öka alla element i den kolumnen i skillnadsmatrisen med 1.
Detta gör att vi kan omvandla problemet till att arbeta med bara en matris.
Bestäm om någon lösning finns eller inte:
ipconfig för ubuntu
Efter att ha skapat skillnadsmatris för varje cell a[i][j] (exklusive första raden och första kolumnen) kontrollerar vi om
a[i][j] - a[i][0] - a[0][j] + a[0][0] = 0.
Om denna ekvation inte håller för någon cell kan vi omedelbart dra slutsatsen att det inte finns någon lösning.
Varför fungerar detta?
Fundera på hur rad och kolumn operationer påverkar varje cell: när vi utför x operationer på rad i och och operationer på kolumn j a[i][j] ändras med (x + y) a[i][0] ändringar med x (endast radoperationer) a[0][j] ändringar med y (endast kolumnoperationer) och a[0][0] påverkas av varken rad i eller kolumn j operationer. Därför (x + y) - x - y + 0 = 0 måste hålla för någon giltig lösning. Om denna ekvation inte gäller för någon cell betyder det att ingen sekvens av rad- och kolumnoperationer kan omvandla en matris till en annan.
Beräkna antalet nödvändiga transformationer:
C++För att beräkna antalet nödvändiga transformationer behöver vi bara titta på första raden och första kolumnen därför att:
- Vi summerar först |a[i][0]| för all i (varje första kolumnelement) eftersom detta representerar hur många radoperationer vi behöver. För varje rad i behöver vi |a[i][0]| operationer för att göra det radelementet noll.
- Sedan summerar vi |a[0][j] - a[0][0]| för alla j (varje första radelement minus första element) eftersom detta representerar ytterligare kolumnoperationer som behövs. Vi subtraherar a[0][0] för att undvika att räkna det två gånger eftersom radoperationer redan har påverkat detta element.
- Summan av dessa två ger oss minsta antal operationer behövs eftersom radoperationer hanterar skillnaderna i första kolumn och kolumnoperationer hanterar de återstående skillnaderna i den första raden.
// 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));
Produktion
3
Tidskomplexitet: O(n*m)
Hjälputrymme: O(1)
strängjämföra i javaSkapa frågesport