2026夏季攀拓甲级游记

2026夏季攀拓甲级游记

先说结论96/100,一等奖

怎么说这份题呢，你说难吧，好像也不是很难，你说简单吧，其实全是英文题，搞你心态，而且考一些很刁钻的考法。

1001

说实话，没看懂这个题要干什么，因为pat的题背景感都很强，给了一个数图的两张图，但是没看出来啥意思，但是从输入输出看出来是给了一个01矩阵，输出每行(每列)的连续的每块1的个数，不要每行行尾的空格。

#include <iostream>
#include <vector>
#include <string>
using namespace std;

void printAns(vector<int>& ans) {
    for (int i = 0; i < ans.size(); i++) {
        if (i > 0) cout << " ";
        cout << ans[i];
    }
    cout << endl;
}

int main() {
    int n;
    cin >> n;

    vector<string> a(n);

    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }

    for (int i = 0; i < n; i++) {
        vector<int> ans;
        int cnt = 0;

        for (int j = 0; j < n; j++) {
            if (a[i][j] == '1') {
                cnt++;
            } else {
                if (cnt > 0) {
                    ans.push_back(cnt);
                    cnt = 0;
                }
            }
        }

        if (cnt > 0) {
            ans.push_back(cnt);
        }

        printAns(ans);
    }

    for (int j = 0; j < n; j++) {
        vector<int> ans;
        int cnt = 0;

        for (int i = 0; i < n; i++) {
            if (a[i][j] == '1') {
                cnt++;
            } else {
                if (cnt > 0) {
                    ans.push_back(cnt);
                    cnt = 0;
                }
            }
        }

        if (cnt > 0) {
            ans.push_back(cnt);
        }

        printAns(ans);
    }

    return 0;
}

说实话，这个英文题看的我真难受.

1002

这个题看懂了，就是让你把一个长难句中的古句子换成现代流行语。考场上不会getline读多行，换的python，但是不知道哪里超时了，痛失四分。细节没注意到。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    cin.ignore(); 

    vector<pair<string, string>> p;

    for (int i = 0; i < n; i++) {
        string first, second;

        getline(cin, first);   // 第一个字符串
        getline(cin, second);  // 第二个字符串

        p.push_back({first, second});
    }

    string s;
    getline(cin, s); // 最后的长句子

    for (int i = 0; i < n; i++) {
        string first = p[i].first;
        string second = p[i].second;

        int pos = 0;

        while ((pos = s.find(second, pos)) != string::npos) {
            s.replace(pos, second.size(), first);
            pos += first.size();
        }
    }

    cout << s << endl;

    return 0;
}

超时代码：

n = int(input())

pairs = []

for _ in range(n):
    first = input()    
    second = input()   
    pairs.append((first, second))

s = input()

for first, second in pairs:
    pos = 0

    while True:
        low_s = s.lower()
        low_second = second.lower()

        idx = low_s.find(low_second, pos)

        if idx == -1:
            break

        s = s[:idx] + first + s[idx + len(second):]

        pos = idx + len(first)
print(s)

1003

这个题怎么说呢，题干很抽象，如果用通俗的话来说就是，给了一堆公司员工关系，让你按照linux下的指令Tree一样打印出来,dfs直接秒好吧。但有个限制就是要按照字典序，同时第ith级别打印ith * 2 个空格。

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

const int N = 1010;

int n;
string name[N];
vector<int> child[N];
void dfs(int u, int level) {
    for (int i = 0; i < level; i++) {
        cout << " ";
    }

    cout << name[u] << endl;

    for (int v : child[u]) {
        dfs(v, level + 1);
    }
}

int main() {
    cin >> n;

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

        child[boss].push_back(i);
    }

    for (int i = 0; i <= n; i++) {
        sort(child[i].begin(), child[i].end(), [](int a, int b) {
            return name[a] < name[b];
        });
    }

    for (int root : child[0]) {
        dfs(root, 0);
    }

    return 0;
}

1004

先说人话:给n , m , l , tu ,tf ,表示一个立方体，1为障碍物，0为通行，2是起点，3是终点，tu是同一个平面内移动一格的速度，tf是上下的速度，问从起点到终点的最短路径。

背景是无人机，如果读英文题，说实话很坐牢了，全是不认识的单词，差点坐牢。

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int z, x, y;
    long long dist;

    bool operator<(const Node& other) const {
        return dist > other.dist; 
    }
};

int main() {
    int n, m, l;
    long long tu, tf;

    cin >> n >> m >> l >> tu >> tf;

    vector<vector<vector<int>>> a(
        n, vector<vector<int>>(m, vector<int>(l))
    );

    int sz = -1, sx = -1, sy = -1;
    int ez = -1, ex = -1, ey = -1;

    for (int z = 0; z < n; z++) {
        for (int x = 0; x < m; x++) {
            for (int y = 0; y < l; y++) {
                cin >> a[z][x][y];

                if (a[z][x][y] == 2) {
                    sz = z;
                    sx = x;
                    sy = y;
                }

                if (a[z][x][y] == 3) {
                    ez = z;
                    ex = x;
                    ey = y;
                }
            }
        }
    }

    const long long INF = 4e18;

    vector<vector<vector<long long>>> dist(
        n, vector<vector<long long>>(m, vector<long long>(l, INF))
    );

    priority_queue<Node> q;

    dist[sz][sx][sy] = 0;
    q.push({sz, sx, sy, 0});

    // 6 个方向
    int dz[6] = {0, 0, 0, 0, 1, -1};
    int dx[6] = {1, -1, 0, 0, 0, 0};
    int dy[6] = {0, 0, 1, -1, 0, 0};

    while (!q.empty()) {
        Node cur = q.top();
        q.pop();

        int z = cur.z;
        int x = cur.x;
        int y = cur.y;

        if (cur.dist != dist[z][x][y]) {
            continue;
        }

        if (z == ez && x == ex && y == ey) {
            break;
        }

        for (int i = 0; i < 6; i++) {
            int nz = z + dz[i];
            int nx = x + dx[i];
            int ny = y + dy[i];

            if (nz < 0 || nz >= n || nx < 0 || nx >= m || ny < 0 || ny >= l) {
                continue;
            }

            if (a[nz][nx][ny] == 1) {
                continue;
            }

            long long w;

            if (i < 4) {
                w = tu;
            } else {
                w = tf;
            }

            if (dist[nz][nx][ny] > dist[z][x][y] + w) {
                dist[nz][nx][ny] = dist[z][x][y] + w;
                q.push({nz, nx, ny, dist[nz][nx][ny]});
            }
        }
    }

    if (dist[ez][ex][ey] == INF) {
        cout << -1 << endl;
    } else {
        cout << dist[ez][ex][ey] << endl;
    }

    return 0;
}

pat甲级的题本身不是很难，但是听陈越姥姥的话还是来考了，考完感觉很水的样子，但确实算是对自己代码能力的一个提升，因为在三个小时，要读一个背景很抽象的英文题还是很累的。绝大部分人学完算法的第一站我都推荐去考一下甲级，题目贴合工业背景，或许这才是为什么能得到各种公司认可的原因吧。