找到具有给定总和的对，使得对的元素在不同的行中

给定一个由不同值组成的矩阵和一个总和。任务是在给定矩阵中找到总和等于给定总和的所有对。一对中的每个元素必须来自不同的行，即；两人不得位于同一排。

例子：

Input : mat[4][4] = {{1, 3, 2, 4},
                     {5, 8, 7, 6},
                     {9, 10, 13, 11},
                     {12, 0, 14, 15}}
        sum = 11
Output: (1, 10), (3, 8), (2, 9), (4, 7), (11, 0) 

方法一（简单）
这个问题的一个简单解决方案是，一个一个地，获取所有行的每个元素，并从矩阵中的下一个直接行开始找到对。这种方法的时间复杂度为 O(n ⁴ )。方法 2（使用排序）内

• 按升序对所有行进行排序。此预处理的时间复杂度为 O(n ² logn)。
• 现在我们将逐行选择每一行，并在当前行之后的剩余行中查找对元素。
• 取两个迭代器， left和right 。左迭代器指向当前第 i 行的左角，右迭代器指向下第 j 行的右角，我们将在其中找到一对元素。
• 如果mat[i][left] + mat[j][right] < sum那么left++即；在第 i 行向右移动，否则向右 ++即；在第 j 行向左角移动。

C++

// C++ program to find a pair with given sum such that
// every element of pair is in different rows.
#include
using namespace std;
 
const int MAX = 100;
 
// Function to find pair for given sum in matrix
// mat[][] --> given matrix
// n --> order of matrix
// sum --> given sum for which we need to find pair
void pairSum(int mat[][MAX], int n, int sum)
{
    // First sort all the rows in ascending order
    for (int i=0; i=0)
            {
                if ((mat[i][left] + mat[j][right]) == sum)
                {
                    cout << "(" << mat[i][left]
                         << ", "<< mat[j][right] << "), ";
                    left++;
                    right--;
                }
                else
                {
                    if ((mat[i][left] + mat[j][right]) < sum)
                        left++;
                    else
                        right--;
                }
            }
        }
    }
}
 
// Driver program to run the case
int main()
{
    int n = 4, sum = 11;
    int mat[][MAX] = {{1, 3, 2, 4},
                      {5, 8, 7, 6},
                      {9, 10, 13, 11},
                      {12, 0, 14, 15}};
    pairSum(mat, n, sum);
    return 0;
}

Java

// Java program to find a pair with
// given sum such that every element
// of pair is in different rows.
import java.util.Arrays;
class GFG {
static final int MAX = 100;
 
// Function to find pair for given sum in
// matrix mat[][] --> given matrix
// n --> order of matrix
// sum --> given sum for which we need to find pair
static void pairSum(int mat[][], int n, int sum) {
     
    // First sort all the rows in ascending order
    for (int i = 0; i < n; i++)
    Arrays.sort(mat[i]);
 
    // Select i'th row and find pair for element in i'th
    // row in j'th row whose summation is equal to given sum
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            int left = 0, right = n - 1;
            while (left < n && right >= 0) {
                if ((mat[i][left] + mat[j][right]) == sum) {
                System.out.print("(" + mat[i][left] + ", " +
                                     mat[j][right] + "), ");
                left++;
                right--;
                }
                else {
                    if ((mat[i][left] + mat[j][right]) < sum)
                        left++;
                    else
                        right--;
                }
            }
        }
    }
}
 
// Driver code
public static void main(String[] args) {
    int n = 4, sum = 11;
    int mat[]
        [] = {{1 ,  3,  2,  4},
              {5 ,  8,  7,  6},
              {9 , 10, 13, 11},
              {12,  0, 14, 15}};
    pairSum(mat, n, sum);
}
}
// This code is contributed by Anant Agarwal.

Python 3

# Python 3 program to find a pair with
# given sum such that every element of
# pair is in different rows.
MAX = 100
 
# Function to find pair for given
# sum in matrix mat[][] --> given matrix
# n --> order of matrix
# sum --> given sum for which we
# need to find pair
def pairSum(mat, n, sum):
 
    # First sort all the rows
    # in ascending order
    for i in range(n):
        mat[i].sort()
 
    # Select i'th row and find pair for
    # element in i'th row in j'th row
    # whose summation is equal to given sum
    for i in range(n - 1):
        for j in range(i + 1, n):
            left = 0
            right = n - 1
            while (left < n and right >= 0):
                if ((mat[i][left] + mat[j][right]) == sum):
                    print( "(", mat[i][left],
                           ", ", mat[j][right], "), ",
                                            end = " ")
                    left += 1
                    right -= 1
                 
                else:
                    if ((mat[i][left] +
                         mat[j][right]) < sum):
                        left += 1
                    else:
                        right -= 1
 
# Driver Code
if __name__ == "__main__":
    n = 4
    sum = 11
    mat = [[1, 3, 2, 4],
           [5, 8, 7, 6],
           [9, 10, 13, 11],
           [12, 0, 14, 15]]
    pairSum(mat, n, sum)
 
# This code is contributed
# by ChitraNayal

Javascript

 
// Javascript program to find a pair with
// given sum such that every element
// of pair is in different rows.
 
let MAX = 100;
  
// Function to find pair for given sum in
// matrix mat[][] --> given matrix
// n --> order of matrix
// sum --> given sum for which we need to find pair
function pairSum(mat, n, sum) {
      
    // First sort all the rows in ascending order
    for (let i = 0; i < n; i++)
        mat[i].sort((a, b) => a - b);
  
    // Select i'th row and find pair for element in i'th
    // row in j'th row whose summation is equal to given sum
    for (let i = 0; i < n - 1; i++) {
        for (let j = i + 1; j < n; j++) {
            let left = 0, right = n - 1;
            while (left < n && right >= 0) {
                if ((mat[i][left] + mat[j][right]) == sum) {
                    document.write("(" + mat[i][left] + ", " +
                                     mat[j][right] + "), ");
                    left++;
                        right--;
                }
                else {
                    if ((mat[i][left] + mat[j][right]) < sum)
                        left++;
                    else
                        right--;
                }
            }
        }
    }
}
 
// Driver program
 
    let n = 4, sum = 11;
    let mat = [[1 ,  3,  2,  4],
              [5 ,  8,  7,  6],
              [9 , 10, 13, 11],
              [12,  0, 14, 15]];
               
    pairSum(mat, n, sum);
   

输出：

(1, 10), (3, 8), (2, 9), (4, 7), (11, 0)

时间复杂度： O(n ² logn + n^3)
辅助空间： O(1)

方法三（散列）

1. 创建一个空的哈希表并将矩阵的所有元素作为键存储在哈希中，并将它们的位置作为值存储。
2. 再次遍历矩阵以检查每个元素是否存在于哈希表中。如果存在，则比较行号。如果行号不相同，则打印该对。

CPP

// C++ program to find pairs with given sum such
// the two elements of pairs are from different rows
#include
using namespace std;
 
const int MAX = 100;
 
// Function to find pair for given sum in matrix
// mat[][] --> given matrix
// n --> order of matrix
// sum --> given sum for which we need to find pair
void pairSum(int mat[][MAX], int n, int sum)
{
    // Create a hash and store all elements of matrix
    // as keys, and row and column numbers as values
    unordered_map > hm;
    for (int i=0; i p = it->second;
                int row = p.first, col = p.second;
 
                // If row number of pair is not same as current
                // row, then print it as part of result.
                // Second condition is there to make sure that a
                // pair is printed only once. 
                if (row != i && row > i)
                   cout << "(" << mat[i][j] << ", "
                        << mat[row][col] << "), ";
            }
        }
    }
}
 
// Driver program
int main()
{
    int n = 4, sum = 11;
    int mat[][MAX]= {{1, 3, 2, 4},
                     {5, 8, 7, 6},
                     {9, 10, 13, 11},
                     {12, 0, 14, 15}};
    pairSum(mat, n, sum);
    return 0;
}

Java

// Java program to find pairs with given sum such
// the two elements of pairs are from different rows
import java.io.*;
import java.util.*;
class GFG
{
 
  static int MAX = 100;
 
  // Function to find pair for given sum in matrix
  // mat[][] --> given matrix
  // n --> order of matrix
  // sum --> given sum for which we need to find pair
  static void pairSum(int mat[][], int n, int sum)
  {
 
    // Create a hash and store all elements of matrix
    // as keys, and row and column numbers as values
    Map> hm = new HashMap>();
    for (int i = 0; i < n; i++)
    {
      for (int j = 0; j < n; j++)
      {
        hm.put(mat[i][j], new ArrayList(Arrays.asList(i, j)) );
      }
 
    }
 
    // Traverse the matrix again to check for every
    // element whether its pair exists or not.
    for (int i = 0; i < n; i++)
    {
      for (int j = 0; j < n; j++)
      {
 
        // Look for remaining sum in hash
        int remSum = sum - mat[i][j];
 
        // If an element with value equal to remaining sum exists
        if(hm.containsKey(remSum))
        {
 
          // Find row and column numbers of element with
          // value equal to remaining sum.
          ArrayList p = hm.get(remSum);
          int row = p.get(0), col = p.get(1);
 
          // If row number of pair is not same as current
          // row, then print it as part of result.
          // Second condition is there to make sure that a 
          // pair is printed only once.  
          if (row != i && row > i)
          {
            System.out.print("(" + mat[i][j] + "," + mat[row][col] + "), ");
          }
        }
      }
    }
  }
 
  // Driver code
  public static void main (String[] args) {
    int n = 4, sum = 11;
    int[][] mat = {{1, 3, 2, 4},
                   {5, 8, 7, 6},
                   {9, 10, 13, 11},
                   {12, 0, 14, 15}};
    pairSum(mat, n, sum);
  }
}
 
// This code is contributed by avanitrachhadiya2155

蟒蛇3

# JavaScript program to find pairs with given sum such
# the two elements of pairs are from different rows
MAX = 100
 
# Function to find pair for given sum in matrix
  # mat[][] --> given matrix
  # n --> order of matrix
  # sum --> given sum for which we need to find pair
def pairSum(mat, n, sum):
     
    # Create a hash and store all elements of matrix
    # as keys, and row and column numbers as values
    hm = {}
     
    for i in range(n):
        for j in range(n):
            hm[mat[i][j]] = [i, j]
     
    # Traverse the matrix again to check for every
    # element whether its pair exists or not.
    for i in range(n):
        for j in range(n):
           
            # Look for remaining sum in hash
            remSum = sum - mat[i][j]
             
            # If an element with value equal to remaining sum exists
            if remSum in hm:
               
                # Find row and column numbers of element with
                # value equal to remaining sum.
                p=hm[remSum]
                row = p[0]
                col = p[1]
                 
                # If row number of pair is not same as current
                # row, then print it as part of result.
                # Second condition is there to make sure that a
                # pair is printed only once.
                if (row != i and row > i):
                    print("(" , mat[i][j] , "," , mat[row][col] , "), ", end="")
                     
# Driver code
n = 4
sum = 11
mat = [[1, 3, 2, 4],
                   [5, 8, 7, 6],
                   [9, 10, 13, 11],
                   [12, 0, 14, 15]]
pairSum(mat, n, sum)
 
# This code is contributed by patel2127

C＃

// C# program to find pairs with given sum such
// the two elements of pairs are from different rows
using System;
using System.Collections.Generic;
public class GFG
{   
 
  // Function to find pair for given sum in matrix
  // mat[][] --> given matrix
  // n --> order of matrix
  // sum --> given sum for which we need to find pair
  static void pairSum(int[,] mat, int n, int sum)
  {
 
    // Create a hash and store all elements of matrix
    // as keys, and row and column numbers as values
    Dictionary> hm = new Dictionary>();
    for (int i = 0; i < n; i++)
    {
      for (int j = 0; j < n; j++)
      {
        hm.Add(mat[i,j],new List(){i,j});
      }
    }
 
    // Traverse the matrix again to check for every
    // element whether its pair exists or not.
    for (int i = 0; i < n; i++)
    {
      for (int j = 0; j < n; j++)
      {
 
        // Look for remaining sum in hash
        int remSum = sum - mat[i,j];
 
        // If an element with value equal to remaining sum exists
        if(hm.ContainsKey(remSum))
        {
 
          // Find row and column numbers of element with
          // value equal to remaining sum.
          List p = hm[remSum];
          int row = p[0], col = p[1];
 
          // If row number of pair is not same as current
          // row, then print it as part of result.
          // Second condition is there to make sure that a 
          // pair is printed only once.  
          if (row != i && row > i)
          {
            Console.Write("(" + mat[i, j] + "," + mat[row, col] + "), ");
          }
        }
      }
    }
  }
 
  // Driver code
  static public void Main (){
    int n = 4, sum = 11;
    int[,] mat = {{1, 3, 2, 4},
                  {5, 8, 7, 6},
                  {9, 10, 13, 11},
                  {12, 0, 14, 15}};
    pairSum(mat, n, sum);
  }
}
 
// This code is contributed by rag2127

Javascript

 
// JavaScript program to find pairs with given sum such
// the two elements of pairs are from different rows
 
let MAX = 100;
 
// Function to find pair for given sum in matrix
  // mat[][] --> given matrix
  // n --> order of matrix
  // sum --> given sum for which we need to find pair
function pairSum(mat,n,sum)
{
    // Create a hash and store all elements of matrix
    // as keys, and row and column numbers as values
    let hm = new Map();
    for (let i = 0; i < n; i++)
    {
      for (let j = 0; j < n; j++)
      {
        hm.set(mat[i][j], [i, j] );
      }
  
    }
  
    // Traverse the matrix again to check for every
    // element whether its pair exists or not.
    for (let i = 0; i < n; i++)
    {
      for (let j = 0; j < n; j++)
      {
  
        // Look for remaining sum in hash
        let remSum = sum - mat[i][j];
  
        // If an element with value equal to remaining sum exists
        if(hm.has(remSum))
        {
  
          // Find row and column numbers of element with
          // value equal to remaining sum.
          let p = hm.get(remSum);
          let row = p[0], col = p[1];
  
          // If row number of pair is not same as current
          // row, then print it as part of result.
          // Second condition is there to make sure that a
          // pair is printed only once. 
          if (row != i && row > i)
          {
            document.write("(" + mat[i][j] + "," +
            mat[row][col] + "), ");
          }
        }
      }
    }
}
 
// Driver code
let n = 4, sum = 11;
let mat = [[1, 3, 2, 4],
                   [5, 8, 7, 6],
                   [9, 10, 13, 11],
                   [12, 0, 14, 15]];
    pairSum(mat, n, sum);
 
 
 
// This code is contributed by ab2127
 

输出：

(1, 10), (3, 8), (2, 9), (4, 7), (11, 0), 

一件重要的事情是，当我们遍历一个矩阵时，一对可能会被打印两次。为了确保一对只打印一次，我们检查从哈希表中选取的其他元素的行号是否大于当前元素的行号。
时间复杂度： O(n ² )，假设哈希表插入和搜索操作花费 O(1) 时间。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。