PTA 图专题总结(二)(各种相关的图算法)

最新推荐文章于 2021-12-27 14:09:24 发布
最新推荐文章于 2021-12-27 14:09:24 发布
阅读量371 收藏 2
点赞数
分类专栏： PTA分类整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44101169/article/details/109634245
版权

7-8 哈利·波特的考试(floyed)

https://pintia.cn/problem-sets/15/problems/716

输入样例:

6 11
3 4 70
1 2 1
5 4 50
2 6 50
5 6 60
1 3 70
4 6 60
3 6 80
5 1 100
2 4 60
5 2 80

输出样例:

4 70

// 经典多源最短路径算法
// 求ｋ次最小生成树选择一个最小的或者floyed算法floyed
//　神奇的五行短代码

#include <iostream>
using namespace std;
#define N 105
#define INF  9999999

int main() {
    int n, m;
    cin >> n >> m;
    int map[N][N];
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            if(i == j)
                map[i][j] = 0;		//初始化一定要对不能全部为INF
            else
                map[i][j] = INF;
    while(m--) {
        int a, b, c;
        cin >> a >> b >> c;
        map[a][b] = map[b][a] = c;
    }
    
    // floyed算法本质上是通过尝试插值松弛来看看是不是存在一个绕路的点是得这个点到别的点的距离更大或者更小.
    //所以最后得到的结果是一个每个点关于其他点的距离的最值
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                if(map[i][j] > map[i][k] + map[k][j])
                    map[i][j] = map[i][k] + map[k][j];
    
    int min = INF;
    int index = 0;
    for(int i = 1; i <= n; i++) {
        int max = 0;
        for(int j = 1; j <= n; j++)
            if(max < map[i][j])
                max = map[i][j];
        if(min > max) {
            min = max;
            index = i;
        }
    }
    if(index == 0)
        cout << 0 << endl;
    else
        cout << index << " " << min << endl;
    return 0;
}

// 经典多源最短路径问题,方便起见还是floyed算法较为简单实现也更加具有针对性.但是我不太明白为什么他的初始化不能全部都是INF。至于Prim,Krustal,最小生成树，Dijkstra算法还是等到更加具有针对性的情况下使用.

7-9 旅游规划(Dijkstra)

https://pintia.cn/problem-sets/15/problems/717

输入样例:	4 5 0 3 
	   	0 1 1 20 
	   	1 3 2 30
	   	0 3 4 10 
	   	0 2 2 20 
	   	2 3 1 20 
输出样例:	3 40

#include <iostream>
#include <cstring>
using namespace std;

#define N 505
#define INF 1000

int main() {
    int n, m, s, d;
    cin >> n >> m >> s >> d;
    int map[N][N][2];
    int visited[N];
    memset(visited, 0, sizeof(visited));
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            if(i == j)
                map[i][j][0] = map[i][j][1] = 0;
            else 
                map[i][j][0] = map[i][j][1] = INF;
    
    while(m--) {
        int a, b, c, e;
        cin >> a >> b >> c >> e;
        map[a][b][0] = map[b][a][0] = c;
        map[a][b][1] = map[b][a][1] = e;
    }
    
    visited[s] = 1;
    // 本质上Dijkstra是一种生成最小生成树的走法，所以最多只要走n-1次就一定能得到结果
    for(int i = 0; i < n; i++) {
        int min = INF;
        int k = -1;
        for(int j = 0; j < n; j++)
            if(!visited[j] && min > map[s][j][0]) {
                k = j;
                min = map[s][j][0];
            }
         // 退出机制
        if(k == -1)
            break;
        else
            visited[k] = 1;
        
        for(int j = 0; j < n; j++) {
			// 有些博主的代码中还会有map[s][j][0] < INF的情况
			// 这里因为我们取的INF比较少，因此不用担心INF相加整型溢出所以不需要加
            if(!visited[j])// 松弛操作
                if(map[s][j][0] > map[s][k][0] + map[k][j][0] ||
                  (map[s][j][0] == map[s][k][0] + map[k][j][0] && map[s][j][1] > map[s][k][1] + map[k][j][1])){
                    map[s][j][0] = map[s][k][0] + map[k][j][0];
                    map[s][j][1] = map[s][k][1] + map[k][j][1];
                }
        }
    }
    
    cout << map[s][d][0] << " " << map[s][d][1] << endl;
    return 0;
}

// 经典单源最短路径,也是最短生成树的一种

7-10 公路村村通 (Krustal + 并查集)

https://pintia.cn/problem-sets/15/problems/718

输入样例:

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

输出样例:

12

// 利用并查集判断所给的建设计划是否能够使得所有村落相连通
// 同时因为已经建立了并查集的数据结构，因此可以直接利用Krustal算法
#include <iostream>
#include <cstring>
#include <queue>

using namespace std;
#define N 1005
#define INF 99999
int pre[N];

struct edge {
    int u, v;
    int cost;
    friend bool operator < (edge e1, edge e2) {
        return e1.cost > e2.cost;
    }
}Edge;

int find(int x) {
    if(x != pre[x])
        return pre[x] = find(pre[x]);
    return x;
}

void Union(int x, int y) {
    int a = find(x);
    int b = find(y);
    if(a != b)
        pre[a] = b;
}

int main() {
    int n, m;
    cin >> n >> m;
    priority_queue<edge> q;
    
    for(int i = 1; i <= m; i++) {
        cin >> Edge.u >> Edge.v >> Edge.cost;
        q.push(Edge);
    }
    
    for(int i = 1; i <= n; i++)
        pre[i] = i;
    
    int sum = 0;
    int cnt = 0;
    while(m--) {
        edge l = q.top();
        q.pop();
        if(find(l.u) != find(l.v)) {
            Union(l.u, l.v);
            sum += l.cost;
            cnt++;
        }
        if(cnt == n-1)
            break;
    }
    if(cnt != n-1)
        cout << "-1" << endl;
    else
        cout << sum << endl;
    
    return 0;
}

7-35 城市间紧急救援(Dijstra)

https://pintia.cn/problem-sets/15/problems/862

输入样例:

4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2

输出样例:

2 60
0 1 3

#include <iostream>
#include <stack>
#include <cstring>

using namespace std;
#define N 505
#define INF 9999
int flag = 0;
int pre[N];
stack<int> Stack;

void DFS(int s) {
    if(s == -1)
        return;
    Stack.push(s);
    DFS(pre[s]);
}

int main() {
    int n, m, s, d;
    cin >> n >> m >> s >> d;
    int map[N][N];
    int peo[N];
    int sum[N];
    int way[N];
    int visited[N] = {0};
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            if(i == j)
                map[i][j] = 0;
            else
                map[i][j] = INF;
    for(int i = 0; i < n; i++) {
        cin >> peo[i];
        sum[i] = peo[i];
        way[i] = 1;				// memset函数的问题
        pre[i] = -1;			// pre[i]的初始化问题
    }
    
    while(m--) {
        int a, b, c;
        cin >> a >> b >> c;
        map[a][b] = map[b][a] = c;
    }
    
    // Dijkstra
    visited[s] = 1;
    for(int i = 0; i < n-1; i++) {
        int min = INF;
        int k = -1;					// k的退出机制
        for(int j = 0; j < n; j++)
            if(!visited[j] && min > map[s][j]) {
                min = map[s][j];
                k = j;
            }
        if(k == -1)
            break;
        else
            visited[k] = 1;
        
        for(int j = 0; j < n; j++) {
            if(!visited[j]) {
                if(map[s][j] > map[s][k] + map[k][j]) {
                    map[s][j] = map[s][k] + map[k][j];
                    sum[j] = sum[k] + peo[j];
                    way[j] = way[k];
                    pre[j] = k;
                } else if(map[s][j] == map[s][k] + map[k][j]){
                    way[j] += way[k];
                    if(sum[j] < sum[k] + peo[j]) {
                        sum[j] = sum[k] + peo[j];
                        pre[j] = k;
                    }
                }
            }
        }
    }
    DFS(d);					// DFS段错误
    Stack.push(s);
    cout << way[d] << " " << sum[d] + peo[s] << endl;
    while(!Stack.empty()) {
        int l = Stack.top();
        Stack.pop();
        if(flag++)
            cout << " ";
        cout << l;
    }
   
    return 0;
}

// 终于完美的解决了这道题，第一遍做的时候各种找资料博客去看，有的博主的答案还是错的导致自己debug到怀疑人生。现在来总结一下这道题的坑点，有一说一题还是不错的，但是这道题的测试点是有问题的，他的给的默认的起点是0,导致一些不正确的code也是能够通过测试的。
１．关于pre[i]的初始化问题:

void DFS(int s, int v) {
    if(s == v) {
        cout << s;
        return;
    }
    DFS(s, pre[v]);                 // 为什么pre不能初始化
    cout << " " << v;
}

如果采用如上的方式去遍历每个前驱结点,按照代码的逻辑，我们会发现直到起点之前的那个节点是没有头结点的而我最一开始的初始化是

for(int i = 0; i < n; i++)
	pre[i] = i;

然而

visited[s] = 1;
    for(int i = 0; i < n-1; i++) {
        int min = INF;
        int k = -1;
        for(int j = 0; j < n; j++)
            if(!visited[j] && min > map[s][j]) {
                min = map[s][j];
                k = j;
            }
        if(k == -1)
            break;
        else
            visited[k] = 1;

在这里面我们并没有设置第一个距离起点最短的节点的前驱节点，这就会导致进入DFS遍历的时候，pre[k] == k,陷入死循环，造成段错误.而后我在大佬的提示下去掉了初始化，发现就AC了，但是这个问第二个节点没有前驱节点的问题并没有解决。所以只有可能是测试点所给的起点默认均为０才会造成的情况.
2.关于memset函数的问题
之前看其他blog中好多人用就瞎跟着用了，后来准备讲一个数组全赋值为1时就出了问题，后来还是在某大佬的提示下发现这个函数竟然只能够给数组赋值0和-1，这是错误之二。
3.关于k的退出机制问题

visited[s] = 1;
    for(int i = 0; i < n-1; i++) {
        int min = INF;
        int k = -1;
        for(int j = 0; j < n; j++)
            if(!visited[j] && min > map[s][j]) {
                min = map[s][j];
                k = j;
            }
        if(k == -1)
            break;
        else
            visited[k] = 1;

在这段代码中有无这个k的退出机制是没有关系的，但是当 i < n或者更大的数是，假设我们把所有的点都访问完了,如果只是int k;然后进入下面的操作，此时k变量存储位置中的数字是电脑中的一个不知道是什么的数，很容易造成数组的访问越界，所以当初这个地方的段错误也有是因为这个的原因.
4.这道题的关于queue方法找路径和Dijkstra算法本身的理解
第二遍做的时候一直想要试一试不用前驱结点来尝试这找到他的路径,然后就尝试使用了queue,然后插入在

for(int j = 0; j < n; j++)
            if(!visited[j] && min > map[s][j]) {
                min = map[s][j];
                k = j;
            }
        if(k == -1)
            break;
        else
            visited[k] = 1;
            q.push(k);

后来发现测试集的结果是吧所有的节点都输出来了，当时非常不能理解,后来又去重新学习了一下Dijkstra算法，发现这个算法是通过对每个点进行松弛操作来得到最短路径的，所以最后整个循环之后一定会把所有的节点全部压入queue中，所以并不能在松弛的过程中同时看queue的压入顺序来寻找路径，而现在暂时想不出比pre[i]更好的解决方案.算是对这个算法本身细节的理解更加深刻了一些。

7-50 畅通工程之局部最小花费问题(Krustal + 并查集 / Prime)

https://pintia.cn/problem-sets/15/problems/897

输入样例:

4
1 2 1 1
1 3 4 0
1 4 1 1
2 3 3 0
2 4 2 1
3 4 5 0

输出样例:

3

#include <iostream>
#include <queue>

using namespace std;
#define N 105
int pre[N];
struct edge {
    int u, v;
    int cost;
    friend bool operator < (edge a, edge b) {
        return a.cost > b.cost;
    }
}Edge;

int find(int x) {
    if(x != pre[x])
        return pre[x] = find(pre[x]);
    return x;
}

void Union(int x, int y) {
    int a = find(x);
    int b = find(y);
    if(a != b)
        pre[a] = b;
}

int main() {
    int n; 
    cin >> n;
    int len = n*(n-1)/2;
    priority_queue<edge> q;
    
    for(int i = 1; i <= n; i++)
        pre[i] = i;
    
    while(len--) {
        int a, b, c, d;
        cin >> a >> b >> c >> d;
        if(d == 1)
           Union(a, b);
        else {
            Edge.u = a;
            Edge.v = b;
            Edge.cost = c;
            q.push(Edge);
        }
    }
    int sum = 0;
    while(!q.empty()) {
        edge l = q.top();
        q.pop();
        if(find(l.v) != find(l.u)) {
            Union(l.u, l.v);
            sum += l.cost;
        }
    }
    cout << sum << endl;
}

// 采用优先队列简化程序
法二（Prim）

// Prime算法
#include <iostream>
#define INF 9999
#define N 105
using namespace std;

int main() {
    int n;
    cin >> n;
    int map[N][N];
    int visited[N] = {0};
    int len = n*(n-1)/2;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            if(i != j)
                map[i][j] = INF;
            else
                map[i][j] = 0;
    
    while(len--) {
        int a, b, c, d;
        cin >> a >> b >> c >> d;
        if(d == 1)
            map[a][b] = map[b][a] = 0;
        else
            map[a][b] = map[b][a] = c;
    }
    
    visited[1] = 1;
    int sum = 0;
    for(int i = 0; i < n-1; i++) {
        int min = INF;
        int k = -1;
        for(int j = 1; j <= n; j++)
            if(!visited[j] && min > map[1][j]) {
                min = map[1][j];
                k = j;
            }
        
        if(k == -1)
            break;
        else
            visited[k] = 1;
        sum += map[1][k];
        
        for(int j = 1; j <= n; j++)
            if(!visited[j] && map[1][j] > map[k][j])
                map[1][j] = map[k][j];
    }
    
    cout << sum << endl;
    return 0;
}

// 这中解法的重点在于

 for(int j = 1; j <= n; j++)
            if(!visited[j] && map[1][j] > map[k][j])
                map[1][j] = map[k][j];

可能是我Dijkstra写太多了在第二遍做的时候也写成了松弛，其实如果要让代码更加清楚一些应该再重新开一个dist[]数组来表示与已访问点相连接的最短边，每次找到最短的那个，加入sum,本质上也是求一个最短生成树.整理了一下果然清晰很多.

那行界
关注
专栏目录
PTA 图
abyss_miracle的博客
03-29 732
图分为有向图（路径单项）和无向图（路径双向）。 一。存储 1.矩阵存储（要注意无向图时矩阵对称，写入值的时候别漏了）。 /* 图的邻接矩阵表示法 */ #define MaxVertexNum 100 /* 最大顶点数设为100 */ #define INFINITY 65535 /* ∞设为双字节无符号整数的最大值65535*/ typedef int Vertex; ...
PTA【图着色问题】Java
─━ _ ─━✧
10-15 788
图着色问题是一个著名的NP完全问题。给定无向图G=(V,E)，问可否用K种颜色为V中的每一个顶点分配一种颜色，使得不会有两个相邻顶点具有同一种颜色？ 但本题并不是要你解决这个着色问题，而是对给定的一种颜色分配，请你判断这是否是图着色问题的一个解。 输入格式： 输入在第一行给出3个整数V（0<V≤500）、E（≥0）和K（0<K≤V），分别是无向图的顶点数、边数、以及颜色数。顶点和颜色都从1到V编号。随后E行，每行给出一条边的两个端点的编号。在图的信息给出之后，给出了一个正整数N（≤20），是待.
PTA 图专题总结(一)（BFS+DFS）
qq_44101169的博客
11-14 348
7.6 列出连通集（BFS + DFS） 给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。 输入格式: 输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。 输出格式: 按照"{ v​1​​ v​2​​ … v​k​​ }"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。
PTA 第四章算法题汇总
billlee7942的博客
04-08 2824
嗨，同学，要成为粉丝才可见奥，关注我把哈哈哈哈或，奥利给　～ 7-1生成3的乘方表(15分) 输入一个非负整数n，生成一张3的乘方表，输出3​0​​~3​n​​的值。可调用幂函数计算3的乘方。 n=int(input()) for i in range(0,n+1): print("pow(3,%d) = %d"%(i,3**i)) 7-2统计素数并求和(20分) 本...
PTA第二章算法题汇总
billlee7942的博客
03-26 4387
7-2计算分段函数[1](10分) 本题目要求计算下列分段函数f(x)的值： x=float(input()) if abs(x) < 10e-10: y=0 else: y=1/x print("f({0:.1f}) = {1:.1f}".format(x,y)) 7-3阶梯电价(15分) 为了提倡居民节约用电，某省电力公司执行“阶梯电价”，安装一户一表...
PTA-数据结构与算法题目集.zip
12-28
PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 ...
PTA习题：数据结构与算法题目集1
08-08
数据结构与算法是计算机科学的基础，它涉及到如何高效地存储和处理数据，以及设计和分析解决问题的方法。在这些题目中，我们将探讨三个不同主题：单链表逆转、最大子列和问题，以及树的同构。 首先，让我们看单链表...
PTA：改写二分搜索算法
weixin_43554584的博客
09-21 2325
改写二分搜索算法。返回小于x的最大元素位置和大于x的最小元素位置。
PTA数据结构与算法题目集部分题解，补充blog创建前的题解.zip
最新发布
12-28
PTA数据结构与算法题目集部分题解，补充blog创建前的题解 PTA数据结构与算法题目集部分题解，补充blog创建前的题解 PTA数据结构与算法题目集部分题解，补充blog创建前的题解 PTA数据结构与算法题目集部分题解，补充...
递归-PTA改写二分搜索算法
haha_7的博客
11-21 815
题目来源：《计算机算法设计与分析》，王晓东 设a[0:n-1]是已排好序的数组，请改写二分搜索算法，使得当x不在数组中时，返回小于x的最大元素位置i和大于x的最小元素位置j。当搜索元素在数组中时，i和j相同，均为x在数组中的位置。 输入格式: 输入有两行： 第一行是n值和x值； 第二行是n个不相同的整数组成的非降序序列，每个整数之间以空格分隔。 输出格式: 输出小于x的最大元素的最大下标i和大于x的最小元素的最小下标j。当搜索元素在数组中时，i和j相同。 提示：若x小于全部数值，则输出：-1 0 若x大于全
数据结构PTA实验五图的应用&实验六内部排序
weixin_58323835的博客
12-27 296
【7-1列出连通度】 给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。 输入格式: 输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。 输出格式: 按照"{v1​v2​...vk​}"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。 输入样例: ...
PTA：图的理论习题集
teletubbies的博客
07-30 3574
1.3无向连通图至少有一个顶点的度为1。(1分)(F) 1.2无向连通图边数一定大于顶点个数减1(F) ==1-4用邻接表法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。(1分) ...
6-26 图的广度遍历-邻接矩阵实现 (10分)
qq_37618760的博客
02-08 3691
本题要求实现邻接矩阵存储图的广度优先遍历。 函数接口定义： void BFS(MGraph G,Vertex i); 其中MGraph是邻接矩阵存储的图，定义如下： #define MaxVertexNum 10 /*定义最大顶点数*/ typedef int Vertex;/* 用顶点下标表示顶点,为整型 */ typedef struct{ int arcs[MaxV...
数据结构pta图作业
Stella218的博客
11-20 4666
选择判断知识点 无向连通图所有顶点的度之和为偶数。无向连通图：任何两个结点之间是连通的，都存在一条路径，且图中无方向。性质：①无向连通图所有顶点的度之和为边数*2。②边数等于顶点个数。 无向连通图边数一定大于顶点个数减1。(F) 三个顶点，两条边。 用邻接表法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。(F) 解析：设结点数为n，边数m，空间复杂度O(n+m)。如图，节点个数为V0~V5,边数用箭头表示，故只要两个节点之间有边相连，就会分配存储空间。 用邻接矩阵法存储图，占.
pta l2-7（家庭房产）
weixin_34007291的博客
03-16 337
题目链接：https://pintia.cn/problem-sets/994805046380707840/problems/994805068539215872 题意：给定n个人的信息，包括其编号，父母以及孩子的编号，以及其名下的房产数量和房产面积，要求有多少个家族，并列出每个家族的最小编号，家庭人数，家庭人均房产数量和人均房产面积。 思路：算法部分就是简单的并查集，但数据处理等方面还挺复...
图的基本操作：建立图，DFS，BFS-06-图1 列出连通集
bobo1356的博客
05-17 579
图的遍历方式一般有两种：DFS，BFS 题目 06-图1 列出连通集 (25分) 分析 这里考察的是图的基本操作：建立一个图，深度优先遍历（DFS）和广度优先遍历（BFS）。 由于这儿N很小，我就直接用邻接矩阵（二维数组）来存储图。 DFS利用递归，BFS利用队列。 我的代码 #include<iostream> #include<cstring> #include<queue> usi
【PTA】【数据结构与算法】图的基本概念
热门推荐
葑鈊丶
05-17 1万+
这里是从PTA平台整理的【图的基本概念】题目集
【PTA】7-14 喊山 (图bfs)
Skyed_blue的博客
11-04 1812
7-14 喊山 (30 分) 喊山，是人双手围在嘴边成喇叭状，对着远方高山发出“喂—喂喂—喂喂喂……”的呼唤。呼唤声通过空气的传递，回荡于深谷之间，传送到人们耳中，发出约定俗成的“讯号”，达到声讯传递交流的目的。原来它是彝族先民用来求援呼救的“讯号”，慢慢地人们在生活实践中发现了它的实用价值，便把它作为一种交流工具世代传袭使用。（图文摘自：http://news.xrxxw.com/newssho...
pta 一笔画
weixin_51638679的博客
11-24 4792
小丁最近迷恋上一个游戏，传说中的“一笔画”游戏。 那么什么是一笔画？如下图，顾名思义就是一笔可以完成的图。一笔画最基本的要求是在画图的过程中，笔不能离开纸，且笔所画过的线不能重复，最后画完所有的线便算完成。 虽然小丁喜欢玩这个游戏，但有时候花费半天也找不到答案。小丁听说写一个计算机程序便能判断是否可以一笔画图，所以他希望善良可爱的你来帮帮他的忙。 快来帮帮弱小，可怜，又无助的小丁。 输入格式: 给出图中的节点数N（1<=N<=1000,编号1-N）和边数M；随后M行给出存在边的两个
PTA编程练习答案：函数与算法实现
在编程学习过程中，PTA（Programming Training Arena）是一个常用的在线实践平台，提供各种编程题目供用户练习。以下是一些PTA中的函数答案，涵盖了C/C++语言的基础编程概念： 1. **三-32程序阅读**：此题考察的是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值