PAT-数据结构与基础算法（AcWingPAT甲级课笔记）

已于 2024-02-04 14:50:48 修改
阅读量232 收藏 5
点赞数 10
文章标签： 算法 c++ 数据结构
于 2024-01-30 00:40:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43975885/article/details/135923807
版权

目录

链表

1032 Sharing

1074 Reversing Linked List

1097 Deduplication on a Linked List

1133 Splitting A Linked List

二路归并

1029 Median

前缀和

1046 Shortest Distance

双指针

1085 Perfect Sequence

1044 Shopping in Mars

BFS

1091 Acute Stroke

枚举

1148 Werewolf - Simple Version

1117 Eddington Number

1040 Longest Symmetric String

栈

1051 Pop Sequence

1055 The World's Richest

1057 Stack

链表

暴力：

先把链表里的数据放入数组，按题目要求对数组进行操作，最后再把数组转化成链表输出

1032 Sharing

解析

1.先建立链表，把输入的数据存下里啊

2.先遍历第一个链表，把链表里的地址都存入到哈希表中

3.再遍历第二个链表，找到一个元素在哈希表中存在过，该地址就是要求的地址

#include <iostream>
#include <cstring>

using namespace std;

const int N = 100010;

int n;
int h1, h2, ne[N];
char e[N];
bool st[N];

int main(){
    scanf("%d%d%d", &h1, &h2, &n);
    for (int i = 0; i < n; i ++ ){
        int address, next;
        char data;
        scanf("%d %c %d", &address, &data, &next);
        e[address] = data, ne[address] = next;
    }

    for (int i = h1; i != -1; i = ne[i])
        st[i] = true;

    for (int i = h2; i != -1; i = ne[i])
        if (st[i]){
            printf("%05d\n", i);
            return 0;
        }

    puts("-1");

    return 0;
}

1074 Reversing Linked List

解析：

1.先把链表存下来，放入vector里

2.对vector做翻转

3.把vector再转成链表

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 100010;

int n, m;
int h, e[N], ne[N];

int main(){
    scanf("%d%d%d", &h, &n, &m);

    for (int i = 0; i < n; i ++ ){
        int address, data, next;
        scanf("%d%d%d", &address, &data, &next);
        e[address] = data, ne[address] = next;
    }

    vector<int> q;
    for (int i = h; i != -1; i = ne[i]) q.push_back(i);

    for (int i = 0; i + m - 1 < q.size(); i += m)
        reverse(q.begin() + i, q.begin() + i + m);

    for (int i = 0; i < q.size(); i ++ ){
        printf("%05d %d ", q[i], e[q[i]]);
        if (i + 1 == q.size()) puts("-1");
        else printf("%05d\n", q[i + 1]);
    }

    return 0;
}

1097 Deduplication on a Linked List

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;

const int N = 100010;

int n;
int h, e[N], ne[N];
bool st[N];

int main(){
    scanf("%d%d", &h, &n);
    for (int i = 0; i < n; i ++ ){
        int address, key, next;
        scanf("%d%d%d", &address, &key, &next);
        e[address] = key, ne[address] = next;
    }

    vector<int> a, b;
    for (int i = h; i != -1; i = ne[i]){
        int v = abs(e[i]);
        if (st[v]) b.push_back(i);
        else{
            st[v] = true;
            a.push_back(i);
        }
    }

    for (int i = 0; i < a.size(); i ++ ){
        printf("%05d %d ", a[i], e[a[i]]);
        if (i + 1 == a.size()) puts("-1");
        else printf("%05d\n", a[i + 1]);
    }
    for (int i = 0; i < b.size(); i ++ ){
        printf("%05d %d ", b[i], e[b[i]]);
        if (i + 1 == b.size()) puts("-1");
        else printf("%05d\n", b[i + 1]);
    }

    return 0;
}

1133 Splitting A Linked List

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;

const int N = 100010;

int n, k;
int h, e[N], ne[N];

int main(){
    scanf("%d%d%d", &h, &n, &k);
    for (int i = 0; i < n; i ++ ){
        int address, key, next;
        scanf("%d%d%d", &address, &key, &next);
        e[address] = key, ne[address] = next;
    }

    vector<int> a, b, c;
    for (int i = h; i != -1; i = ne[i]){
        int v = e[i];
        if (v < 0) a.push_back(i);
        else if (v <= k) b.push_back(i);
        else c.push_back(i);
    }

    a.insert(a.end(), b.begin(), b.end());
    a.insert(a.end(), c.begin(), c.end());

    for (int i = 0; i < a.size(); i ++ ){
        printf("%05d %d ", a[i], e[a[i]]);
        if (i + 1 == a.size()) puts("-1");
        else printf("%05d\n", a[i + 1]);
    }

    return 0;
}

二路归并

1029 Median

#include <iostream>
#include <cstring>

using namespace std;

const int N = 200010;

int n, m;
int a[N], b[N], c[N * 2];

int main(){
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);
    scanf("%d", &m);
    for (int i = 0; i < m; i ++ ) scanf("%d", &b[i]);

    int k = 0, i = 0, j = 0;
    while (i < n && j < m)
        if (a[i] <= b[j]) c[k ++ ] = a[i ++ ];
        else c[k ++ ] = b[j ++ ];
    while (i < n) c[k ++ ] = a[i ++ ];
    while (j < m) c[k ++ ] = b[j ++ ];

    printf("%d\n", c[(n + m - 1) / 2]);

    return 0;
}

前缀和

1046 Shortest Distance

#include <iostream>
#include <cstring>

using namespace std;

const int N = 100010;

int n, m;
int s[N];

int main(){
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ){
        scanf("%d", &s[i]);
        s[i] += s[i - 1];
    }

    scanf("%d", &m);
    while (m -- ){
        int l, r;
        scanf("%d%d", &l, &r);
        if (l > r) swap(l, r);
        printf("%d\n", min(s[r - 1] - s[l - 1], s[n] - s[r - 1] + s[l - 1]));
    }

    return 0;
}

双指针

1085 Perfect Sequence

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 100010;

int n, p;
int a[N];

int main(){
    scanf("%d%d", &n, &p);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

    sort(a, a + n);

    int res = 0;
    for (int i = 0, j = 0; i < n; i ++ ){
        while ((long long)a[j] * p < a[i]) j ++ ;
        res = max(res, i - j + 1);
    }

    printf("%d\n", res);
    return 0;
}


1044 Shopping in Mars

#include <iostream>
#include <cstring>

using namespace std;

const int N = 100010, INF = 1e9;

int n, m;
int s[N];

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ )
    {
        scanf("%d", &s[i]);
        s[i] += s[i - 1];
    }

    int res = INF;
    for (int i = 1, j = 0; i <= n; i ++ )
    {
        while (s[i] - s[j + 1] >= m) j ++ ;
        if (s[i] - s[j] >= m) res = min(res, s[i] - s[j]);
    }

    for (int i = 1, j = 0; i <= n; i ++ )
    {
        while (s[i] - s[j + 1] >= m) j ++ ;
        if (s[i] - s[j] == res) printf("%d-%d\n", j + 1, i);
    }

    return 0;
}

BFS

1091 Acute Stroke

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

const int M = 1286, N = 128, L = 60;

int m, n, l, T;
int g[L][M][N];
struct Node
{
    int x, y, z;
};

int d[][3] = {
    {1, 0, 0},
    {-1, 0, 0},
    {0, 1, 0},
    {0, -1, 0},
    {0, 0, 1},
    {0, 0, -1},
};

int bfs(int x, int y, int z)
{
    queue<Node> q;
    q.push({x, y, z});
    g[x][y][z] = 0;

    int cnt = 1;
    while (q.size())
    {
        auto t = q.front();
        q.pop();

        for (int i = 0; i < 6; i ++ )
        {
            int a = t.x + d[i][0], b = t.y + d[i][1], c = t.z + d[i][2];
            if (a >= 0 && a < l && b >= 0 && b < m && c >= 0 && c < n && g[a][b][c])
            {
                g[a][b][c] = 0;
                q.push({a, b, c});
                cnt ++ ;
            }
        }
    }

    return cnt;
}

int main()
{
    scanf("%d%d%d%d", &m, &n, &l, &T);

    for (int i = 0; i < l; i ++ )
        for (int j = 0; j < m; j ++ )
            for (int k = 0; k < n; k ++ )
                scanf("%d", &g[i][j][k]);

    int res = 0;
    for (int i = 0; i < l; i ++ )
        for (int j = 0; j < m; j ++ )
            for (int k = 0; k < n; k ++ )
                if (g[i][j][k])
                {
                    int t = bfs(i, j, k);
                    if (t >= T) res += t;
                }

    printf("%d\n", res);

    return 0;
}

枚举


1148 Werewolf - Simple Version

#include <iostream>
#include <cstring>

using namespace std;

const int N = 110;

int n;
int q[N];

int judge(int k, int i, int j)  // 如果是假话，返回1；如果是真话，返回0
{
    int t = q[k];
    if (t > 0)
    {
        if (t == i || t == j) return 1;
        return 0;
    }

    t = -t;
    if (t == i || t == j) return 0;
    return 1;
}

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++ ) cin >> q[i];

    for (int i = 1; i <= n; i ++ )
        for (int j = i + 1; j <= n; j ++ )
        {
            int s = judge(i, i, j) + judge(j, i, j);
            if (s != 1) continue;

            s = 0;
            for (int k = 1; k <= n; k ++ )
                s += judge(k, i, j);

            if (s != 2) continue;

            cout << i << ' ' << j << endl;
            return 0;
        }

    puts("No Solution");

    return 0;
}

1117 Eddington Number

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 100010;

int n;
int a[N];

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);
    sort(a, a + n);

    for (int i = n; i; i -- )
        if (a[n - i] > i)
        {
            printf("%d\n", i);
            return 0;
        }

    puts("0");
    return 0;
}

1040 Longest Symmetric String

#include <iostream>
#include <cstring>

using namespace std;

int main()
{
    string str;
    getline(cin, str);

    int res = 0;
    for (int i = 0; i < str.size(); i ++ )
    {
        int l = i - 1, r = i + 1;
        while (l >= 0 && r < str.size() && str[l] == str[r]) l --, r ++ ;
        res = max(res, r - l - 1);

        l = i, r = i + 1;
        while (l >= 0 && r < str.size() && str[l] == str[r]) l --, r ++ ;
        res = max(res, r - l - 1);
    }

    cout << res << endl;

    return 0;
}

栈

1051 Pop Sequence

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

using namespace std;

const int N = 1010;

int m, n, k;
int a[N];

bool check()
{
    stack<int> stk;
    for (int i = 1, j = 0; i <= n; i ++ )
    {
        stk.push(i);
        if (stk.size() > m) return false;

        while (stk.size() && stk.top() == a[j])
        {
            stk.pop();
            j ++ ;
        }
    }

    return stk.empty();
}

int main()
{
    scanf("%d%d%d", &m, &n, &k);
    while (k -- )
    {
        for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);
        if (check()) puts("YES");
        else puts("NO");
    }

    return 0;
}

1055 The World's Richest

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

const int N = 210;

int n, m;
struct Person
{
    string name;
    int age, w;

    bool operator< (const Person& t) const
    {
        if (w != t.w) return w > t.w;
        if (age != t.age) return age < t.age;
        return name < t.name;
    }
};

vector<Person> ages[N];
int idx[N];

int main()
{
    scanf("%d%d", &n, &m);

    char name[10];
    for (int i = 0; i < n; i ++ )
    {
        int age, w;
        scanf("%s%d%d", name, &age, &w);
        ages[age].push_back({name, age, w});
    }

    for (auto& age : ages) sort(age.begin(), age.end());

    for (int C = 1; C <= m; C ++ )
    {
        printf("Case #%d:\n", C);
        int cnt, a, b;
        scanf("%d%d%d", &cnt, &a, &b);

        memset(idx, 0, sizeof idx);
        bool exists = false;
        while (cnt -- )
        {
            int t = -1;
            for (int i = a; i <= b; i ++ )
                if (idx[i] < ages[i].size())
                {
                    if (t == -1 || ages[i][idx[i]] < ages[t][idx[t]])
                        t = i;
                }

            if (t == -1) break;
            auto& p = ages[t][idx[t]];
            idx[t] ++ ;

            printf("%s %d %d\n", p.name.c_str(), p.age, p.w);
            exists = true;
        }

        if (!exists) puts("None");
    }

    return 0;
}

1057 Stack

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

using namespace std;

stack<int> stk;
multiset<int> up, down;

void adjust()
{
    while (up.size() > down.size())
    {
        down.insert(*up.begin());
        up.erase(up.begin());
    }

    while (down.size() > up.size() + 1)
    {
        auto it = down.end();
        it -- ;
        up.insert(*it);
        down.erase(it);
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    char op[20];
    while (n -- )
    {
        scanf("%s", op);
        if (strcmp(op, "Push") == 0)
        {
            int x;
            scanf("%d", &x);
            stk.push(x);
            if (up.empty() || x < *up.begin()) down.insert(x);
            else up.insert(x);
            adjust();
        }
        else if (strcmp(op, "Pop") == 0)
        {
            if (stk.empty()) puts("Invalid");
            else
            {
                int x = stk.top();
                stk.pop();
                printf("%d\n", x);
                auto it = down.end();
                it -- ;
                if (x <= *it) down.erase(down.find(x));
                else up.erase(up.find(x));

                adjust();
            }
        }
        else
        {
            if (stk.empty()) puts("Invalid");
            else
            {
                auto it = down.end();
                it -- ;
                printf("%d\n", *it);
            }
        }
    }

    return 0;
}

我注定这样
关注
  • 10
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【专栏必读】王道考研408数据结构+计算机算法设计与分析万字笔记、题目题型总结、注意事项、目录导航和思维导图
快乐江湖的博客
11-23 4万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
PAT数据结构与算法题目
HZNU_ksco的博客
12-10 503
链表逆序我的写法 struct ListNode *reverse( struct ListNode *head ) { struct ListNode *head1, *tail1, *p, *q; head1 = tail1 = p = q = NULL; for (p = head; p != NULL; p = p->next) { q = (
保研/面试复习-数据结构与算法-万字总结(近三万字)
Airy的博客
09-30 5511
算法复习 1.最短路径 Dijkstra 经典的单源最短路径算法 算法思想 采用了一种贪心的策略。 声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点集合T。 初始时，源点到源点为0，多以dist[s]=0。对于s存在能直接到达的边(s,m)，则dis[m]=w(s,m)，同时吧所有其他的s不能直接到达的点的dis设为正无穷。初始时，集合T中只有顶点s。 然后从dist中选择最小值，则该值就是s到该值对应点的最短路径，并把该点放入集合T中。
PAT甲级数据结构类技术总结
qiiingc的解题记录
03-15 2959
本篇文章专门汇总特别需要注意的数据结构，将说明每种数据结构的引入和具体用法。
数据结构算法题解大全【持续更新】（c++）
热门推荐
weixin_44077556的博客
04-22 2万+
1、二维数组查找 题述 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32M，其他语言64M。 我的思路 该题中二维数组每行从左到右是递增的，每列从上到下是递增的。 起始指针从二维数组末尾...
数据结构 算法 ACM PAT .......zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构与算法ppt课件.ppt
12-21
数据结构与算法ppt课件 本资源是一份数据结构与算法的PPT课件，主要讲解了字符串的概念、抽象数据类型和实现方法。下面是从该资源中提取的知识点： 1. 字符串的概念：字符串是由n个字符组成的有限序列，记作S：...
OnlineJudgeSolutions:数据结构与算法笔记
04-02
基础数据结构 算法整理 介绍 每天是一道OJ ，防止老年痴呆。大概是发现Github是个好东西后有了新鲜感？于是准备陆续的把一些代码放上来，也算是监督自己吧。 当然回到正题，会记录日常的OJ，如果是一类的算法译文，...
算法笔记1_算法笔记PAT_算法笔记_
10-01
《算法笔记1_算法笔记PAT_算法笔记》是一份针对浙江大学计算机科学与技术学院机试以及PAT（Programming Ability Test）考试的学习参考资料，主要以C/C++编程语言为载体，深入讲解了各种算法的设计与实现。这份笔记...
数据结构与算法理论复习
04-12
数据结构与算法理论是计算机科学的核心组成部分，它们是解决问题和设计高效程序的基础。在这个复习资料中，我们将深入探讨几个关键的领域，包括二叉树、森林、图、线性表以及PAT例题，这些都是理解数据结构与算法的...
36. Adam 算法详解
qq_41238579的博客
07-10 945
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 57
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 180
算法014：找到字符串中所有字母异位词
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 59
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
【排序 - 堆排序】
2302_80393814的博客
07-10 461
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 164
【代码】代码随想录算法训练营第33天。
摩尔投票算法
qq_55846232的博客
07-14 159
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 132
手撕七大排序 （三）
【C++】B3716分解质因子3 题解_素数筛法_欧拉筛+埃氏筛_算法竞赛
最新发布
YLCHUP的博客
07-14 290
洛谷B3716题解，一道巧妙的质数筛法变形题，讲解得很详细，适合中等水平学习。快来看ヾ(•ω•`)o

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值