寻找来自不同国家的宇航员

给定一个表示宇航员数量的正整数 N （从(N – 1) 中标记为 0 ）和一个矩阵mat[][]包含来自同一国家的宇航员对，任务是计算方式的数量选择两名来自不同国家的宇航员。

例子：

Input: N = 6, mat[][] = {{0, 1}, {0, 2}, {2, 5}}
Output: 9
Explanation:
Astronauts with ID {0, 1, 2, 5} belong to first country, astronaut with ID {3} belongs to second country and astronaut with ID {4} belongs to third country. The number of ways to choose two astronauts from different countries is:

1. Choose 1 astronaut from country 1 and 1 astronaut from country 2, then the total number of ways is 4*1 = 4.
2. Choose 1 astronaut from country 1 and 1 astronaut from country 3, then the total number of ways is 4*1 = 4.
3. Choose 1 astronaut from country 2 and 1 astronaut from country 3, then the total number of ways is 1*1 = 1.

Therefore, the total number of ways is 4 + 4 + 1 = 9. 

Input: N = 5, mat[][] = {{0, 1}, {2, 3}, {0, 4}}
Output: 6

方法：给定的问题可以通过将这个问题建模为一个图来解决，其中宇航员代表图的顶点，给定的对代表图中的边。构建该图后，其想法是计算从不同国家选择 2 名宇航员的方法数。请按照以下步骤解决问题：

• 创建一个列表列表， adj[][]来存储图的邻接列表。
• 使用变量i遍历给定数组arr[]并将arr[i][1]附加到adj[arr[i][0]]并将arr[i][0]附加到adj[arr[i][1] ]]为无向边。
• 现在，使用本文中讨论的方法，通过执行深度优先搜索来查找图的每个连通分量的大小，并将所有连通分量的大小存储在一个数组中，例如v[] 。
• 初始化一个整数变量，比如ans作为从 N名宇航员中选择 2 名宇航员的方法总数，即 N*(N – 1)/2 。
• 遍历数组v[]并从变量ans 中减去 v[i]*(v[i] – 1)/2以排除每个连接组件之间的所有可能对。
• 完成以上步骤后，打印ans的值作为结果。

下面是上述方法的实现：

C++

// C++ program for the above approach
  
#include 
using namespace std;
  
// Function to perform the DFS Traversal
// to find the count of connected
// components
void dfs(int v, vector >& adj,
         vector& visited, int& num)
{
    // Marking vertex visited
    visited[v] = true;
    num++;
  
    // DFS call to neighbour vertices
    for (int i = 0; i < adj[v].size(); i++) {
  
        // If the current node is not
        // visited, then recursively
        // call DFS
        if (!visited[adj[v][i]]) {
            dfs(adj[v][i], adj,
                visited, num);
        }
    }
}
  
// Function to find the number of ways
// to choose two astronauts from the
// different countries
void numberOfPairs(
    int N, vector > arr)
{
    // Stores the Adjacency list
    vector > adj(N);
  
    // Constructing the graph
    for (vector& i : arr) {
        adj[i[0]].push_back(i[1]);
        adj[i[1]].push_back(i[0]);
    }
  
    // Stores the visited vertices
    vector visited(N);
  
    // Stores the size of every
    // connected components
    vector v;
  
    int num = 0;
    for (int i = 0; i < N; i++) {
  
        if (!visited[i]) {
  
            // DFS call to the graph
            dfs(i, adj, visited, num);
  
            // Store size of every
            // connected component
            v.push_back(num);
            num = 0;
        }
    }
  
    // Stores the total number of
    // ways to count the pairs
    int ans = N * (N - 1) / 2;
  
    // Traverse the array
    for (int i : v) {
        ans -= (i * (i - 1) / 2);
    }
  
    // Print the value of ans
    cout << ans;
}
  
// Driver Code
int main()
{
    int N = 6;
    vector > arr = { { 0, 1 }, { 0, 2 }, { 2, 5 } };
    numberOfPairs(N, arr);
  
    return 0;
}

输出：

9

时间复杂度： O(N + E)，其中 N 是顶点数，E 是边数。
辅助空间： O(N + E)

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