GPLT PAT 编程练习

GPLT && PAT 编程练习

L1-064 估值一亿的AI核心代码 (20 分)
- 通过这题学到了string的几个字符串处理的函数
L1-058 6翻了 (15 分)
L1-059 敲笨钟 (20 分)
L2-032 彩虹瓶 (25 分)
L2-031 深入虎穴 (25 分)
7-10 公路村村通 (最小生成树）

L1-064 估值一亿的AI核心代码 (20 分)

规则是：

无论用户说什么，首先把对方说的话在一行中原样打印出来；
消除原文中多余空格：把相邻单词间的多个空格换成 1 个空格，把行首尾的空格全部删掉，把标点符号前面的空格删掉；
把原文中所有大写英文字母变成小写，除了 I；
把原文中所有独立的 can you、could you 对应地换成 I can、I could—— 这里“独立”是指被空格或标点符号分隔开的单词；
把原文中所有独立的 I 和 me 换成 you；
把原文中所有的问号 ? 换成惊叹号 !；
在一行中输出替换后的句子作为 AI 的回答。
输入格式：
输入首先在第一行给出不超过 10 的正整数 N，随后 N 行，每行给出一句不超过 1000 个字符的、以回车结尾的用户的对话，对话为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。

输出格式：
按题面要求输出，每个 AI 的回答前要加上 AI: 和一个空格。

输入样例：

6
Hello ?Good to chat   with you
can   you speak Chinese?
Really?
Could you show me 5
What Is this prime? I,don 't know

输出样例：

Hello ?
AI: hello!Good to chat   with you
AI: good to chat with you
can   you speak Chinese?
AI: I can speak chinese!
Really?
AI: really!
Could you show me 5
AI: I could show you 5
What Is this prime? I,don 't know
AI: what Is this prime! you,don't know

参考大佬的解题思路与博客：https://blog.csdn.net/qq1013459920/article/details/88997856

通过这题学到了string的几个字符串处理的函数

substr(index,n) 得到index开始，长度为n的子串
erase(index,n) 删除index开始的num个字符
insert(index,ch) 在index处插入字符ch
replace(index,n,str2) 用str2字符串替换index开始的n个字符
isalnum(char ch) 判断字符ch是否为字母或数字，是返回1，否返回0
isalpha(char ch) 判断字符ch是否为英文字符，是返回1，否返回0
isdigit(char ch) 判断字符ch是否为十进制数字字符，是返回1，否返回0

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<map>
#include<climits>
using namespace std;
string str;//对话为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。
// judge函数 主要判断该子串的位置，防止越界等。
bool judge(int pos, int dis, int len){if(pos - 1 >= 0 && pos + dis < len) //如果该特殊子串在字符串的之间, 避免出现 merry 以及 ame这种错误的转换，可以是I,或!I这种return !isalnum(str[pos - 1]) && !isalnum(str[pos + dis]);else if(pos - 1 >= 0) //如果该特殊子串在字符串的末尾return !isalnum(str[pos - 1]);else if(pos + dis < len) //如果该特殊子串在字符串的开头return !isalnum(str[pos + dis]);return true;
}
int main(){int n;cin >> n;// 千万注意getline之前，因为有cin输入，留有了回车，则需要getchar吸收。// 但getline() 之间不需要getchar(),getline不读取缓冲区回车，丢弃最后一个换行符。getchar(); int len;while(n--){getline(cin, str);cout << str <<endl; // !注意，题目要求还要再输出一次原输入 这里容易漏掉。cout << "AI: ";len = str.size();//1.把行首尾的空格全部删掉。int  i = 0;while(len > 1 && str[0] ==' '){str.erase(0, 1);len --;}i = len - 1;while(len > 0 && str[i] == ' '){str.erase(i, 1);i --;len --;}len = str.size();//2.把相邻单词间的多个空格换成 1 个空格, 把标点符号前面的空格删掉。for(i = 0; i < len; i++){while(str[i] ==' '){//很重要的知识点：isalnum(char ch)  判断字符ch是否为字母或数字，是返回1，否返回0if(i + 1 < len && !isalnum(str[i + 1] )){//这里不能直接判断是空格，因为是标点符号的话，空格也需要去掉str.erase(i, 1);len --;}else{break;}}}len = str.size();// 3. 把原文中所有大写英文字母变成小写，除了 I,把原文中所有的问号 ? 换成惊叹号 !// 注意 这里有个细节，他要求是所有的字母，而不是独立的字母。与下面一条规则不同。for( i = 0; i < len; i++){if(str[i] != 'I' && str[i] >= 'A' && str[i] <= 'Z') //转小写str[i] += 32;else if (str[i] == '?') str[i] = '!';}//4.   把所有字符转小写了，再判断里面的me,can you等单词，而且这里要重点理解“独立”2字，因此不仅仅是简单的判断 需要利用到judge函数。len = str.size();for(int i = 0; i < len; i++){if(i < len && str[i] == 'I' && judge(i, 1, len))str.replace(i, 1, "you");if(i + 1 < len && str.substr(i, 2) == "me" && judge(i, 2, len))str.replace(i, 2, "you");if(i + 6 < len && str.substr(i, 7) =="can you" && judge(i, 7, len))str.replace(i, 7, "I can");if(i + 8 < len && str.substr(i, 9) =="could you" && judge(i, 9, len))str.replace(i, 9, "I could");//！ 这句话特别重要，也是我一直无法AC的地方， 因为前者判断 以及 题设给出的样例 都只有一种单词变化的情况，如果是I，me这几种一起出现，使得新的len变大的话，就会无法遍历全部的字符。len = str.size(); }  cout << str <<endl;}}

L1-058 6翻了 (15 分)

“666”是一种网络用语，大概是表示某人很厉害、我们很佩服的意思。最近又衍生出另一个数字“9”，意思是“6翻了”，实在太厉害的意思。如果你以为这就是厉害的最高境界，那就错啦 —— 目前的最高境界是数字“27”，因为这是 3 个 “9”！

本题就请你编写程序，将那些过时的、只会用一连串“6666……6”表达仰慕的句子，翻译成最新的高级表达。

输入格式：
输入在一行中给出一句话，即一个非空字符串，由不超过 1000 个英文字母、数字和空格组成，以回车结束。

输出格式：
从左到右扫描输入的句子：如果句子中有超过 3 个连续的 6，则将这串连续的 6 替换成 9；但如果有超过 9 个连续的 6，则将这串连续的 6 替换成 27。其他内容不受影响，原样输出。

输入样例：

it is so 666 really 6666 what else can I say 6666666666

输出样例：

it is so 666 really 9 what else can I say 27

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;int main(){string s;getline(cin, s);int i = 0;int cnt = 0;for(int i = 0; i < s.size(); i++){if(s[i] == '6')cnt++;else{if(cnt > 9)cout << "27";else if(cnt > 3)cout << "9";else{while(cnt != 0){cout << "6";cnt --;}}cnt = 0;cout << s[i];}}if(cnt > 9)cout << "27";else if(cnt > 3)cout << "9";else{while(cnt != 0){cout << "6";cnt --;}}cnt = 0;}

L1-059 敲笨钟 (20 分)

微博上有个自称“大笨钟V”的家伙，每天敲钟催促码农们爱惜身体早点睡觉。为了增加敲钟的趣味性，还会糟改几句古诗词。其糟改的方法为：去网上搜寻压“ong”韵的古诗词，把句尾的三个字换成“敲笨钟”。例如唐代诗人李贺有名句曰：“寻章摘句老雕虫，晓月当帘挂玉弓”，其中“虫”（chong）和“弓”（gong）都压了“ong”韵。于是这句诗就被糟改为“寻章摘句老雕虫，晓月当帘敲笨钟”。

现在给你一大堆古诗词句，要求你写个程序自动将压“ong”韵的句子糟改成“敲笨钟”。

输入格式：
输入首先在第一行给出一个不超过 20 的正整数 N。随后 N 行，每行用汉语拼音给出一句古诗词，分上下两半句，用逗号 , 分隔，句号 . 结尾。相邻两字的拼音之间用一个空格分隔。题目保证每个字的拼音不超过 6 个字符，每行字符的总长度不超过 100，并且下半句诗至少有 3 个字。

输出格式：
对每一行诗句，判断其是否压“ong”韵。即上下两句末尾的字都是“ong”结尾。如果是压此韵的，就按题面方法糟改之后输出，输出格式同输入；否则输出 Skipped，即跳过此句。

xun zhang zhai ju lao diao chong, xiao yue dang lian gua yu gong.
tian sheng wo cai bi you yong, qian jin san jin huan fu lai.
xue zhui rou zhi leng wei rong, an xiao chen jing shu wei long.
zuo ye xing chen zuo ye feng, hua lou xi pan gui tang dong.
ren xian gui hua luo, ye jing chun shan kong.

输出样例：

xun zhang zhai ju lao diao chong, xiao yue dang lian qiao ben zhong.
Skipped
xue zhui rou zhi leng wei rong, an xiao chen jing qiao ben zhong.
Skipped
Skipped

输入样例：

#include<iostream>
#include<string>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include <vector>using namespace std;int main(){int n;cin >> n;getchar();while(n--){string s;getline(cin, s);int dh, jh;string c1, c2;for(int i = 0; i < s.size(); i++){if(s[i] == ','){dh = i;if(i - 3  >= 0)c1 = s.substr(i - 3, 3);}else if(s[i] == '.'){jh = i;c2 = s.substr(i - 3, 3);}}if(c2 =="ong" && c1 == "ong"){int cnt = 0;int flag = 0;for(int  i = s.size() - 1; s[i] != ','; i--){if(s[i] ==' ')cnt++;if(cnt == 3){flag = i;cout<< s.substr(0, i + 1);cout<< "qiao ben zhong." << endl;break;}}}else{cout << "Skipped" << endl;}}
}

L2-032 彩虹瓶 (25 分)

知识点：栈的使用。
需要理清题目的逻辑，输入一个num，先判断能不能放，能则放上去，并且此时去看临时货物能不能放上来（这里题目暗示了是一个循环，也就是，直到临时货物上的不能在正常按顺序放后，终止），不能：则先判断临时货物剩余空间，如果还有位置，则放到新的货物上。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cstring>
#include<string>
#include<cmath>
using namespace std;int main(){int n, m, k, num;cin >> n >> m >> k;while(k--){stack<int> st;vector<int> v(n + 1);int res = 0; //最后正确存放的结果数int cnt = 1; //存放时候的计数结果int flag = 0;  // 错误标记for(int i = 1; i <= n; i++){cin >> v[i];if(v[i] == cnt){cnt ++;res ++; while(!st.empty() && st.top() == cnt){    //易错点 注意是while 而不是if 如果序号对了，则继续找临时货架里面的货物  st.pop();res ++;cnt ++;                     } }else{if(st.size() >= m){flag = 1;//别加break 这里，因为你break对于这个顺序放置的货物判断不会出错，但是你的缓冲区里还有数据（参考题设 全部输入完再敲入回车。） 那么你的新一轮循环的cin 还是会取之前break之后原本要输入的缓冲区的数据，}elsest.push(v[i]);}}       if(!flag && res == n) cout << "YES" << endl;else cout << "NO" << endl;}
}

L2-031 深入虎穴 (25 分)

著名的王牌间谍 007 需要执行一次任务，获取敌方的机密情报。已知情报藏在一个地下迷宫里，迷宫只有一个入口，里面有很多条通路，每条路通向一扇门。每一扇门背后或者是一个房间，或者又有很多条路，同样是每条路通向一扇门…… 他的手里有一张表格，是其他间谍帮他收集到的情报，他们记下了每扇门的编号，以及这扇门背后的每一条通路所到达的门的编号。007 发现不存在两条路通向同一扇门。

内线告诉他，情报就藏在迷宫的最深处。但是这个迷宫太大了，他需要你的帮助 —— 请编程帮他找出距离入口最远的那扇门。
输入格式：
输入首先在一行中给出正整数 N,是门的数量。最后 N 行，第 i 行（1≤i≤N）按以下格式描述编号为 i 的那扇门背后能通向的门：

K D[1] D[2] ... D[K]

其中 K 是通道的数量，其后是每扇门的编号。

输出格式：
在一行中输出距离入口最远的那扇门的编号。题目保证这样的结果是唯一的。

输入样例：

输出样例：

关键点：寻找根节点，本题并没有并且表示1就是他的根节点，之前我只拿到了18分，借鉴了其他人的思路明白了自己的错误所在，故添加findRoot函数寻找确定根节点。


//bfs
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
using namespace std;struct node{ // 结构体 深度 和结点int depth;int door;
};
int bfs(queue<node> q, vector<vector<int>> & v){ //bfs搜索int level = 1;int d= 1;while(!q.empty()){      node s = q.front();level = s.depth;d =s.door;q.pop();for(int i = 0; i < v[d].size(); i++){q.push({level + 1, v[d][i]});}    }return d;
}int findRoot(vector<int> &isroot){ //寻找根节点int res = 1;for(int i = 1; i < isroot.size(); i++){if(isroot[i] == 0){res = i;break;}}return res;
}
int main(){int n;cin >> n;int k;vector<vector<int>> v(n + 1); //细节：从1开始计数    int cnt = 1;vector<int> isroot(n + 1);while(n--){cin >> k;for(int i = 0; i < k; i++){int d;cin >> d;v[cnt].push_back(d); // 使用邻接矩阵存储各个结点的后继结点isroot[d] = 1; // 初始化是0，因此如果该cnt结点的后继有d结点，就说明了d不是根节点，用1表示。}cnt ++;}int root  = findRoot(isroot);queue<node> q;    q.push({1, root});int ans = bfs(q, v);cout << ans;
}

7-10 公路村村通 (最小生成树）

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:
输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。

输出格式:
输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1 ，表示需要建设更多公路。

输入样例:

输出样例:

从题目可以得知，这是典型的最小生成树的算法题，找到一条可以都连通的路，并且计算权值总和。
之前自己最小生成树这里的算法基本没有做过，因此添加一题来学习下，避免机试的时候直接不会。
我觉得这篇博主的代码简洁易懂，就按照大佬的思路来写：https://blog.csdn.net/z6_6z/article/details/79604802c


//普利姆算法-- 加点法#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int N = 1001;
int G[N][N]; //采用邻接矩阵G存储
bool visit[N] = {false}; // 标记数组, visit[i] = true表示已经加入了最小生成树的集合中。
int dis[N]; // dis[i]表示顶点i ∈ U - V 到最小生成树集合 任意顶点v ∈V中的边的最小权值。
int n, m;//普利姆算法-- 加点法
int prim(int G[N][N], int v0){int ans = 0;//初始化 dis[1] = 0 表示开始的最小生成树的集合中只有v0dis[v0] = 0;    //因为是加点法：例如题设的1 -> 6 -> 3 -> 5 -> 2 ->4 因此需要遍历 n 个结点，循环n次//从而找出n - 1 条边，形成最小生成树。for(int i = 1; i <= n; i++){int u = -1;  //记录新加入最小生成树集合的顶点uint min = inf;  //最小值在循环中不断变化for(int j = 1; j <= n; j++){if(visit[j] == false && dis[j] < min){u = j;min = dis[u]; }}//但如果无法找到新的顶点 说明不是连通图，无法形成最小生成树// 这里并不包含visit[u] = true都访问的情况，因为如果都访问过，循环就终止了。if(u == -1)return -1;visit[u] = true;// 记录路径长度ans = ans + dis[u];//加入新的的顶点后，还要更新其他U-V顶点的边最小权值dis[k]。for(int k = 1; k <= n; k++){//如果 顶点k未被访问 并且存在边，并且该边的权值小于记录的dis[k]if(visit[k] == false && G[u][k] < inf && G[u][k] < dis[k]){dis[k] = G[u][k];}}}return ans;
}int main(){// 初始化G 和 visitfill(dis, dis + N, inf);fill(G[0], G[0] + N*N, inf);cin >> n >> m;for(int i = 0; i < m; i++){int v1, v2, w;cin >> v1 >> v2 >> w;G[v1][v2] = w;G[v2][v1] = w;}int ans = prim(G, 1);cout << ans;return 0;
}