1541

1541

关注
发信
关注(28)粉丝(399)

Noj - 在线强化训练4

状态题号竞赛题号标题
×1092A
×1145B
×1144C
×1202D
×1243E
×1473F
×1474G
×1501H
×1541I
×1042J
×1043K
×1571L
1092.童年的回忆——计算24
时限：1000ms 内存限制：10000K  总时限：3000ms
描述
很多年过去了，每当想起儿时跟表弟玩计算24的游戏时的情景，还会情不自禁地微微一笑。
游戏的规则很简单：一副扑克牌，乱序后每局抽出4张，计算牌面点数经四则运算是否能得到24。先计算出的人扼要说出计算方法，验证无误后获得本局比赛胜利，得到4张牌。全部牌用完后谁手中的牌多即获得最后的胜利！
有些题目很简单，如2，2，2，3，常常看到你争我抢的局面，而有的题目则不太容易算出，甚至可能误判为无解，如2，4，9，10……
现在，我们都学会了编程。为了在多年后再一争高下，我们决定进行一次新的比拼：看谁写出的程序能既快又准地算出结果！比赛的基本规则不变，即仍是每局4个整数，运用四则运算（可以加括号），但为了降低程序设计的难度，除法的结果只保留整数部分，即5/2=2。
怎么样，你是不是也想加入我们的比赛呢？看看谁能获得最后的胜利！

输入
本题包含多个测例。
数据的第一行有一个整数N（0从第二行开始的N行，各包含4个不大于15的以空格分隔的非零整数。

输出
对于每个测例，如果可以计算得到24，则输出“Yes”，否则输出“No”。每个输出占一行。

输入样例
2
2 2 3 3
2 4 9 10

输出样例
Yes
Yes

提示

来源
icso.

1092.童年的回忆——计算24

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <cmath>
 using namespace std;

 int cal(int x, int y, int op); //定义加减乘除运算
 int search(int m); //回溯法遍历所有数字顺序
 int test(); //遍历所有运算符
 int calculate(int op1, int op2, int op3); //遍历所有括号形式

 int n;
 ];
 int main()
 {
     while(cin>>n)
     {
         while(n--)
         {
             ; j<; j++)
             {
                 cin>>a[j];
             }
             ))
                 cout<<"Yes"<<endl;
             else
                 cout<<"No"<<endl;
         }
     }
     ;
 }
 /*回溯法遍历所有数字顺序*/
 int search(int m)
 {
     )
     {
         )
             ;
     }
     else
     {
         ; i++)
         {
             swap(a[i], a[m]);
             ) == )
             {
                 );
             }
             swap(a[i], a[m]);
         }
     }
     ;
 }

 /*遍历所有运算符*/
 int test()
 {
     ; i<; i++)
         ; j<; j++)
             ; k<; k++)
                 )
                     ;
     ;
 }

 /*遍历所有括号形式*/
 int calculate(int op1, int op2, int op3)
 {
     ], a[], op1), a[], op2), a[], op3) == )
     {
         );
     }

     ], a[], op1), cal(a[], a[], op3), op2) == )
     {
         );
     }

     ], cal(a[], a[], op2), op1), a[], op3) == )
     {
         );
     }

     ], cal(cal(a[], a[], op2), a[], op3), op1) == )
     {
         );
     }

     ], cal(a[], cal(a[], a[], op3), op2), op1) == )
     {
         );
     }
     );
 }

 /*定义加减乘除运算*/
 int cal(int x, int y, int op)
 {
     switch(op)
     {
     :
         return x + y;
     :
         return x - y;
     :
         return x * y;
     :
         )
             return x / y;
         else
             ; //返回一个很大的数即刻
     }
 }

代码A

.循环赛日程表
时限：1000ms 内存限制：10000K  总时限：3000ms
描述
用分治算法生成循环赛日程表（1到2的n次方个人）

输入
一个小于等于7的正整数n

输出
循环赛日程表（1到2的n次方个人）

输入样例

输出样例

提示

来源

E1243.循环赛日程表

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <cmath>
 using namespace std;

 void creatTable(int n);
 void printTable(int n);
 ][]; //行和列都从1开始计数

 int main()
 {
     int n;
     while(cin>>n)
     {
         creatTable(n);
         printTable(n);
     }
     ;
 }

 void creatTable(int n)
 {
     peo[][] = ;
     peo[][] = ;
     peo[][] = ;
     peo[][] = ;
     ; k<=n; k++)//一共还需要分治n-1次，这是第2次
     {
         )); //左上角的子方阵的长度
         int now = pow(2.0, double(k)); //当前大方阵的长度
         ; i<=now; i++)
         {
             ; j<=now; j++)
             {
                 /*通过左上角填充左下角，左下角元素 = 左上角对应元素 + 2^(x-1)*/
                 peo[i][j] = peo[i-pre][j] + pre;
             }
         }
         ; i<=pre; i++)
         {
             ; j<=now; j++)
             {
                 /*通过左下角填充右上角，右上角元素 = 左下角对应元素*/
                 peo[i][j] = peo[i+pre][j-pre];
             }
         }
         ; i<=now; i++)
         {
             ; j<=now; j++)
             {
                 /*右下角元素 = 左上角元素*/
                 peo[i][j] = peo[i-pre][j-pre];
             }
         }
     }

 }
 void printTable(int n)
 {
     int num = pow(2.0, double(n)); //人数=2的n次方
     ; x<=num; x++)
     {
         ; y<num; y++)
         {
             cout<<peo[x][y]<<" ";
         }
         cout<<peo[x][num];
         cout<<endl;
     }
 }

代码E

.括号匹配
时限：1000ms 内存限制：10000K  总时限：3000ms
描述
假设一个算术表达式中可以包含三种括号：圆括号"("和")",方括号"["和"]"和花括号"{"和"}"，且这三种括号可按任意的次序嵌套使用，如：...[...(...)...{...{...}...[...]...}...]...，编写程序判别给定表达式中所含括号是否正确配对出现。

输入
输入一个由这几种括号组成的字符串，字符串长度不大于100。

输出
若正确则输出"Yes"，否则输出"No"。注意字母的大小写，结尾带回车。

输入样例
{()[]}{}

输出样例
Yes

1473.括号匹配

 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #include <stack>
 using namespace std;

 int main()
 {
     string str;
     while(cin>>str)
     {
         stack<char> stack_str;
         ]==]==]=='}')
             cout<<"No"<<endl;
         else
         {
             ; i<str.length(); i++) //string类的length()或者size()函数返回的是unsigned integer(无符号数)类型。
             {
                 if(str[i]=='(' || str[i]=='[' || str[i]=='{')
                     stack_str.push(str[i]);
                 if(str[i]==')' && stack_str.top()=='(')
                 {
                     stack_str.pop();
                     continue;
                 }
                 if(str[i]==']' && stack_str.top()=='[')
                 {
                     stack_str.pop();
                     continue;
                 }
                 if(str[i]=='}'&& stack_str.top()=='{')
                 {
                     stack_str.pop();
                     continue;
                 }
             }
             if(stack_str.empty())
                 cout<<"Yes"<<endl;
             else
                 cout<<"No"<<endl;
         }
     }

     ;
 }

代码F

.四则元算表达式转换为逆波兰式
时限：1000ms 内存限制：10000K  总时限：3000ms
描述
假设表达式由单字母整数类型变量和双目四则运算符构成（"+","-","*","/"）,写一个程序，将一个通常书写形式且书写正确的表达式转换为逆波兰式。

输入
输入一个完整的正确的四则运算表达式，长度不超过100（其中仅含有："("、")"、"a"、"b"和"c"五种字符）。

输出
输出这个表达式的逆波兰表达式。注意结尾带回车。

输入样例
输入样例一：(a+b)
输入样例二：((a+b)*(a-c))
输入样例三：((a*(b+c))-(a/c))

输出样例
输出样例一：ab+
输出样例二：ab+ac-*
输出样例三：abc+*ac/-

1474.四则元算表达式转换为逆波兰式

 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #include <stack>
 using namespace std;

 int main()
 {
     ];
     stack<char> s;
     while(cin>>str)
     {
         while(!s.empty()) //清空栈
             s.pop();
         ;
         while(str[i++] != '\0')
         {
             if(str[i] == '(')
                 continue;
             else if(str[i]== 'a' || str[i]=='b' || str[i]=='c')
                 cout<<str[i];
             else if(str[i]=='+' || str[i]=='-' || str[i]=='*' || str[i]=='/')
                 s.push(str[i]);
             else if(str[i] == ')')
             {
                 cout<<s.top();
                 s.pop();
             }
         }
         cout<<endl;
     }
     ;
 }

代码G

.用括号法递归建立二叉树
时限：1000ms 内存限制：10000K  总时限：3000ms
描述
如果用大写字母标识二叉树节点，则一棵二叉树可以用以下字母序列建立，#表示空节点。试写一个递归算法，有这种形式的字符序列，建立相应的二叉树的二叉链表存储结构，并按层次遍历输出。如一棵二叉树可表示为：A(B(#,D),C(E(#,F),#))

输入
按题中要求，用括号法输入二叉树序列，#表示空节点

输出
按层次遍历建立好的二叉树并输出

输入样例
A(B(#,D),C(E(#,F),#))

输出样例
ABCDEF

1501.用括号法递归建立二叉树

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 using namespace std;

 void printBinary();
 void createBinary(char c);

 ];
 ]; //用数组存储二叉树，下标2i代表i的左孩子，2i+1代表i的右孩子
 int pos; //用来记录二叉树下标
 ; //记录二叉树的长度
 int main()
 {

     while(cin>>str)
     {
         pos = ; //初始从1开始，不然0*2=0
         ; i<; i++)
             BinaryTree[i] = '#'; //二叉树初始化为0
         ;
         while(str[j]!='\0')
         {
             createBinary(str[j]);
             j++;
         }
         printBinary();
     }

     ;
 }

 /*将c插入二叉树数组*/
 void createBinary(char c)
 {
     if((c>='A' && c<='Z') || c=='#')
     {
         BinaryTree[pos] = c;
         length++;
     }
     else if(c=='(')
     {
         pos = pos * ;
     }
     else if(c==',')
     {
         pos += ;
     }
     else if(c==')')
     {
         pos /= ;
     }
 }

 void printBinary()
 {
     ; i<; i++)
     {
         if(BinaryTree[i] != '#')
             cout<<BinaryTree[i];
     }
     cout<<endl;
 }

代码H

.加1乘2平方
时限：1000ms 内存限制：10000K  总时限：3000ms
描述
最简单的队列的使用
#include <iostream>
#include <queue>
using namespace std;

queue<int> q1;
int main()
{
int temp, x;
q1.push();//入队
q1.push();//入队
temp = q1.front();//访问队首元素
q1.pop();//出队
q1.empty();//判队列是否为空
q1.back();//返回队尾元素
q1.size();//返回队列长度
}

给定两个正整数m、n，问只能做加1、乘2和平方这三种变化，从m变化到n最少需要几次

输入
输入两个10000以内的正整数m和n，且m小于n

输出
输出从m变化到n的最少次数

输入样例

输出样例

I 1541.加1乘2平方

 #include <iostream>
 #include <cstdio>
 #include <queue>
 #include <cstring>
 using namespace std;
 int bsf();
 int m, n;
 ]; //visited[i]=3 代表访问i的步数是3
 queue<int> q;
 int main()
 {
     while(cin>>m>>n)
     {
         memset(visited,  , sizeof(visited));
         cout<<bsf()<<endl;
     }
     ;
 }

 int bsf()
 {
     q.push(m);
     visited[m] = ;
     while(!q.empty())
     {
         int temp = q.front();
         q.pop();
         if(temp == n)
         {
             return visited[n];
         }
         <=n && !visited[temp+])
         {
             q.push(temp+);
             visited[temp+] = visited[temp] + ;
         }
         <=n && !visited[temp*])
         {
             q.push(temp*);
             visited[temp*] = visited[temp] + ;
         }
         if(temp*temp<=n && !visited[temp*temp])
         {
             q.push(temp*temp);
             visited[temp*temp] = visited[temp] + ;
         }
     }
     ;
 }

代码I

04-30 20:20
Powered by LMLPHP ©2024 1541 0.073746