A:单词翻转
总时间限制: 1000ms 内存限制: 65536kB
描述:
输入一个句子（一行），将句子中的每一个单词翻转后输出。
输入:
只有一行，为一个字符串，不超过500个字符。单词之间以空格隔开。
输出:
翻转每一个单词后的字符串，单词之间的空格需与原文一致。
样例输入
hello world
样例输出
olleh dlrow
这道题算是首次用c++在oj上刷题，一开始调用了reverse函数，一直WA，很郁闷，直接cout倒是AC了。
#include <stdio.h>
#include<iostream>
#include <string.h>
#include <string>
#include <cstdio>
#include <algorithm>
using namespace std;
int main() {
string sentence;
getline(cin,sentence);//使用了getline
int left=0;//单词左边
int right=0;//单词右边
while(right<sentence.size()){
//遇到空格就是一个单词（中间多个空格也成立）
if(sentence[right]==' ') {
for(int i=right-1;i>=left;i--) {
cout << sentence[i];
}
cout<<' ';
left=right+1;
}
if(right==sentence.size()-1){
for(int i=right;i>=left;i--) {
cout << sentence[i];
}
}
right++;
}
return 0;
}
B:密码
总时间限制: 1000ms 内存限制: 65536kB
描述
Bob 和 Alice 开始使用一种全新的编码系统。它是一种基于一组私有钥匙的。他们选择了n个不同的数a1 ， . . .，an, 它们都大于0小于等于n。 机密过程如下：待加密的信息放置在这组加密钥匙下，信息中的字符和密钥中的数字一一对应起来。信息中位于i位置的字母将被写到加密信息的第ai个位置, ai 是位于i位置的密钥。加密信息如此反复加密，一共加密 k 次。
信息长度小于等于n。如果信息比 n 短, 后面的位置用空格填补直到信息长度为n。
请你帮助 Alice 和 Bob 写一个程序，读入密钥，然后读入加密次数 k 和要加密的信息，按加密规则将信息加密。
输入
输入包括几块。每块第一行有一个数字n, 0 < n <= 200. 接下来的行包含n个不同的数字。数字都是大于0小于等于n的。下面每行包含一个k和一个信息字符串，它们之间用空格格开。每行以换行符结束，换行符不是要加密的信息。每个块的最后一行只有一个0。 最后一个块后有一行，该行只有一个0。
输出
输出有多个块，每个块对应一个输入块。每个块包含输入中的信息经过加密后的字符串，顺序与输入顺序相同。所有加密后的字符串的长度都是 n。 每一个块后有一个空行。
样例输入
10
4 5 3 7 2 8 1 6 10 9
1 Hello Bob
1995 CERC
0
0
样例输出
BolHeol b
C RCE
来源
poj 1026
这道题的输入就难倒我了，结果还不是表面上看起来的容易，需要找到密码的循环节，也就是说，找到转换多少次后又对应位置的字母又回到了原位，不然会超时。
#include <stdio.h>
#include<iostream>
#include <string.h>
#include <string>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
int n,k;
int code[210],T[210],ans[210];
bool vis[210];//类似union find
char s[210];
while(cin>>n)
{
if(n==0) break;
for(int i=1;i<=n;++i)
{
cin>>code[i];
}
memset(vis,0,sizeof(vis));//数组初始化
for(int i=1;i<=n;++i)
{
if(vis[i])continue;
vis[i]=true;
int cnt=1;
for(int j=code[i];j!=i;j=code[j])
{
cnt++;
vis[j]=true;
}
T[i]=cnt;//找到圈，存下来
for(int j=code[i];j!=i;j=code[j])
{
T[j]=cnt;//所有的这条路径，肯定都是再变换这么多次就回来
}
}
while(cin>>k)
{
if(k==0) break;
getchar();//防空格
cin.getline(s+1,200);
int len=strlen(s+1);
for(int i=len+1;i<=n;++i)
{
s[i]=' ';//末尾填充空格
}
s[n+1]='\0';//末尾填充字符串结尾符
for(int i=1;i<=n;++i)
{
int j=i;
for(int t=0;t<(k%T[i]);++t)//变换k%T[i]次即可
{
j=code[j];
}
ans[j]=i;
}
for(int i=1;i<=n;++i)
{
cout<<s[ans[i]];
}
cout<<endl;
}
cout<<endl;
}
return 0;
}
C:数组转换
总时间限制: 1000ms 内存限制: 65535kB
描述
有n个数字1,2,3…,n，由小至大依次放入栈。问是否存在一种出栈方式，使这n个数字出栈的顺序为a1,a2,…,an。
输入
第一行输入一个整数t，代表有t组测试数据
对于每组测试数据，第一行输入整数n，第二行输入n个数字：a1,a2, … , an
1<= n <= 1000
输出
每组测试数据输出一行。
如果出栈顺序a1,a2,…,an是合法的，输出yes，否则输出no。
样例输入
3
3
1 2 3
3
3 2 1
4
1 4 2 3
样例输出
yes
yes
no
这道题的思路是说，找一个栈直接模拟这个入栈出栈的过程，如果放进去要弹出来，就得先把前面压进去的弹出来。我一开始的思路不太对，想着先找出那些立马弹出来的（以为下标等于数字就行），再根据栈的弹出过程来判断，这样子没有考虑全面，比如1342也可以。
#include <stdio.h>
#include<iostream>
#include <string.h>
#include <string>
#include <cstdio>
#include <algorithm>
#include <stack>
using namespace std;
int main() {
int t;
cin>>t;
int test_num=0;
while(test_num<t){
int n;
cin>>n;
stack<int>s;
int nums[n];
for(int i=0;i<n;i++){
int num;
cin>>num;
nums[i]=num;
}
int point=0;
bool flag=true;
for(int i=0;i<n;i++)
{
//将nums[i]前面的元素都压入栈
//point存储压到哪个元素了
for(int j=point+1;j<=nums[i];j++)
{
point=j;
s.push(j);
}
//不等于就不对了
if(s.top()!=nums[i]) {
flag = false;
break;
}
else {
s.pop();
}
}
if(flag) {
cout << "yes" << endl;
}
else{
cout<<"no"<<endl;
}
test_num++;
}
return 0;
}
D:汉诺塔问题(Hanoi)
总时间限制: 1000ms 内存限制: 65535kB
描述
一、汉诺塔问题
有三根杆子A，B，C。A杆上有N个(N>1)穿孔圆盘，盘的尺寸由下到上依次变小。要求按下列规则将所有圆盘移至C杆： 每次只能移动一个圆盘； 大盘不能叠在小盘上面。 提示：可将圆盘临时置于B杆，也可将从A杆移出的圆盘重新移回A杆，但都必须遵循上述两条规则。
问：如何移？最少要移动多少次？
可参考如下网址：
http://blog.csdn.net/geekwangminli/article/details/7981570
输入
输入为一个整数后面跟三个单字符字符串。
整数为盘子的数目，后三个字符表示三个杆子的编号。
输出
输出每一步移动盘子的记录。一次移动一行。
每次移动的记录为例如3:a->b 的形式，即把编号为3的盘子从a杆移至b杆。
我们约定圆盘从小到大编号为1, 2, …n。即最上面那个最小的圆盘编号为1，最下面最大的圆盘编号为n。
样例输入
3 a b c
样例输出
1:a->c
2:a->b
1:c->b
3:a->c
1:b->a
2:b->c
1:a->c
主要参考了上面写的网址，使用递归，总体步骤就是，先把n-1个盘子借助第3个柱子挪到第2个柱子，再把这个盘子挪到第3个柱子，然后再把n-1个盘借助第一个盘挪到第三个盘。
#include<cstdio>
#include<cstring>
#include<vector>
#include<utility>
#include <iostream>
using namespace std;
int move(int num,char from,char temp,char to){
//递归的边界条件，盘子只剩一个
if(num==1){
cout<<num<<":"<<from<<"->"<<to<<endl;
}
else{
move(num-1,from,to,temp);
cout<<num<<":"<<from<<"->"<<to<<endl;
move(num-1,temp,from,to);
}
}
int main(){
int n;
cin>>n;
char a,b,c;
cin>>a>>b>>c;
move(n,a,b,c);
return 0;
}
E:由中根序列和后根序列重建二叉树
总时间限制: 500ms 内存限制: 65535kB
描述
我们知道如何按照三种深度优先次序来周游一棵二叉树，来得到中根序列、前根序列和后根序列。反过来，如果给定二叉树的中根序列和后根序列，或者给定中根序列和前根序列，可以重建一二叉树。本题输入一棵二叉树的中根序列和后根序列，要求在内存中重建二叉树，最后输出这棵二叉树的前根序列。
用不同的整数来唯一标识二叉树的每一个结点，下面的二叉树
中根序列是9 5 32 67
后根序列9 32 67 5
前根序列5 9 67 32
输入
两行。第一行是二叉树的中根序列，第二行是后根序列。每个数字表示的结点之间用空格隔开。结点数字范围0～65535。暂不必考虑不合理的输入数据。
输出
一行。由输入中的中根序列和后根序列重建的二叉树的前根序列。每个数字表示的结点之间用空格隔开。
样例输入
9 5 32 67
9 32 67 5
样例输出
5 9 67 32
碰到树的问题首先想递归，我的思路是从后序遍历中先找到根（最后一个元素），再从确定中序遍历的左右子树内容，对左右子树递归。
#include <stdio.h>
#include<iostream>
#include <string.h>
#include <string>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
void rebuild(int mid[],int back[],int l1,int r1, int l2,int r2){
//输出根节点
cout<<back[r2]<<" ";
//停止条件，如果只剩一个元素就结束
if(l1-r1==0)
return;
//找到根节点位置
int point1=-1;
for(int i=l1;i<=r1;i++){
if(back[r2]==mid[i]){
point1=i;
}
}
//有左子树
if(point1-1>=0) {
int l2_new = -1;
int r2_new = -1;
for (int i = l2; i <= r2; i++) {
if (back[i] == mid[l1]) {
l2_new = i;
}
if (back[i] == mid[point1 - 1]) {
r2_new = i;
}
}
rebuild(mid, back, l1, point1 - 1, l2_new, r2_new);
}
//有右子树
if(mid[point1+1]>0) {
int l2_new = -1;
int r2_new = -1;
for (int i = l2; i <= r2; i++) {
if (back[i] == mid[point1 + 1]) {
l2_new = i;
}
if (back[i] == mid[r2]) {
r2_new = i;
}
}
rebuild(mid, back, point1 + 1, r2, l2_new, r2_new);
}
}
int main() {
int i=0;
int mid[65536];
int back[65536];
while(cin>>mid[i++])
{
if(cin.get() != ' ') break;
}
i=0;
while(cin>>back[i++])
{
if(cin.get() != ' ') break;
}
rebuild(mid,back,0,i-1,0,i-1);
return 0;
}
F:区间合并
总时间限制: 1000ms 内存限制: 65536kB
描述
给定 n 个闭区间 [ai; bi]，其中i=1,2,…,n。任意两个相邻或相交的闭区间可以合并为一个闭区间。例如，[1;2] 和 [2;3] 可以合并为 [1;3]，[1;3] 和 [2;4] 可以合并为 [1;4]，但是[1;2] 和 [3;4] 不可以合并。
我们的任务是判断这些区间是否可以最终合并为一个闭区间，如果可以，将这个闭区间输出，否则输出no。
输入
第一行为一个整数n，3 ≤ n ≤ 50000。表示输入区间的数量。
之后n行，在第i行上（1 ≤ i ≤ n），为两个整数 ai 和 bi ，整数之间用一个空格分隔，表示区间 [ai; bi]（其中 1 ≤ ai ≤ bi ≤ 10000）。
输出
输出一行，如果这些区间最终可以合并为一个闭区间，输出这个闭区间的左右边界，用单个空格隔开；否则输出 no。
样例输入
5
5 6
1 5
10 10
6 9
8 10
样例输出
1 10
一开始就想到要排序，但是c++的结构体不会弄，又学习了一波。
#include <stdio.h>
#include<iostream>
#include <string.h>
#include <string>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
//定义结构体 oj常用
struct area{
int upper;
int lower;
};
//定义比较函数
int cmp(area x1, area x2){
return x1.lower<x2.lower;
}
int main() {
vector<int> v1;
vector<int> v2;
int n;
cin>>n;
area a[n];
int areanum=0;
while(areanum<n){
int lower;
cin>>lower;
int upper;
cin>>upper;
a[areanum].lower=lower;
a[areanum].upper=upper;
areanum++;
}
//排序用法
sort(a,a+n,cmp);
int l=a[0].lower;
int h=a[0].upper;
for(int i=0;i<n;i++){
if(a[i].lower>h){
cout<<"no";
return 0;
}
else{
h=max(a[i].upper,h);
}
}
cout<<l<<" "<<h;
return 0;
}
主要学习oj上常用的c++语法，和一些思路（比如循环节），收获挺大的，继续努力。