【算法】【PAT】1051-1060

最新推荐文章于 2024-05-04 22:59:00 发布
最新推荐文章于 2024-05-04 22:59:00 发布
阅读量458 收藏
点赞数
分类专栏： # PAT 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ashe_1994/article/details/116905770
版权

目录

点击前往【PAT甲级之路总纲】

1051 Pop Sequence (25分) 推荐：2星

题目

在这里插入图片描述Sample Input:

5 7 5
1 2 3 4 5 6 7
3 2 1 7 5 6 4
7 6 5 4 3 2 1
5 6 4 3 7 2 1
1 7 6 5 4 3 2

Sample Output:

YES
NO
NO
YES
NO

分析

推荐：2星
两种方法：

  1. 模拟堆栈: vector来保留结果，stack来存序列数
  2. 找规律 ： 计数小于的堆顶的maxcnt， 指向top， 指向tmp，指向cnt

题解

模拟堆栈

#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int main(){
#ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int m, n, k;
    scanf("%d%d%d", &m,&n,&k);
    for (int i = 0; i < k; i++){ ///检查每个序列是否能实现
        bool flag = false;
        stack<int> s; ///栈数据
        vector<int> v(n+1); ///需要匹配的队列
        for(int j = 1; j <= n;j++)
            scanf("%d", &v[j]);///从1开始
        int current = 1;
        for(int j = 1; j <= n; j++){
            s.push(j);
            if(s.size() > m) break; ///爆栈都没有符合
            while(!s.empty() && s.top() == v[current]){ ///匹配值成立
                s.pop();
                current++;
            }
        }
        if(current == n+1) flag = true; ///成功匹配
        if (flag) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

找规律

#include <iostream>
using namespace std;
int main(){
#ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int m, n, k;
    scanf("%d %d %d", &m, &n, &k);
    for(int i = 0; i < k; i++){
        int tmp, cur, top, cnt = 1, flag=1, maxCnt = 0;
        scanf("%d", &top);
        cur = top;
        for(int j = 1; j < n; j++){
            scanf("%d", &tmp);
            if(tmp < top){
                cnt++;
                if(tmp > cur) flag = 0;
            }else{
                top = tmp;
                cnt = 1;
            }
            cur = tmp;
            maxCnt = max(maxCnt, cnt);
        }
        if (maxCnt > m) flag = 0;
        if (flag) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

1052 Linked List Sorting (25分) 推荐：1星

题目

在这里插入图片描述Sample Input:

5 00001
11111 100 -1
00001 0 22222
33333 100000 11111
12345 -1 33333
22222 1000 12345

Sample Output:

5 12345
12345 -1 00001
00001 0 11111
11111 100 22222
22222 1000 33333
33333 100000 -1

分析

推荐：1星
静态链表数组，常考。
要同一条链上，也就是说需要记录是否在一条链上，同时可遍历该链
需要做到，排序和记录

题解

#include <iostream>
#include <algorithm>
using namespace std;
struct NODE{
    int address, key, next;
    bool flag;
}node[100000];
int cmp1(NODE a, NODE b){
    return !a.flag || !b.flag ? a.flag > b.flag : a.key < b.key; /// 将无效的flag放在后面， 然后再进行排序
}
int main(){
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif // ONLINE_JUDGE
    int n, cnt = 0, s, a, b, c;
    scanf("%d%d", &n, &s);
    for(int i = 0; i<n; i++){ ///数据初始化
        scanf("%d%d%d", &a, &b, &c);
        node[a] = {a, b, c, false};
    }
    for(int i = s; i != -1; i = node[i].next){
        node[i].flag = true;
        cnt++;
    }
    if (cnt == 0){
        printf("0 -1");
    }else{
        sort(node, node + 100000, cmp1);
        printf("%d %05d\n", cnt, node[0].address);
        for(int i = 0; i < cnt; i++){
            printf("%05d %d ", node[i].address, node[i].key);
            if(i != cnt - 1)
                printf("%05d\n", node[i+1].address);
            else
                printf("-1\n");
        }
    }
    return 0;
}

1053 Path of Equal Weight (30分) 推荐：经典

题目

在这里插入图片描述在这里插入图片描述Sample Input:

20 9 24
10 2 4 3 5 10 2 18 9 7 2 2 1 3 12 1 8 6 2 2
00 4 01 02 03 04
02 1 05
04 2 06 07
03 3 11 12 13
06 1 09
07 2 08 10
16 1 15
13 3 14 16 17
17 2 18 19

Sample Output:

10 5 2 7
10 4 10
10 3 3 6 2
10 3 3 6 2

分析

推荐：经典
dfs的题，存储权重的方法，可用结构体，也可另存数组

题解

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int target;
struct NODE{
    int w;
    vector<int> child;
};
vector<NODE> v;
vector<int> path;
void dfs(int index, int nodeNum, int sum){  ///当前节点，下一个节点，加上当前节点的综合
    if(sum > target) return; ///边界条件
    if(sum == target){ /// 符合条件，添加路径
        if(v[index].child.size() != 0) return; ///还有子节点，不成立，放回
        for(int i = 0; i < nodeNum; i++) ///
            printf("%d%c", v[path[i]].w, i != nodeNum -1 ? ' ':'\n');
        return ;
    }
    for(int i = 0; i < v[index].child.size(); i++){
        int node = v[index].child[i];
        path[nodeNum] = node;
        dfs(node, nodeNum + 1, sum + v[node].w);
    }
}
int cmp1(int a, int b){
    return v[a].w > v[b].w;
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int n, m, node, k;
    scanf("%d%d%d", &n, &m, &target);
    v.resize(n), path.resize(n);
    for(int i = 0; i < n; i++)
        scanf("%d", &v[i].w);
    for(int i = 0; i < m; i++){
        scanf("%d %d", &node, &k);
        v[node].child.resize(k); ///设置Child尺寸
        for(int j=0; j < k; j++)
            scanf("%d", &v[node].child[j]); ///存储下标
        sort(v[node].child.begin(), v[node].child.end(), cmp1); ///下降排序
    }
    dfs(0, 1, v[0].w); ///多节点深度搜索
    return 0;
}

1054 The Dominant Color (20分)

题目

在这里插入图片描述Sample Input:

5 3
0 0 255 16777215 24
24 24 0 0 24
24 0 24 24 24

Sample Output:

24

题解

#include <iostream>
#include <unordered_map>
using namespace std;
int main(){
#ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int m, n, t;
    unordered_map<int, int> book;
    scanf("%d %d", &m, &n);
    int mid = (m * n)/2;
    for(int i = 0; i < m; i++){
        for(int j = 0; j < n; j++){
            scanf("%d", &t);
            book[t]++;
            if(book[t] > mid){
                printf("%d", t);
                break;
            }
        }
    }
    return 0;
}

1055 The World‘s Richest (25分)

题目

在这里插入图片描述Sample Input:

12 4
Zoe_Bill 35 2333
Bob_Volk 24 5888
Anny_Cin 95 999999
Williams 30 -22
Cindy 76 76000
Alice 18 88888
Joe_Mike 32 3222
Michael 5 300000
Rosemary 40 5888
Dobby 24 5888
Billy 24 5888
Nobody 5 0
4 15 45
4 30 35
4 5 95
1 45 50

Sample Output:

Case #1:
Alice 18 88888
Billy 24 5888
Bob_Volk 24 5888
Dobby 24 5888
Case #2:
Joe_Mike 32 3222
Zoe_Bill 35 2333
Williams 30 -22
Case #3:
Anny_Cin 95 999999
Michael 5 300000
Alice 18 88888
Cindy 76 76000
Case #4:
None

题解

#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
struct node{
    char name[10];
    int age, money;
};
int cmp1(node a, node b){
    if (a.money != b.money)
        return a.money > b.money;
    else if (a.age != b.age)
        return a.age < b.age;
    else
        return (strcmp(a.name, b.name) < 0);
}
int main(){
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif // ONLINE_JUDGE
    int n, k, num, amin, amax;
    scanf("%d %d", &n, &k);
    vector<node> vt(n), v;
    vector<int> book(205, 0);
    for (int i = 0; i < n; i++)
        scanf("%s %d %d", vt[i].name, &vt[i].age, &vt[i].money);
    sort(vt.begin(), vt.end(), cmp1);
    for(int i = 0; i < n; i++){
        if(book[vt[i].age] < 100){
            v.push_back(vt[i]);
            book[vt[i].age]++;
        }
    }
    for(int i = 0; i < k; i++){
        scanf("%d%d%d", &num, &amin, &amax);
        vector<node> t;
        for(int j = 0; j < v.size(); j++){
            if(v[j].age >= amin && v[j].age <= amax)
                t.push_back(v[j]);
        }
        if(i != 0) printf("\n");
        printf("Case #%d:", i+1);
        int flag = 0;
        for (int j = 0; j < num && j < t.size(); j++){
            printf("\n%s %d %d", t[j].name, t[j].age, t[j].money);
            flag = 1;
        }
        if (flag == 0) printf("\nNone");
    }
    return 0;
}

1056 Mice and Rice (25分) 推荐：2星

题目

在这里插入图片描述Sample Input:

11 3
25 18 0 46 37 3 19 22 57 56 10
6 0 8 7 10 5 9 1 4 2 3

Sample Output:

5 5 5 2 5 5 5 3 1 3 5

分析

模拟题
推荐：2星
用数组来记录映射太多，容易混乱,比较适合用结构体

题解

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
struct node{
    int weight, index, rank, index0;
};
bool cmp1(node a, node b){
    return a.index0 < b.index0;
}
int main(){
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif // ONLINE_JUDGE
    int n, g, num;
    scanf("%d%d", &n, &g);
    vector<int> v(n);
    vector<node> w(n);
    for(int i = 0; i < n; i++)
        scanf("%d", &v[i]);
    for (int i = 0; i < n; i++){
        scanf("%d", &num);
        w[i].weight = v[num];
        w[i].index = i; ///比赛序
        w[i].index0 = num; ///在原数组中所处位置
    }
    queue<node> q;
    for (int i = 0; i < n; i++)
        q.push(w[i]);
    while(!q.empty()){
        int size = q.size();
        if (size == 1){ ///只剩一个
            node temp = q.front();
            w[temp.index].rank = 1;
            break;
        }
        int group = size/g; ///比赛小组数
        if(size % g != 0)
            group += 1;
        node maxnode;
        int maxn = -1, cnt = 0; ///每一组最大值，小组内参赛者数
        for (int i = 0; i < size; i++){
            node temp = q.front();
            w[temp.index].rank = group + 1; /// 第一轮失败者的排名
            q.pop();
            cnt++;
            if (temp.weight > maxn){
                maxn = temp.weight;
                maxnode = temp;
            }
            if (cnt == g || i == size - 1){ ///两个终止条件
                cnt = 0;
                maxn = -1;
                q.push(maxnode);
            }
        }
    }
    sort(w.begin(), w.end(), cmp1);
    for(int i = 0; i < n; i++){
        if( i != 0) printf(" ");
        printf("%d", w[i].rank);
    }
    return 0;
}

1057 Stack (30分) 推荐：2星

题目

在这里插入图片描述Sample Input:

17
Pop
PeekMedian
Push 3
PeekMedian
Push 2
PeekMedian
Push 1
PeekMedian
Pop
Pop
Push 5
Push 4
PeekMedian
Pop
Pop
Pop
Pop

Sample Output:

Invalid
Invalid
3
2
2
1
2
4
4
5
3
Invalid

分析

推荐：2星
堆栈模拟，输出中位数(可以用桶排序和树状数组，当前数据用的是桶排序)

题解

#include<iostream>
#include<stack>
#include<cstring>
using namespace std;
const int maxn = 1e5 + 10;
const int sqrtN = 316;
int block[sqrtN], table[maxn];
int n;
stack<int>s;
void Pop()
{
    int x = s.top();
    s.pop();
    table[x]--;
    block[x / sqrtN]--;
    printf("%d\n", x);
}
void Push(int x)
{
    s.push(x);
    table[x]++;
    block[x / sqrtN]++;
}
void PeekMedian(int k) ///核心：找到第k个数
{
    int sum = 0, idx = 0;
    while (sum + block[idx] < k)
        sum += block[idx++];
    int num = sqrtN*idx;
    while (sum + table[num] < k)
        sum += table[num++];
    printf("%d\n", num);
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif // ONLINE_JUDGE
    scanf("%d", &n);
    while (n--)
    {
        char ss[30];
        scanf("%s", ss);
        int num;
        if (ss[1] == 'o')
        {
            if (s.size() == 0)printf("Invalid\n");
            else Pop();
        }
        else if (ss[1] == 'e')
        {
            if (s.size() == 0)printf("Invalid\n");
            else
            {
                int k;
                if (s.size() % 2 == 0)k = s.size() / 2;
                else k = (s.size() + 1) / 2;
                PeekMedian(k);
            }
        }
        else if(ss[1]=='u')
        {
            scanf("%d", &num);
            Push(num);
        }
    }
    return 0;
}

1058 A+B in Hogwarts (20分)

题目

在这里插入图片描述Sample Input:

3.2.1 10.16.27

Sample Output:

14.1.28

分析

涉及进制，则将数转换为最小单位来计算，时间也是如此

题解

#include <iostream>
using namespace std;

int main(){
#ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
#endif // ONLINE_JUDGE
    long long a, b, c, d, e, f;
    scanf("%lld.%lld.%lld %lld.%lld.%lld", &a, &b, &c, &d, &e, &f);
    long long num = c + b*29 + a*29*17 + f + e * 29 + d * 29*17;
    long long g = num / (17*29);
    num = num % (17*29);
    printf("%lld.%lld.%lld", g, num/29, num%29);
    return 0;
}

1059 Prime Factors (25分) 推荐：2星

题目

在这里插入图片描述Sample Input:

97532468

Sample Output:

97532468=2^2*11*17*101*1291

分析

推荐：2星
生成素数表，并输出因子公式。

要点

  • bool primes[10000] 初始化，只能赋值0, 或者false
  • long int 其实就是int
  • int的范围 ： -2147483648 ~ 2147483647
  • 注意： 考虑1的情况
  • 这个的精华在于循环的条件： n >= 2

题解

#include <cstdio>
#include <vector>
using namespace std;
vector<int> prime(500000, 1);
int main(){
    for(int i = 2; i * i < 500000; i++){ ///找素数
        if(prime[i] == 1){
            for(int j = 2; j * i < 500000; j++)
                prime[j*i] = 0;
        }
    }
    #ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
    #endif // ONLINE_JUDGE
    long int a;
    scanf("%ld", &a);
    printf("%ld=", a);
    if (a == 1) printf("1");
    bool state = false;
    for(int i = 2; a >= 2; i++){ ///如果还有值
        int cnt = 0, flag = 0;
        while(prime[i] == 1 &&a % i == 0){
            cnt ++;
            a = a / i;
            flag = 1;
        }
        if (flag){
            if(state) printf("*");
            printf("%d", i);
            state = true;
        }
        if(cnt >= 2)
            printf("^%d", cnt);
    }
    return 0;
}

1060 Are They Equal (25分) 推荐：2星

题目

在这里插入图片描述Sample Input 1:

3 12300 12358.9

Sample Output 1:

YES 0.123*10^5

Sample Input 2:

3 120 128

Sample Output 2:

NO 0.120*10^3 0.128*10^3

分析

推荐：2星
条件分开遍历。
本质上是道模拟题，要想到各种情况，落实到纸面，只要推出公式，就可完成。

题解

#include <cstdio>
#include <cstring>
using namespace std;
int n;
char C[10000], A[10000], B[10000];
int trimStr(char *t, char *d){
    int cnt = strlen(t), q = 0, index = 0;
    for(int i = 0; i < strlen(t); i++){
        if (t[i] == '.'){
            cnt = i;
            break;
        }
    }
    while( t[q] == '0' || t[q] == '.') q++; ///跳掉无效数据
    if(cnt >= q)
        cnt = cnt - q;
    else cnt = cnt - q + 1; ///更新有效数据
    if (q == strlen(t)) cnt = 0; ///特判0
    while(index < n){ ///找到n个有效数， 找不到则填0
        if(t[q] != '.' && q < strlen(t))
            d[index++] = t[q];
        else if (q >= strlen(t))
            d[index++] = '0';
        q++;
    }
    return cnt;
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("data.txt", "r", stdin);
#endif // ONLINE_JUDGE
    scanf("%d %s", &n, C);
    int cnta = trimStr(C, A);
    scanf("%s", C);
    int cntb = trimStr(C, B);
    if(strcmp(A, B) == 0 && cnta == cntb)
        printf("YES 0.%s*10^%d", A, cnta);
    else
        printf("NO 0.%s*10^%d 0.%s*10^%d", A, cnta, B, cntb);
}
AzheCo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法笔记1_算法笔记PAT_算法笔记_
10-01
用于浙大机试和PAT的参考书 C/C++编写
【PAT算法之路】 -- 专栏总揽
qq_40515692的博客
11-25 716
简介 首先是菜鸡自我介绍，刷了一个月PAT算法（之前有一些数据结构基础）， PAT考了97。比起一大波满分的，自然很弱，而且个人运气较好。 详情见：我的大学 ------------ 机械、单片机、电子设计大赛、算法、PAT之旅 写这个专栏的起因是自己最近刷算法，忘记了之前的记住的算法，比如并查集等等算法的写法，于是想记录下。主要是帮助自己复习算法，但是也非常希望能帮到读者。 IDE选择 个人推荐...
关联规则挖掘（Apriori算法和FP-Growth算法）
qq_42370335的博客
07-16 6390
Apriori算法的频繁项集的方式是：先产生低阶频繁项集（从1开始的）的，再由低阶频繁项集产生高阶候选项集，高阶候选项集经过支持度的度量筛选产生，最后生成同阶频繁项集。这是不断重复的“产生-测试”的过程。而FP-growth算法采用是完全不同的方式，算法的第一个核心是压缩数据集，采用的是FP_tree这样的一个数据结构来完全表示了所有的事务，第二个核心是采用了“分而治之”的思想，用递归的方式将挖掘频繁项集一步步分成各自的子问题来解决。对比于Apriori算法，FP-growth算法的特点是只需扫描两次数据库
PAT乙级-1051 复数乘法 (15分)
卷子的博客
03-13 670
点击链接PAT乙级-AC全解汇总 题目： 复数可以写成 (A+Bi) 的常规形式，其中 A 是实部，B 是虚部，i 是虚数单位，满足 i2​​ =−1；也可以写成极坐标下的指数形式 (R×e(Pi)​ )，其中 R 是复数模，P 是辐角，i 是虚数单位，其等价于三角形式 R(cos( P )+isin( P ))。 现给定两个复数的 R 和 P，要求输出两数乘积的常规形式。 输入格式： 输入在一行...
PAT-A- 1037 Magic Coupon 【贪心算法】
热门推荐
gdc6916的博客
05-24 3万+
The magic shop in Mars is offering some magic coupons. Each coupon has an integerNprinted on it, meaning that when you use this coupon with a product, you may getNtimes the value of that product back! What is more, the shop also offers some bonus produ...
字符串匹配算法之Rabin-Karp,KMP算法
vinojie的博客
09-14 998
Rabin-Karp算法 Rabin-Karp算法是由M.O.Rabin和R.A.Karp发明的一种基于散列的字符串查找算法。 Rabin_karp算法的思想是通过将字符串的比较转回成数字的比较。比较两个长度为m的字符串是否相等需要O(m)时间，而比较两个数字是否相等通常可以是O(1)。为了将字符串映射称对应的数字，需要用到哈希函数。 这里存在一个问题就是利用哈希函数将字符串映射成对应的数字有可能发生哈希冲突，也就是说两个字符串通过哈希函数得到数字相等，但是这两个字符不同。Rabin-Karp的解决方法是，
PAT乙级1051题解
YHL的博客
03-06 347
题目详情： 1051 复数乘法 (15 分) 复数可以写成 (A+Bi) 的常规形式，其中 A 是实部，B 是虚部，i 是虚数单位，满足 i ​2 ​​ =−1；也可以写成极坐标下的指数形式 (R×e ​(Pi) ​​ )，其中 R 是复数模，P 是辐角，i 是虚数单位，其等价于三角形式 R(cos§+isin§)。 现给定两个复数的 R 和 P，要求输出两数乘积的常规形式。 输入格式： 输入在一行中依次给出两个复数的 R​1​​ , P​1​​ , R​2 , P​2 ，数字间以空格分隔。 输出格式： 在
2023年春季PAT乙级 B-5
weixin_73664542的博客
03-06 653
2023年春季PAT乙级 B-5
浙大PAT甲级题目1041-1060详细代码解答｜标准答案｜C++语言｜浙软机试
Joe_Morningstar的博客
04-07 457
浙大PAT甲级题目代码详细解答，标准答案，可以代替浙江大学软件学院上机考试，想要保研到浙软的计算机保研学子值得一看！不看后悔！
PAT2017-2019考点分析
0
10-06 339
PAT乙级-【题目+解答】汇总（100%原创/100%完成）
卷子的博客
03-12 3万+
PAT乙级-【题目+解答】汇总 PAT乙级-AC全解汇总 PAT乙级解答集合
【PAT必备】算法笔记-带上机训练宝典
02-27
高清 PDF 资料，PAT 高分备考必看，晴神宝典。算法学习。
浙大PAT算法比赛备考资料
03-05
浙大PAT算法比赛，C++组的备考资料。包括C++语法，算法笔记，刷题带练，以及比赛经验分享。
算法笔记4_pat参考书_算法笔记_
10-01
用于浙大机试和PAT的参考书
算法笔记 pat
08-03
本书是针对各种考研复试上机的同学们，尤其是pat 和ccf,csp，有很重要的学习经验
Golang | Leetcode Golang题解之第67题二进制求和
weixin_66442839的博客
05-04 504
Golang | Leetcode Golang题解之第67题二进制求和
StarryCoding 算法小白周赛2 题解与代码（含视频题解）
最新发布
qq_29495615的博客
05-04 893
因为他会按照“拜访时间安排表”的顺序拜访每一位好友，而无法成功拜访某一好友时，必定是出现靠后拜访的时间早于靠前拜访的，或者两次拜访的时间相同，所以问题的本质就是判断数组是否。），应该删除这个数还是前一个数，因为我们想要的是让后面的数的合法值域更大，所以我们需要最小化留下的那个数，也就是说，如果靠后的数。如果某个数比前一个数小，那么肯定不行，我们需要考虑删去这个元素。如果大于，则最好不要更改，给后面的元素更多的空间。由于数的范围很小，假如这个数合法，我们直接从此数。,能保证加的数量是最少的，并且。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 742
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
c++容器与算法概述
北风
05-01 588
简单讲述输入输出运算符重载 以及容器的简单使用及接口哦苦
pat7-107-10 公路村村通
06-10
解决这个问题的算法有很多，其中一个经典的算法是Kruskal算法。这个算法的基本思想是先将所有的边按照代价从小到大排序，然后依次加入到最小生成树的集合中，如果加入这条边不会形成环路，就将这条边加入最小生成树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值