Gangs(附C语言实现)

        一道比较好的并查集题目:Gangs

题目描述

描述

        1920年的芝加哥,出现了一群强盗。如果两个强盗遇上了,那么他们要么是朋友,要么是敌人。
而且有一点是肯定的,就是A的朋友的朋友是A的朋友;A的敌人的敌人也是A的朋友。
两个强盗是同一伙的当且仅当他们是朋友。现在给你一些关于强盗们的信息,问你至多有多少个强盗团伙。

输入

        输入的第一行为N(2<=N<=1000),表示强盗的个数(从1编号到N)。
        第二行M(1<=M<=100000),表示信息条数。
        以下M行,每行可能是F p q或是E p q,分别表示p和q是朋友,或是敌人。
        假设输入不会产生矛盾

输出

        输出只有一行,表示最大可能的团伙数。

样例输入

6
4
E 1 4
F 3 5
F 4 6
E 1 2

样例输出

3

解答

代码

#include <iostream>
using namespace std;
int a[1001] = {0};
int b[1001][1001] = {0};
int father(int n) {
    if (a[n] == -1) {
        return n;
    } else
        return father(a[n]);
}

int hb(int x, int y) {
    int n, m;
    n = father(x);
    m = father(y);
    if (n < m) {
        a[m] = n;
    } else {
        a[n] = m;
    }
    return 0;
}
int main() {
    int n, m;
    int i, j, k;
    char c;
    int x, y, z, p;
    cin >> n >> m;
    for (i = 1; i <= 1001; i++) {
        a[i] = -1;
    }
    for (i = 1; i <= m; i++) {
        cin >> c >> x >> y;
        if (c == 'E') {
            b[y][x] = 1;
            b[x][y] = 1;
        }
        if (c == 'F') {
            hb(x, y);
        }
    }
    for (i = 1; i <= n; i++)
        for (j = 1; j < i; j++) {
            if (b[i][j]) {
                for (k = 1; k <= n; k++) {
                    if (b[j][k] && k < i) {
                        hb(k, i);
                    }
                }
            }
        }
    int s = 0;
    for (i = 1; i <= n; i++) {
        if (a[i] == -1) s++;
    }
    cout << s;
    system("pause");
    return 0;
}

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
OpenACC提供了用于在多个加速器之间分配任务的指令,以实现在多个加速器上并行化计算。下面是一个使用OpenACC实现Floyd算法的多卡优化示例代码: ```c #include <stdio.h> #include <stdlib.h> #include <openacc.h> #define INF 0x3f3f3f3f void floyd(int *d, int n) { int i, j, k; #pragma acc data copy(d[0:n*n]) { for (k = 0; k < n; k++) { #pragma acc parallel loop collapse(2) for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { int ik = d[i * n + k]; int kj = d[k * n + j]; int ij = d[i * n + j]; if (ik + kj < ij) { d[i * n + j] = ik + kj; } } } } } } int main() { int n = 4; int *d = (int*) malloc(n * n * sizeof(int)); int num_devices = acc_get_num_devices(acc_device_nvidia); d[0*n+0] = 0; d[0*n+1] = 2; d[0*n+2] = 6; d[0*n+3] = 4; d[1*n+0] = INF; d[1*n+1] = 0; d[1*n+2] = 3; d[1*n+3] = INF; d[2*n+0] = 7; d[2*n+1] = INF; d[2*n+2] = 0; d[2*n+3] = 1; d[3*n+0] = 5; d[3*n+1] = INF; d[3*n+2] = 12; d[3*n+3] = 0; #pragma acc enter data copyin(d[0:n*n]) #pragma acc parallel loop num_gangs(num_devices) for (int i = 0; i < num_devices; i++) { #pragma acc device_num(i) { int start = (i * n) / num_devices; int end = ((i + 1) * n) / num_devices; int *d_device = d + start * n; int size = (end - start) * n * sizeof(int); #pragma acc enter data create(d_device[0:size]) #pragma acc update device(d_device[0:size]) floyd(d_device, end - start); #pragma acc update host(d_device[0:size]) #pragma acc exit data delete(d_device[0:size]) } } #pragma acc exit data copyout(d[0:n*n]) for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { printf("%d ", d[i * n + j]); } printf("\n"); } free(d); return 0; } ``` 在这个示例中,我们使用了OpenACC的`acc enter data`和`acc exit data`指令,在多个加速器之间分配任务,以实现在多个加速器上并行化计算。我们首先使用`acc enter data`指令将矩阵`d`复制到所有设备上,并使用`copyin`选项将其从主机内存复制到设备内存。然后,我们使用`acc parallel loop`指令在主机上循环所有设备,并使用`num_gangs`选项指定设备的数量。在每个设备上,我们使用`acc device_num`指令来选择设备,并使用`acc enter data`指令创建一个新的设备副本,使用`create`选项来指定数据大小。然后,我们使用`acc update device`指令将设备副本从主机内存复制到设备内存,调用`floyd`函数来计算设备副本中的数据。最后,我们使用`acc update host`指令将设备副本从设备内存复制回主机内存,并使用`acc exit data`指令删除设备副本。在所有设备上完成计算后,我们使用`acc exit data`指令将最终结果从设备内存复制回主机内存,并使用`copyout`选项将其从设备内存复制到主机内存。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值