Dat două matrice a şi b de mărime n*m . Sarcina este de a găsi necesarul numărul de etape de transformare astfel încât ambele matrici devin egale. Imprimare -1 dacă acest lucru nu este posibil.
The transformare pasul este următorul:
- Selectați orice matrice din două matrice.
- Alegeți fie rând/coloană a matricei selectate.
- Crește fiecare element al selectării rând/coloană de 1.
Exemple:
Intrare:
a[][] = [[1 1]
[1 1]]b[][] = [[1 2]
[3 4]]Ieșire : 3
Explicaţie :
[[1 1] -> [[1 2] -> [[1 2] -> [[1 2]
[1 1]] [1 2]] [2 3]] [3 4]]
Intrare :
a[][] = [[1 1]
[1 0]]b[][] = [[1 2]
[3 4]]Ieșire : -1
Explicaţie : Nicio transformare nu va face a și b egali.
Abordare:
Ideea este că crescând orice rând/coloană în matricea a este echivalent cu decrementând același rând/coloană în matricea b .
Aceasta înseamnă că, în loc să urmărim ambele matrice, putem lucra cu diferența lor (a[i][j] - b[i][j]). Când creștem un rând în ' o' toate elementele din acel rând cresc cu 1, ceea ce este la fel cu toate elementele din acel rând din matricea diferențelor crescând cu 1. În mod similar, când incrementăm o coloană în ' o' este echivalent cu creșterea tuturor elementelor din acea coloană a matricei de diferențe cu 1.
Acest lucru ne permite să transformăm problema în lucrul cu o singură matrice.
Stabiliți dacă există sau nu vreo soluție:
După crearea matricea diferențelor pentru fiecare celulă a[i][j] (excluzând primul rând și prima coloană) verificăm dacă
a[i][j] - a[i][0] - a[0][j] + a[0][0] = 0.
Dacă această ecuație nu este valabilă pentru nicio celulă, putem concluziona imediat că nu există nicio soluție.
ce este o stivă javaDe ce funcționează asta?
Gândește-te cum rând și coloană operaţiile afectează fiecare celulă: când efectuăm x operații pe rând i şi şi operatii pe coloana j a[i][j] se modifică cu (x + y) a[i][0] se modifică cu x (numai operațiuni pe rând) a[0][j] se modifică cu y (numai operațiuni pe coloană) și a[0][0] este afectată de nici rândul i, nici coloana j operațiuni. Prin urmare (x + y) - x - y + 0 = 0 trebuie să țină pentru orice soluție validă. Dacă această ecuație nu este valabilă pentru nicio celulă, înseamnă că nicio secvență de operații pe rând și coloane nu poate transforma o matrice în alta.
Calculați numărul de transformări necesare:
C++Pentru a calcula numărul de transformări necesare, trebuie doar să ne uităm la primul rând şi prima coloană deoarece:
- Mai întâi rezumam |a[i][0]| pentru toate i (fiecare element din prima coloană), deoarece aceasta reprezintă de câte operații pe rând avem nevoie. Pentru fiecare rând i avem nevoie de |a[i][0]| operațiuni pentru ca acel element rând să fie zero.
- Apoi rezumam |a[0][j] - a[0][0]| pentru toate j (fiecare element din primul rând minus primul element), deoarece aceasta reprezintă operațiuni suplimentare necesare pe coloană. Scădem a[0][0] pentru a evita să-l numărăm de două ori, deoarece operațiile pe rând au afectat deja acest element.
- Suma acestor doi ne dă numărul minim de operațiuni necesare deoarece operațiunile pe rând se ocupă de diferențele din prima coloană, iar operațiunile pe coloană se ocupă de diferențele rămase din primul rând.
// 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));
Ieșire
3
Complexitatea timpului: O(n*m)
Spațiu auxiliar: O(1)