2023年秋季学期《算法分析与设计》练习13 OJ-1417 算法分析与设计练习13，使用python、C语言

1的个数

题目描述

输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

输入

 输入一个整数（int类型）。

输出

这个数转换成2进制后，输出1的个数。

样例输入 Copy

5

样例输出 Copy

2

n = int(input())
n = bin(n)
n = list(n)
count = 0
for i in n:
    if i == '1':
        count += 1
print(count)

最小素数对

题目描述

任意一个偶数（大于2）都可以由2个素数组成，组成偶数的2个素数有很多种情况，本题目要求输出组成指定偶数的两个素数差值最小的素数对。

 

输入

输入一个偶数。

输出

输出两个素数。

样例输入 Copy

20

样例输出 Copy

7
13

import math

def s(t):
    i = 2
    while i <= math.sqrt(t):
        if t % i == 0:
            return False
        i += 1
    return True

n = int(input())
t1 = n / 2
t2 = n / 2
i = 0
while i < t1:
    if s(t1) and s(t2):
        print(int(t1 - i))
        print(int(t2 + i))
        break
    t1 -= 1
    t2 += 1

 工作单位

题目描述

在某个城市中住着n个人，现在给定关于这n个人的m条信息（即某2个人认识）。

假设所有认识的人一定属于同一个单位，请计算该城市有多少个单位？

输入

第1行的第1个值表示总人数n，第2个值表示总信息数m；第2行开始为具体的认识关系信息

输出

单位的个数

样例输入 Copy

<span style="background-color:#ffffff"><span style="color:#333333"><span style="color:#333333"><span style="background-color:#f5f5f5">10 4
2 3
4 5
4 8
5 8
</span></span></span></span>

样例输出 Copy

<span style="background-color:#ffffff"><span style="color:#333333"><span style="color:#333333"><span style="background-color:#f5f5f5">7</span></span></span></span>

n, m = map(int, input().split())
a = [0 for i in range(n+1)]
count = 1
for i in range(m):
    j, k = map(int, input().split())
    if a[j] == 0 and a[k] == 0: # 建立一个单位
        a[j] = count
        a[k] = count
        count += 1
    elif a[j] != 0 and a[k] == 0:   # k的单位人数改为j同一个
        a[k] = a[j]
    elif a[k] != 0 and a[j] == 0:   # j的单位人数改为k同一个
        a[j] = a[k]
    elif a[j] != a[k] and a[j] != 0 and a[k] != 0:  # 去掉重复部分
        if a[j] < a[k]:
            for p in range(1, n+1):
                if a[p] == a[k]:
                    a[p] = a[j]
        else:
            for p in range(1, n+1):
                if a[p] == a[j]:
                    a[p] = a[k]
r = 0
for i in range(1, n+1): # 一个人一个单位的单位个数 
    if a[i] == 0:
        r += 1
for i in range(1, count):
    flag = 0
    for j in range(1, n + 1):
        if a[j] == i:
            flag = 1
            break
    if flag == 1:
        r += 1
print(r)

X星人的福利

题目描述

马上就要过年啦！X星球决定给每个人发一份福利，不过这份福利需要排队去X星设置在各个地方的福利发放点领取，福利据说是一个神秘大礼包。
由于每个人在2021年为X星做出的贡献不一样，因此福利包中的礼物也不一样，领取福利所需要的时间也不一样。
现在有N个X星人到达了某一个福利发放点，很遗憾这个福利发放点只有一位工作人员在发放福利包，现在已知每个X星人领取福利包所需要时间（不包括排队等待时间，单位：分钟）。
为了让所有人的平均等待时间最少，需要你设计一个算法来安排领取顺序，请编写程序输出最少平均等待时间（单位：分钟），结果四舍五入保留两位小数。

输入

单组输入，每组输入包含两行。
第1行输入一个正整数N，表示等待领取福利包的X星人的数量（N<=1000）。
第2行输入N个正整数，分别对应N个X星人每人领取福利包所需时间（单位：分钟），每个X星人的领取时间均不会超过100分钟。

输出

输出最少平均等待时间（单位：分钟），结果四舍五入保留两位小数。

样例输入 Copy

4
4 3 1 4

样例输出 Copy

3.25

# while True:
n = int(input())
a = list(map(int, input().split()))
sum = 0
a.sort()
for i in range(0, n - 1):
    sum += a[i] * (n - i - 1)
sum /= n
print('%.2f' % sum)

XP的小视频

题目描述

XP的表哥为他推荐了一些学习计算机编程的小视频，这些视频的播放时间长短不完全相同。现在给定一段时间，你能告诉XP他最多可以看多少个视频吗？每个视频的播放时间和给定的总时间均用分钟为单位。

输入

单组输入数据

第一行为m n

m为给定时间长度（分钟）(0<n,m<=1000)

n表示视频个数

接下来是n个整数代表每个视频的播放时间(每个视频播放时间为不超过1000的正整数)

输出

输出一个整数代表XP最多可以看的视频数。

样例输入 Copy

84 6
65 46 18 76 79 3

样例输出 Copy

3

while True:
    m, n = map(int, input().split())
    a = list(map(int, input().split()))
    a.sort()
    count = 0
    for i in range(n):
        if m >= a[i]:
            count += 1
            m -= a[i]
    print(count)

最小生成树（Prim）

题目描述

使用Prim算法求图的最小生成树(MST)

输入

每组数据分为两个部分，第一部分为图的点数n，和边数m,
第二部分为m行，每一行输入三个数字，前两个为两个顶点的编号，第三个为边权重。

输出

最小生成树，输出时按照边的两个端点的升序输出。（先看左端点，再看右端点，端点不换位置）

样例输入 Copy

3 3
0 1 10
0 2 15
1 2 50

样例输出 Copy

0 1 10
0 2 15

#include<stdio.h>
#include<stdlib.h>

typedef struct {
    int X;
    int Y;
    int V;
} Nod;

typedef struct {
    int X;
    int Y;
    int V;
} Bia;

Nod a[1000];
Bia b[1000];
int n, m;

int cmp(const void *a, const void *b) {
    Nod *nodeA = (Nod *)a;
    Nod *nodeB = (Nod *)b;

    if (nodeA->X == nodeB->X) {
        return nodeA->Y - nodeB->Y;
    }

    return nodeA->X - nodeB->X;
}

void print(int k, int temp) {
    if (temp) {
        printf("%d %d %d\n", a[k].X, a[k].Y, a[k].V);
    } else {
        printf("%d %d %d\n", a[k].Y, a[k].X, a[k].V);
    }
}

void prim() {
    int i, j, k, temp;
    int E1, E2, V;
    int s[n + 1];
    int G[n + 1][n + 1];
    int leng[n + 1];
    int used[n + 1];
    int flag = 0;

    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            G[i][j] = 100000000;
        }
    }

    for (k = 0; k < m; k++) {
        scanf("%d %d %d", &E1, &E2, &V);
        G[E1][E2] = V;
        G[E2][E1] = V;
        b[k].X = E1;
        b[k].Y = E2;
        b[k].V = V;
    }

    for (i = 0; i < n; i++) {
        leng[i] = G[0][i];
        s[i] = 0;
        used[i] = 0;
    }

    used[0] = 1;

    for (i = 1; i < n; i++) {
        j = 0;
        for (k = 0; k < n; k++) {
            if ((used[k] == 0) && leng[k] < leng[j]) {
                j = k;
            }
        }

        a[flag].X = s[j];
        a[flag].Y = j;
        a[flag].V = leng[j];
        flag++;

        used[j] = 1;

        for (int k = 1; k < n; k++) {
            if ((used[k] == 0) && G[j][k] < leng[k]) {
                leng[k] = G[j][k];
                s[k] = j;
            }
        }
    }

    qsort(a, flag, sizeof(Nod), cmp);

    for (k = 0; k < flag; k++) {
        temp = 0;
        for (int i = 0; i < n; i++) {
            if (a[k].X == b[i].X && a[k].Y == b[i].Y) {
                temp = 1;
                break;
            }
        }
        print(k, temp);
    }
}

int main() {
    while (scanf("%d %d", &n, &m) != EOF) {
        prim();
    }
    return 0;
}