机试旧题新讲一

最近在准备学校复试，刷一些老题旧题，在N诺oj和牛客网上都有提交。今天就总结部分题目，只写我觉得值得写的（当然还有一些我不会写，不想去学了）。
1、二进制数

输入输出格式
输入描述:
每行有一个数字n（0<=n<=10^8），表示要求的二进制串。
输出描述:
输出共T行。每行输出求得的二进制串。
输入输出样例
输入样例#:
23
输出样例#:
10111

reverse函数必须使用首尾指针，可以反转vector数组也可以反转string字符串。

#include<bits/stdc++.h>
using namespace std;
int main(){unsigned int n;cin>>n;vector<int> res;while (n != 0) {int tmp = n%2;n = n/2;res.push_back(tmp);}reverse(res.begin(),res.end());for (auto i : res) {cout<<i;}
}

2、查找第K小数

查找一个数组的第K小的数，注意同样大小算一样大。如 2 1 3 4 5 2 第三小数为3。

输入输出格式
输入描述:
输入有多组数据。
每组输入n，然后输入n个整数(1<=n<=1000)，再输入k。
输出描述:
输出第k小的整数。
输入输出样例
输入样例#:
6
2 1 3 5 2 2
3
输出样例#:
3

因为要找第k小不同的数，因此不能使用堆来写，因为必须经过一次排序，时间复杂度最快O(nlogn)，然后对比前后不相同的第几个值。

#include<bits/stdc++.h>
using namespace std;
int main () {int n;while (cin>>n) {vector<int> record(n);for (int i = 0; i < n; i++) {cin>>record[i];}sort(record.begin(), record.end());int k;cin>>k;int count = 1;for (int i = 1;i < n; i++) {if (record[i] != record[i-1]){count++;if (count == k) {cout<<record[i]<<endl;}}}}return 0;
}

3、查找1

输入数组长度 n
输入数组 a[1…n]
输入查找个数m
输入查找数字b[1…m]
输出 YES or NO 查找有则YES 否则NO 。
输入输出格式
输入描述:
输入有多组数据。
每组输入n，然后输入n个整数，再输入m，然后再输入m个整数（1<=m<=n<=100）。
输出描述:
如果在n个数组中输出YES否则输出NO。
输入输出样例
输入样例#:
6
3 2 5 4 7 8
2
3 6
输出样例#:
YES
NO

哈希表法，直接定为每个元素是否出现过。

#include<bits/stdc++.h>
using namespace std;
int main() {int n, m;while (cin>>n) {vector<int> nums1(n);vector<int> record(10000, 0);for (int i = 0; i < n; i++) {cin>>nums1[i];record[nums1[i]] = 1;}cin>>m;vector<int> nums2(m);for (int i = 0; i < m; i++) {cin>>nums2[i];if (record[nums2[i]] == 1)cout<<"YES"<<endl;elsecout<<"NO"<<endl;}return 0;}
}

4、哈夫曼树

哈夫曼树，第一行输入一个数n，表示叶结点的个数。需要用这些叶结点生成哈夫曼树，根据哈夫曼树的概念，这些结点有权值，即weight，题目需要输出所有结点的值与权值的乘积之和。
输入输出格式
输入描述:
输入有多组数据。
每组第一行输入一个数n，接着输入n个叶节点（叶节点权值不超过100，2<=n<=1000）。
输出描述:
输出权值。
输入输出样例
输入样例#:
5
1 2 2 5 9
输出样例#:
37

这里用到了优先队列priority_queue，再强调一遍，优先队列默认是less比较仿函数，大顶堆（与sort排序相反）。因此如果需要小顶堆（求最大的k个值，出现最多次的k个数）,要在优先队列的第三个参数使用greater<int>。求WPL。

#include<bits/stdc++.h>
using namespace std;
int main() {int n;while (cin>>n) {vector<int> nums(n);for (int i = 0; i < n; i++) {cin>>nums[i];}priority_queue<int ,vector<int>, greater<int>> q;for (int i = 0; i < n; i++) {q.push(nums[i]);}int res = 0;while (q.size()>1) {int tmp1 = q.top();q.pop();int tmp2 = q.top();q.pop();int sum = tmp1 + tmp2;res += sum;q.push(sum);}cout<<res<<endl;}
}

5、查找 - 北邮

读入一组字符串（待操作的），再读入一个int n记录记下来有几条命令，总共有2中命令：1、翻转从下标为i的字符开始到i+len-1之间的字符串倒序；2、替换命中如果第一位为1，用命令的第四位开始到最后的字符串替换原读入的字符串下标 i 到 i+len-1的字符串。每次执行一条命令后新的字符串代替旧的字符串（即下一条命令在作用在得到的新字符串上）。命令格式：第一位0代表翻转，1代表替换；第二位代表待操作的字符串的起始下标int i；第三位表示需要操作的字符串长度int len。
输入输出格式
输入描述:
输入有多组数据。
每组输入一个字符串（不大于100）然后输入n，再输入n条指令（指令一定有效）。
输出描述:
根据指令对字符串操作后输出结果。
输入输出样例
输入样例#:
bac
2
003
112as
输出样例#:
cab
cas

这里涉及到string的substr、erase、insert函数，需要指出三个函数都可以采用角标（非迭代器）定位首地址，所有左右区间的都是左闭右开，insert函数插入的必须是string类型，不能是char类型。swap函数，老朋友了，交换string，vector都可以。

#include<bits/stdc++.h>
using namespace std;
void reverse(string &s, int begin, int end) {for (int i = begin, j = end; i < j; i++,j--) {swap(s[i],s[j]);}
}
int main() {string str;while (cin>>str) {int n;cin>>n;for (int i = 0; i < n; i++) {string s;cin>>s;//反转if (s[0] == '0') {int begin = s[1]-'0';int end = s[2]-'0'+begin-1;reverse(str, begin, end);cout<<str<<endl;}else if (s[0] == '1') {int begin = s[1]-'0';int end = s[2]-'0'+begin-1;string s1 = s.substr(3, s.size());str.erase(str.begin()+begin, str.begin()+end+1);str.insert(begin,s1);cout<<str<<endl;}}}return 0;
}

6、二叉树（北京邮电大学）

输入二叉树的前序遍历和中序遍历结果，输入二叉树的后序遍历结果。
输入输出格式
输入描述:
第一行为二叉树先序遍历结果。
第二行为二叉树中序遍历结果。
输出描述:
二叉树后续遍历结果
输入输出样例
输入样例#:
426315
623415
输出样例#:
632514

构造二叉树，太难辣！这次是前序加中序构建二叉树，那么下次万一是后序加中序构建二叉树呢！于是勤奋的我把两种都给出来了！然后注意定义树怎么定义：

struct TreeNode{int val;TreeNode *left;TreeNode *right;//构造结构TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

//前、中序构建二叉树
#include<bits/stdc++.h>
using namespace std;
struct TreeNode{int val;TreeNode *left;TreeNode *right;TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
TreeNode* traversal(vector<int>& preorder, vector<int>& inorder)
{if(preorder.size() == 0)return nullptr;int rootValue = preorder[0];TreeNode* root = new TreeNode(rootValue);// 确定中序分割点int Index;for(Index = 0; Index < inorder.size(); Index++){if(inorder[Index] == rootValue) break;}// 分割中序vector<int> leftInorder(inorder.begin(), inorder.begin() + Index);vector<int> rightInorder(inorder.begin() + Index + 1, inorder.end());// 分割前序preorder.erase(preorder.begin());vector<int> leftPreorder(preorder.begin(), preorder.begin() + leftInorder.size());vector<int> rightPreorder(preorder.begin() + leftInorder.size(), preorder.end());// 开始构建树root->left = traversal(leftPreorder, leftInorder);root->right = traversal(rightPreorder, rightInorder);return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {if(preorder.size() == 0 || inorder.size() == 0)return nullptr;return traversal(preorder, inorder);
}
void postTree(TreeNode *t) {if (t != nullptr) {postTree(t->left);postTree(t->right);cout<<t->val;}
}
int main() {vector<int> preTree;vector<int> inTree;string s1,s2;cin>>s1>>s2;for (int i = 0; i < s1.size(); i++) {preTree.push_back(s1[i] - '0');}for (int i = 0; i < s2.size(); i++) {inTree.push_back(s2[i] - '0');}TreeNode *t = buildTree(preTree, inTree);postTree(t);return 0;
}

resize函数可以把后面的去掉。

//中序、后序构造二叉树
class Solution {
public:TreeNode* traversal(vector<int>& inorder, vector<int>& postorder){// 空节点返回nullif(postorder.size() == 0) return nullptr;int rootValue = postorder[postorder.size()-1];//后序遍历最后一个数// 新建的一个节点TreeNode* root = new TreeNode(rootValue);// 中序分割int index;for(index = 0; index < inorder.size(); index++){if(inorder[index] == rootValue)break;}vector<int> leftInorder(inorder.begin(), inorder.begin() + index);vector<int> rightInorder(inorder.begin() + index + 1,inorder.end());// 后序分割postorder.resize(postorder.size() - 1);vector<int> leftPostorder(postorder.begin(),postorder.begin() + index);vector<int> rightPostorder(postorder.begin() + index, postorder.end());// 接上子节点root->left = traversal(leftInorder, leftPostorder);root->right = traversal(rightInorder, rightPostorder);return root;}TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {// 空树if(inorder.size() == 0 || postorder.size() == 0) return nullptr;return traversal(inorder, postorder);}
};

7、二进制数字翻转

入数据组数t

每组数据输入一个十进制数x（0<x<2^32），将其二进制位反转（共32位），然后输出对应的十进制数
输入输出格式
输入描述:
如题
输出描述:
如题
输入输出样例
输入样例#:
2
2
3
输出样例#:
1073741824
3221225472
提示
2^32-1超出了int的范围，请使用long long

他真的，我哭死，他居然提醒我用long long，好贴心啊！

#include<bits/stdc++.h>
using namespace std;
int main() {int t;cin>>t;while(t--) {long long n;cin>>n;vector<int> Binary(32, 0);for (int i = 0; i <32; i++) {Binary[i] = n%2;n /= 2;if (n == 0)break;}//reverse(Binary.begin(), Binary.end());long long sum = 0;for (int i = 0; i < 32; i++){sum *= 2;sum += Binary[i];}cout<<sum<<endl;}return 0;
}

8、发财数

一个大于等于2的整数，如果可以分解为8个或8个以上的素数相乘，则称其为发财数，让你输出第n个发财数
输入输出格式
输入描述:
输入一个整数t，代表有t组数据(t<1000)
输入一个正整数n，（n<=10000）
输出描述:
输出第n个发财数。
输入输出样例
输入样例#:
1
1
输出样例#:
256

枚举遍历，每一次都除以一个数，如果可以除尽。接着除，否则除的数加一，往后看，看是否可以被八个数整除。

#include<bits/stdc++.h>
using namespace std;
int main () {int t;cin>>t;vector<int> nums;while (t--) {int n;cin>>n;
//		if (n <= nums.size()) {
//			cout<<nums[n-1]<<endl;
//		}for (int i = (nums.size() > 0 ? nums.back() + 1 : 256); nums.size() <= n+1; i++) {int value = i;int count = 8;for (int j = 2; j*j <= value;) {if (value % j == 0) {count--;value /= j;if (count == 1) {nums.push_back(i);}}else {j++;}}}
//		for (int i = 0; i < nums.size();i++) {
//			cout<<nums[i]<<" ";
//		}cout<<nums[n-1]<<endl;}return 0;
}

9、复数集合

一个复数（x+iy）集合，两种操作作用在该集合上： 1、Pop 表示读出集合中复数模值最大的那个复数，如集合为空输出 empty ，不为空就输出最大的那个复数并且从集合中删除那个复数，再输出集合的大小SIZE； 2 Insert a+ib 指令（a，b表示实部和虚部），将a+ib加入到集合中，输出集合的大小SIZE；最开始要读入一个int n，表示接下来的n行每一行都是一条命令。
输入输出格式
输入描述:
输入有多组数据。
每组输入一个n(1<=n<=1000)，然后再输入n条指令。
输出描述:
根据指令输出结果。
模相等的输出b较小的复数。
a和b都是非负数。
输入输出样例
输入样例#:
3
Pop
Insert 1+i2
Pop
输出样例#:
empty
SIZE = 1
1+i2
SIZE = 0

排序固然可，但是堆更妙。在结构体里构建排序函数，重载运算符<号可以自定义堆的排序方式。这样出来的大顶堆是按照我们自己定义的方式排序的大顶堆。还有一件事，就是出入如果不符合，那么就会卡住，比如你出入一个字符，但是我用int来接，就接不了，会卡在缓冲区，因此如果有一个字符你不要可以用一个临时变量将其取出，然后不作处理。还有一件事，就是比如234+345这样的式子，可以用int，char，int分别取出三个部分这个真的有用哎！如果一串1 2 3 5，如果想当做字符串，可以getline（cin，str）。

#include<bits/stdc++.h>
using namespace std;
struct Complex{int x;int y;bool operator< (Complex node) const{if (x*x+y*y == node.x*node.x+node.y*node.y) {return y > node.y;}return x*x+y*y < node.x*node.x+node.y*node.y;}
};int main() {int n;while (cin>>n) {string cmd;priority_queue<Complex> q;while (n--) {cin>>cmd;Complex C;if (cmd == "Pop") {if (q.size() == 0) {cout<<"empty"<<endl;}else {cout<<q.top().x<<"+i"<<q.top().y<<endl;q.pop();cout<<"SIZE = "<<q.size()<<endl;}}else if (cmd == "Insert") {char o,c;cin>>C.x>>o>>c>>C.y;q.push(C);cout<<"SIZE = "<<q.size()<<endl;}}}return 0;
}

10、矩阵幂

给定一个n*n的矩阵，求该矩阵的k次幂，即P^k。
输入输出格式
输入描述:
第一行：两个整数n（2<=n<=10）、k（1<=k<=5），两个数字之间用一个空格隔开，含义如上所示。
接下来有n行，每行n个正整数，其中，第i行第j个整数表示矩阵中第i行第j列的矩阵元素Pij且（0<=Pij<=10）。另外，数据保证最后结果不会超过10^8。
输出描述:
对于每组测试数据，输出其结果。格式为：
n行n列个整数，每行数之间用空格隔开，注意，每行最后一个数后面不应该有多余的空格。
输入输出样例
输入样例#:
2 2
9 8
9 3
输出样例#:
153 96
108 81

其实不用快速幂也可以完成，但是可以用更dio的方法为什么不用呢对吧！快速幂，类似求01串转化为十进制数，从低位开始，结果值初始化为1，如果低位为零，则不作处理，低位自己平方；否则结果值乘前面说的低位平方（一直累计）。本题是模板题，要背！
咱就是自己归纳三部曲：
1、重载运算符，返回值为二维数组，其实就是将普通乘法变为矩阵乘法。矩阵乘矩阵返回矩阵。
2、初始化结果矩阵，结果矩阵必须初始化为单位阵。
3、快速幂方法：*

//快速幂方法while (k>0) {if (k % 2 == 1) {Q = Q * P;}P = P * P;k /= 2;}

#include<bits/stdc++.h>
using namespace std;
//重载运算符*变为矩阵乘法，返回一个矩阵
vector<vector<int>> operator*(const vector<vector<int>> &a,const vector<vector<int>> &b) {int n = a.size();vector<vector<int>> tmp(n, vector<int>(n, 0));for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {for (int k = 0; k < n; k++) {tmp[i][j] += a[i][k] * b[k][j];}}}return tmp;
}int main () {int n,k;while (cin>>n>>k) {	vector<vector<int>> P(n, vector<int>(n, 0));vector<vector<int>> Q(n,vector<int>(n, 0));//结果矩阵对角线为1for (int i = 0; i < n; i++) {Q[i][i] = 1;}for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {cin>>P[i][j];}}//快速幂方法while (k>0) {if (k % 2 == 1) {Q = Q * P;}P = P * P;k /= 2;}for (int i = 0; i < n; i++) {cout<<Q[i][0];for (int j = 1; j < n; j++) {cout<<" "<<Q[i][j];}cout<<endl;}}
}