PAT甲级刷题记录（1161-1167）

最新推荐文章于 2022-12-01 15:46:50 发布
最新推荐文章于 2022-12-01 15:46:50 发布
阅读量269 收藏
点赞数
分类专栏： PAT 文章标签： 深度优先 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45848585/article/details/127186175
版权

1161-1170

1161 Merging Linked Lists(25)

#include<iostream>
#include<stack>
#include<vector>
using namespace std;
const int maxn = 1e5 + 1;
struct node{
    int start, val, next;
}nums[maxn];
vector<node> v;
stack<node> s;

int main(){
    int a1, b1, n;
    cin >> a1 >> b1 >> n;
    for(int i = 0; i <= n; i++){
        int st, va, ne;
        cin >> st >> va >>ne;
        nums[st].start = st;
        nums[st].val = va;
        nums[st].next = ne;
    }
    int len1 = 0;
    int a1_copy = a1;
    while(a1_copy != -1){
        s.push(nums[a1_copy]);
        a1_copy = nums[a1_copy].next;
        len1++;
    }
    //测试点3 n,m给的顺序不定
    if(len1 * 3 > n){
        int temp;
        temp = a1;
        a1 = b1;
        b1 = temp;
        //注意清空stack
        while(!s.empty()){
            s.pop();
        }
        while(a1 != -1){
            s.push(nums[a1]);
            a1 = nums[a1].next;
            len1++;
        }
    }
    int cnt = 0;
    while(b1 != -1){
        printf("%05d %d ", b1, nums[b1].val);
        b1 = nums[b1].next;
        cnt++;
        if(cnt == 2){
            cnt = 0;
            if(!s.empty()){
                node temp = s.top();
                printf("%05d\n%05d %d ", temp.start, temp.start, temp.val);
                s.pop();
            }
        }
        if(b1 != -1){
            printf("%05d\n", nums[b1].start);
        }
    }
    cout << "-1";
}

1162 Postfix Expression(25)

#include<iostream>
using namespace std;
struct node{
    string val;
    node *left, *right, *father;
    node(){
        val = "";
        left = right = father = NULL;
    }
};
node* a[21];
node* findroot(node* n){
    while(n -> father != NULL){
        n = n -> father;
    }
    return n;
}
string dfs(node* root){
    string temp1 = "", temp2 = "", temp = "";
    if(root -> left){
        temp1 = "(" + dfs(root -> left) + ")";
    }
    if(root -> right){
        temp2 = "(" +  dfs(root -> right) + ")";
    }
    
    //开始写错了 以为是负号的特殊性 导致测试点4没过
    //if(root -> val == '-'){
    
    //分别考虑 有右孩子并有左孩子 和 只有右孩子
    if(root -> left && root -> right){
        temp = temp1 + temp2 + root -> val;
    }else{
        temp = root -> val + temp2;
    }
    return temp;
}
int main(){
    int n;
    cin >> n;
    
    for(int i = 1; i <=n ;i++){
        a[i] = new node();
    }
    for(int i = 1; i <= n; i++){
        string va;
        int le, ri;
        cin >> va >> le >> ri;
        a[i] -> val = va;
        if(le != -1){
            a[i] -> left = a[le];
            a[le] -> father = a[i];
        }
        if(ri != -1){
            a[i] -> right = a[ri];
            a[ri] -> father = a[i];
        }
    }
    node* root = findroot(a[1]); 
    string res = dfs(root);
    
    cout << "(" + res + ")";
}

1163 Dijkstra Sequence(30)

// 错 思路太乱了 改不动了
// #include<iostream>
// #include<vector>
// using namespace std;
// const int maxn = 1e3 + 1;
// const int INF = 1e7;
// int adj[maxn][maxn];
// int dis[maxn];
// int nv, ne, k;
// int main(){
//     cin >> nv >> ne;
//     int v1, v2, weight;
//     for(int i = 1; i <= nv; i++){
//         for(int j = 1; j <= nv; j++){
//             adj[i][j] = INF;
//         }
//     }
//     for(int i = 1; i <= ne; i++){
//         cin >> v1 >> v2 >> weight;
//         adj[v1][v2] = adj[v2][v1] = weight;
//     }
//     cin >> k;
//     vector<int> seq;
//     for(int i = 1; i <= k; i++){
//         seq.clear();
//         for(int j = 1; j <= nv; j++){
//             cin >> v1;
//             seq.push_back(v1);
//         }
//         bool visit[nv + 1] = {false};
//         for(int i = 1; i <= nv; i++){
//             dis[i] = INF;
//         }
//         int index = 0;
//         int all_flag = 0;
//         for(int j = 1; j <= nv; j++){
//             visit[seq[index]] = true;
//             int now = seq[index];
//             vector<int> next;
//             int minn = INF;
//             for(int t = 1; t <= nv; t++){
//                 if(dis[t] > adj[now][t]){
//                     dis[t] = adj[now][t];
//                 }
//                 if(minn > dis[t] && visit[t] == false){
//                     minn = dis[t];
//                     next.clear();
//                     next.push_back(t);
//                 }else if(minn == dis[t] && visit[t] == false){
//                     next.push_back(t);
//                 }
//             }
            
//             if(next.empty()){
//                 if(index == nv - 1){
//                     break;
//                 }else{
//                     all_flag = 1;
//                     break;
//                 }
//             }else{
//                 int flag = 0;
//                 index++;
//                 for(int  t = 0; t < next.size(); t++){
//                     if(next[t] == seq[index]){
//                         flag = 1;
//                         break;
//                     }
//                 }
//                 if(flag == 0){
//                     all_flag = 1;
//                     break;
//                 }
//             }
//         }
        
//         if(all_flag == 1){
//             cout << "No\n";
//         }else{
//             cout << "Yes\n";
//         }
//     }
// }

#include<iostream>
#include<vector>
using namespace std;
const int maxn = 1001;
const int INF = 1e9;
int adj[maxn][maxn], dis[maxn];
bool visit[maxn];

int nv, ne ,k, flag;
int start, endd;
void deal(int x, int index, vector<int> seq){
    for(int i = 1; i <= nv; i++){
        int minn = INF, now = seq[index];
        for(int j = 1; j <= nv; j++){
            if(dis[j] != INF && !visit[j] && dis[j] <= minn){
                if(dis[j] < minn){
                    if(j == now){
                        flag = 1;
                    }else{
                        flag =0;
                    }
                }else if(dis[j] == minn){
                    if(j == now){
                        flag = 1;
                    }
                }
                minn = dis[j];
            }
        }
        if(!flag){
            return;
        }
        index++;
        if(index > nv){
            return;
        }
        visit[now] = true;
        for(int j = 1; j <= nv; j++){
            if(!visit[j] && dis[j] > dis[now] + adj[now][j] && adj[now][j] != 0){
                dis[j] = dis[now]  + adj[now][j];
            }
        }
    }
}
int main(){
    cin >> nv >> ne;
    int v1, v2, we;
    for(int i = 0; i < ne; i++){
        cin >> v1 >> v2 >> we;
        adj[v1][v2] = adj[v2][v1] = we;
    }
    cin >> k;
    for(int i = 0 ;i < k; i++){
        vector<int> seq(nv);
        fill(visit, visit + maxn, false);
        fill(dis, dis + maxn, INF);
        for(int j = 0; j < nv; j++){
            cin >> seq[j];
        }
        start = seq[0], endd = seq[nv - 1];
        dis[start] = 0;
        deal(start, 0, seq);
        if(flag){
            cout << "Yes\n";
        }else{
            cout << "No\n";
        }
    }
    return 0;
}

1164 Good in C(20)

#include<iostream>
using namespace std;

string s[27][8];
string sentence;
int main(){
    for(int i = 1; i <= 26; i++){
        for(int j = 1; j <= 7; j++){
            cin >> s[i][j];
        }
    }
    cin.get();//吸收换行符
    getline(cin, sentence);
    //cin >> sentence; 可能存在空格分隔的情况
    int flag = 0;
    string temp = "";
    for(int i = 0; i < sentence.length(); i++){
        if(sentence[i] >= 'A' && sentence[i] <= 'Z'){
            temp += sentence[i];
            
        }else{
            //可能输入的第一个是无效字符
            if(temp == ""){
                continue;
            }
            if(flag != 0){
                cout << endl;
            }
            for(int j = 1; j <= 7; j++){
                for(int k = 0; k < temp.length(); k++){
                    if(k != 0){
                        cout << " ";
                    }
                    int t = temp[k] - 64;
                    cout << s[t][j];
                }
                cout << endl;
            }
            temp = "";
            flag = 1;
        }
    }
    if(sentence[sentence.length() - 1] >= 'A' && sentence[sentence.length() -1] <= 'Z'){
        if(flag != 0){
            cout << endl;
        } 
        for(int j = 1; j <= 7; j++){
                for(int k = 0; k < temp.length(); k++){
                    if(k != 0){
                        cout << " ";
                    }
                    int t = temp[k] - 64;
                    cout << s[t][j];
                }
                cout << endl;
        }
    }
}

1165 Block Reversing(25)

#include<iostream>
#include<stack>
using namespace std;
const int maxn = 1e5 + 1;
struct node{
    int start, val, next;
}nums[maxn];

stack<node> s;
int main(){
    int first, n, k;
    cin >> first >> n >> k;
    for(int i = 0; i < n; i++){
        int st, va, ne;
        cin >> st >> va >> ne;
        nums[st].start = st;
        nums[st].val = va;
        nums[st].next = ne;
    }
    int cnt = 0;
    stack<node> temp;
    while(first != -1){
        temp.push(nums[first]);
        first = nums[first].next;
        cnt++;
        if(cnt == k){
            while(!temp.empty()){
                node tempn = temp.top();
                s.push(tempn);
                temp.pop();
            }
            cnt = 0;
        }
    }
    if(cnt != 0){
        while(!temp.empty()){
            node tempn = temp.top();
            s.push(tempn);
            temp.pop();
        }
    }
    
    while(!s.empty()){
        int st, ne;
        node tempn = s.top();
        st = tempn.start;
        s.pop();
        if(s.empty()){
            ne = -1;
            printf("%05d %d %d\n", st, tempn.val, ne);
        }else{
            ne = s.top().start;
            printf("%05d %d %05d\n", st, tempn.val, ne);
        } 
    }
    return 0;
}

1166 Summit(25)

#include<iostream>
#include<vector>
using namespace std;
const int maxn = 201;
int adj[maxn][maxn] = {0};
int main(){
    int n, m, k;
    cin >> n >> m;
    int u1, u2;
    for(int i = 1; i <= m; i++){
        cin >> u1 >> u2;
        adj[u1][u2] = adj[u2][u1] = 1;
    }
    cin >> k;
    int l;
    for(int i = 1; i <= k; i++){
        cin >> l;
        vector<int> v;
        int temp;
        for(int j = 0; j < l; j++){
            cin >> temp;
            v.push_back(temp);
        }
        int flag = 0;
        for(int j = 0; j < l; j++){
            for(int k = j + 1; k < l; k++){
                if(adj[v[j]][v[k]] == 0){
                    flag = 1;
                    break;
                }
            }
            if(flag == 1){
                break;
            }
        }
        if(flag == 1){
            printf("Area %d needs help.\n", i);
            continue;
        }
        int ans = -1;
        for(int j = 1; j <= n; j++){
            flag = 0;
            for(int k = 0; k < l; k++){
                if(adj[j][v[k]] == 0){
                    flag = 1;
                }
            }
            if(flag == 1){
                continue;
            }else{
                ans = j;
                break;
            }
        }
        if(ans == -1){
            printf("Area %d is OK.\n", i);
        }else{
            printf("Area %d may invite more people, such as %d.\n", i, ans);
        } 
    } 
}

1167 Cartesian Tree(30)

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
const int INF = 1e8 + 1;
vector<int> v;
int n;

struct trnode{
    int val;
    trnode *left, *right;
    trnode(int _val){
        val = _val;
        left = right = NULL;
    }
};
void dfs(int left, int right, trnode* &node){
    if(left > right || right < 0 || left > n - 1){
        return;
    }
    int minn = INF, minn_index = -1;
    for(int i = left; i <= right; i++){
        if(v[i] < minn){
            minn = v[i];
            minn_index = i;
        }
    }
    trnode *temp = new trnode(minn);
    node = temp;
    dfs(left, minn_index - 1, node -> left);
    dfs(minn_index + 1, right, node -> right);
}

int main(){
    cin >> n;
    v.resize(n);
    for(int i = 0; i < n; i++){
        cin >> v[i];
    }
    trnode *root;
    dfs(0, n - 1, root);
    queue<trnode*> q;
    q.push(root);
    int flag = 0;
    while(!q.empty()){
        trnode* temp = q.front();
        if(flag == 0){
            cout << temp -> val;
            flag = 1;
        }else{
            cout << " " << temp -> val;
        }
        if(temp -> left){
            q.push(temp ->left);
        }
        if(temp -> right){
            q.push(temp -> right);
        }
        q.pop();
    }
    return 0;
}
4399彪哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
刷pat和leetcode-PAT-Leetcode:浙大PAT&Leetcode刷题笔记
07-07
刷pat和leetcode 起始 因为最近疯狂种草胶片相机，但想要作为奖励送给自己而不是冲动消费 （一般我会在...第二周丧失热情） 同时又希望在PAT和Leetcode刷题以及玩Human Resource Machine这件事不要三分钟热度。 所以我给自己定了计划:刷完100个Leetcode和浙大PAT乙级题库之后就去收割我的相机！ 做此项目记录刷题笔记及心得，祝我好运。 内容 应该包括 刷Leetcode时我有多蠢（刷题笔记） 看工具书的时候我有多蠢（读书笔记） 刷PAT时我有多蠢（刷题笔记） 刷题提交记录 欢迎 希望有和我一样拖延症和三分钟热度的朋友一起记录打败拖延症走向人生巅峰的process （btw等我工作了再用GitHub一定会觉得这个是黑历史的，但whatever现在的我是在解决自己的问题而不是得过且过啊
PAT 刷题笔记
ikunsaikou的博客
02-05 300
常见专业名词： recursively 递归地 traversal 遍历，横越；横断物 DFS 与 BFS 在DFS中关键点是递归以及回溯，在BFS中，关键点则是状态的选取和标记。 DFS用递归的形式，用到了栈结构，先进后出。（根据题不同注意递归点与回溯点） BFS选取状态用队列的形式+循环，先进先出。 已知中序与前序遍历重建二叉树： 不断拆分节点如下代码是先...
PAT刷题笔记
gengsj
02-21 145
数据范围 B1011，题目给出范围是，int 型的数据范围是，两个 int 型变量相加，最后是可能超过 int 型的，因此需要用 long long 作为变量类型  
【持续更新】【pat】pat刷题笔记
weixin_45855916的博客
11-19 185
修改code completion快捷键位CTRL+ENTER，帮助提示函数名称 修改命令行提示符的属性，开启快速编辑模式，方便调试 添加c++11语言标准支持 开启代码调试功能 对输入的字符串进行切割时，可以使用scanf按照指定格式分别输入达到切割效果，比如： //对于这样的输入 3-10 99 11-5 87 102-1 0 //对于这种格式不绝对统一的字符串，可以自己构造相应的s...
PAT刷题记录
weixin_43587550的博客
08-19 204
之后打算尝试ZJUS的预推免，所以准备开始刷PAT，主要是根据Acwing的课以及《算法笔记》来展开。仅以此篇来记录一下刷题过程。 2021年8月19日 今天看完了Acwing的第一节课字符串，根据讲解的题目，依次自己手动刷一遍，看懂了和会写了还是两码事。 1473. A+ B的格式对应PAT的1001 解题思路： 主要的关键在于加逗号的条件，这里是用间隔4位来实现的，但这就以为这每次加一个逗号，count也需要加1。 具体的内容可以看代码： #include <iostream> #incl
pat甲级单词pat甲级单词pat甲级单词
最新发布
06-12
pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词pat甲级单词...
ACM-PAT甲级题目总结及实现
03-24
PAT分为甲级和乙级两个级别，甲级难度相对较高，更适合有一定基础的选手进行挑战。本文将对PAT甲级题目进行深入的总结，并提供相应的实现思路。 首先，我们要理解ACM竞赛的核心是解决算法问题，这需要扎实的数据...
PAT题库甲级题目1-110题答案代码.rar
04-19
《PAT甲级题库1-110题答案代码解析》 PAT(Portable Algorithm Test)是中国计算机软件技术资格考试中的一个重要部分，旨在考察考生的编程能力与算法理解。本压缩包“PAT题库甲级题目1-110题答案代码.rar”包含了针对...
PAT甲级（1001-1115）题库
09-09
这是PAT甲级第1001到1115的所有原题，只有题目没有答案。
pat刷题笔记1101-1104
qq_44109982的博客
11-04 178
第一次完整做完一套pat题目，没有限时，分数分别为25+25+24+15 上学期刚学的算法，然而现在DFS都不会写了确实是没想到，二叉树相关的基础操作还是挺扎实（感谢数据结构的屈老师） 下面附上这几题的代码和简要思路： 第一题就是求左边的数都比他小，同时右边的数都比他大的数的个数，遍历两次数组即可，时间复杂度O（n），两层循环会超时 #include<bits/stdc++.h> using namespace std; int main() { int n; cin>&g
【PAT刷题甲级】部分笔记1001-1064~（上）
C_greenbird的博客
12-11 942
写在前面 这里C++菜鸟一枚~ 暑假将近两个月刷PAT甲级的笔记在此，虽然最终也没有取得满意的结果，但是不可否认，还是从中学到了很多，是我准备的还不够充分，希望能给刷题的同学们一些帮助。 PS：不是每道题都有，仅仅记录了本人刷过的题中记下的一点心得，分为上下两篇笔记。 常用知识点： 1. 数据类型转换 string 类型转 int 、 long 、 long long 、 float 、 double 、 long double // 头文件 #include <string> ： stoi
2021.9PAT备考刷题笔记（30分题我唯唯诺诺，20分题我重拳出击）
qq_41922663的博客
07-25 159
1001 考察点 字符串的处理 #include<iostream> #include<vector> #include<cmath> #include<string> using namespace std; int main(){ int x, y; cin >> x >> y; string s = to_string(x+y); for(int i = 0; i < s.size();
PAT甲级 1167 Cartesian Tree
邹九的个人博客
10-15 99
浙江大学PAT题目解答内容. Contribute to ZouJiu1/PAT development by creating an account on GitHub.GitHub - ZouJiu1/PAT: 浙江大学PAT题目解答内容。
19年冬季第四题 PAT甲级 1167 Cartesian Tree (30分)
白小飞
11-30 220
7-4 Cartesian Tree (30分) A Cartesian tree is a binary tree constructed from a sequence of distinct numbers. The tree is heap-ordered, and an inorder traversal returns the original sequence. For example, given the sequence { 8, 15, 3, 4, 1, 5, 12, 10, 18, 6
c/c++ 洛谷 P1167 刷题
镭射瓶的博客
07-13 405
题目链接 洛谷 P1167 刷题 不想戳的看下图 输入输出格式及样例： 解题思路： 将其统一为分钟，再用贪心。 废话不多说，代码奉上。 代码如下： #include <iostream> #include <cstdlib> #include <cstdio> #include <cmath> #include <algorithm> #define ll long long using namespace std; long long n,a
「1161」Merging Linked Lists
weixin_52435933的博客
12-01 308
Given two singly linked lists​and​. If, you are supposed to reverse and merge the shorter one into the longer one to obtain a list like​⋯. For example, given one list being 6→7 and the o...
PAT乙级 1023 组个最小数
邹九的个人博客
05-03 282
#include<iostream> #include<string> #include<map> #include<algorithm> #include<bits/stdc++.h> using namespace std; int main(void){ int n; vector<int> vec; for(int i=0; i<10; i++) { cin>&g.
刷题笔记：PAT真题在线练习部分A+B
慢慢积累
04-14 503
题目 题目描述 正整数A的“DA（为1位整数）部分”定义为由A中所有DA组成的新整数PA。例如：给定A = 3862767，DA = 6，则A的“6部分”PA是66，因为A中有2个6。 现给定A、DA、B、DB，请编写程序计算PA + PB。 输入描述: 输入在一行中依次给出A、DA、B、DB，中间以空格分隔，其中0 &lt; A, B &lt; 10^10。 输...
1012. 数字分类 (20)
小羊哈利
11-23 273
1012. 数字分类 (20)给定一系列正整数，请按要求对数字进行分类，并输出以下5个数字： A1 = 能被5整除的数字中所有偶数的和； A2 = 将被5除后余1的数字按给出顺序进行交错求和，即计算n1-n2+n3-n4…； A3 = 被5除后余2的数字的个数； A4 = 被5除后余3的数字的平均数，精确到小数点后1位； A5 = 被5除后余4的数字中最大数字。输入格式：每个输入包含1个测
PAT甲级 1034 Python
07-28
根据提供的引用内容，这是一个关于PAT甲级 1034题的Python代码的讨论。引用\[1\]、\[2\]和\[3\]都是关于这个问题的不同的解答代码。根据引用\[1\]的代码，这个答案是错误的，因为格式不正确。根据引用\[2\]的代码，这个答案也是错误的，因为指数需要按整型格式输出。根据引用\[3\]的代码，这个答案也是错误的，因为有多个错误。所以，根据提供的引用内容，无法得出正确的答案。 #### 引用[.reference_title] - *1* *2* *3* [pat 甲级 1002 python](https://blog.csdn.net/qq_20662425/article/details/120508975)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值