vjudge评测传送门
例题3-4
实现一个经典"猜数字"游戏。 给定答案序列和用户猜的序列，统计有多少数字位置正确（A），有多少数字在两个序列都出现过但位置不对（B）。
输入包含多组数据。 每组输入第一行为序列长度n，第二行是答案序列，接下来是若干猜测序列。 猜测序列全0时该组数据结束。 n=0时输入结束。
样例输入：
4
1 3 5 5
1 1 2 3
4 3 3 5
6 5 5 1
6 1 3 5
1 3 5 5
0 0 0 0
10
1 2 2 2 4 5 6 6 6 9
1 2 3 4 5 6 7 8 9 1
1 1 2 2 3 3 4 4 5 5
1 2 1 3 1 5 1 6 1 9
1 2 2 5 5 5 6 6 6 7
0 0 0 0 0 0 0 0 0 0
0
样例输出
Game 1:
(1,1)
(2,0)
(1,2)
(1,2)
(4,0)
Game 2:
(2,4)
(3,2)
(5,0)
(7,0)
分析：本题基本思路很简单，每组猜数游戏中先输入一个序列随后再输入n个序列分别与第一个序列相比较。括号中第一个数表示每次比较中相同位置的数的数目，这个只需每次挨个比较相同的即可。第二个比较两个序列都出现过但位置不对的数的数量，这一点要注意以下。说的是“两个序列都出现过”，即意味着必须一一配对，多余的不算。比如在答案序列中出现了6个1，猜的序列中只有3个，那么只能有三个一一配对，剩下3个1不予考虑。统计出所有一一配对的数量后，减去位置相同的配对数量，剩下的就是能配对但位置不相同的配对数量。
#include<cstdio>
#define Max 1005
int a[Max],b[Max];
int n,con=1,a1,a2,b1,b2;
int main(){
while(scanf("%d",&n)==1&&n){ //输入序列长度
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
printf("Game %d:\n",con++);
while(1){
a1=a2=0;
for(int i=0;i<n;i++){
scanf("%d",&b[i]);
}
if(b[0]==0)break; //序列中没有0，如果第一个都是0，直接结束
for(int i=0;i<n;i++){
if(a[i]==b[i]) a1++; //统计能配对且位置相同的配对数量
}
for(int i=1;i<=9;i++){ //统计所有可配对的数量
b1=b2=0;
for(int j=0;j<n;j++){
if(a[j]==i)b1++;
if(b[j]==i)b2++;
}
if(b1<b2) a2+=b1; //根据一一配对的原则，最小的数量才能一一配对
else a2+=b2;
}
printf(" (%d,%d)\n",a1,a2-a1);//输入位置相同的配对数量和位置不相同的配对数量
}
}
}例题 3.5生成元
题意：如果x加上x的各个数字之和得到y，就说x是y的生成元，给出n(1<=n<=100000),求最小生成元。无解输出0.例如，n=216,121,2005时的解分别为198,0,1979.
样例输入：
3
216
121
2005
样例输出：
198
0
1979
分析:为了节省时间，我们可以将0-100000之间的生成元直接打表，到时候输入一个数，到时候生成一个数直接根据下标查找对应最小生成元即可。
#include<cstdio>
#define N 100005
int num[N];
int con=0,n,x,sum;
int main(){
for(int i=0;i<=9;i++){ //对0-99999之间的生成元打表
for(int j=0;j<=9;j++){
for(int k=0;k<=9;k++){
for(int l=0;l<=9;l++){
for(int m=0;m<=9;m++){
sum = con+i+j+k+l+m;
if(num[sum]==0||con<num[sum])
num[sum]=con;
con++;
}
}
}
}
}
num[100000]=99959;//最后一个数额外打表
scanf("%d",&n);
while(n--){
scanf("%d",&x);
printf("%d\n",num[x]);
}
}例题 3-6 环状序列
长度为n的环状串有n种表示法，分别为从某个位置开始顺时针得到。例如，下图的环状串有10种表示：CGAGTCAGCT，GAGTCAGCTC，AGTCAGCTCG等。在这些表示法中，字典序最小的称为"最小表示"。
输入一个长度为n（n≤100）的环状DNA串（只包含A、C、G、T这4种字符）的一种表示法，你的任务是输出该环状串的最小表示。例如，CTCC的最小表示是CCCT，CGAGTCAGCT的最小表示为AGCTCGAGTC。
样例输入：
2
CGAGTCAGCT
CTCC
样例输出：
AGCTCGAGTC
CCCT
分析：本题即求字典序，可以定义两个“位置指针”。第一个位置指针指示当前假定的字典序列最优解，第二个位置指针指示当前要尝试比较的序列。将第一个与第二个位置指针每个序列的字符asc码相比较，若前者小于后者，则尝试下一个序列。若相等，则尝试比较下一个字符，直至有不相等情况产生。若大于，则让当前位置指针替换最优位置指针。最终即可求得一个最优字典序。
#include<cstdio>
#define M 105
int n,len,ans,i,j,k;
char str[M];
int main(){
scanf("%d",&n);
for(int t=0;t<n;t++){
scanf("%s",str);
len=0;
while(str[len++]){}//求序列长度，懒得用stelen了
len--;
ans=0;
for(i=1;i<len;i++){//尝试环状序列的所有位置
for(j=0;j<len;j++){//将每一个序列的每一个字符与最优序列的每一个字符相比较
if(str[(i+j)%len]<str[(ans+j)%len]){//若当前小于最优，则替换
ans = i;
break;
}
else if(str[(i+j)%len]==str[(ans+j)%len]){//若相等，则继续比较下一个字符
continue;
}
else{ //若不等，则尝试下一个序列
break;
}
}
}
for(k=0;k<len;k++) //从最优点开始输出序列
printf("%c",str[(ans+k)%len]);
printf("\n");
}
}
习题3-1 得分
给出一个由O和X组成的串（长度为1～80），统计得分。每个O的得分为目前连续出现的O的个数，X的得分为0。例如，OOXXOXXOOO的得分为1+2+0+0+1+0+0+1+2+3。
输入：
5
OOXXOXXOOO
OOXXOOXXOO
OXOXOXOXOXOXOX
OOOOOOOOOO
OOOOXOOOOXOOOOX
输出：
10
9
7
55
30
分析：实在没啥可说的，按着题目弄就行
#include<cstdio>
#define M 105
char str[M];
int t,sum,num,len;
int main(){
scanf("%d",&num);
for(int i=0;i<num;i++){
scanf("%s",str);
len = -1;
sum=0;
t=0;
while(str[++len]){}
while(len--){
switch(str[len]){
case 'O': t++;break;
case 'X': t=0;break;
}
sum+=t;
}
printf("%d\n",sum);
}
}
习题 3-2 分子量
给出一种物质的分子式（不带括号），求分子量。本题中的分子式只包含4种原子，分别为C, H, O, N，原子量分别为12.01, 1.008, 16.00, 14.01（单位：g/mol），输入t个分子式，输出分子量，保留三位小数。
输入：
4
C
C6H5OH
NH2CH2COOH
C12H22O11
输出：
12.010
94.108
75.070
342.296
#include <iostream>
#include <string>
using namespace std;
double operate(char c, int n) {
double t = 0;
if (c == 'C') t = 12.01;
if (c == 'H') t = 1.008;
if (c == 'O') t = 16.00;
if (c == 'N') t = 14.01;
return t * n;
}
int main() {
int n;
cin >> n;
while (n--) {
string ss;
cin >> ss;
int len = ss.length();
ss[len] = '\0'; //人工给结尾添加一个结束符，防止后面i+1越界
double mass = 0;
for (int i = 0; i < len+1; i++) {
char c = ss[i];
int sign = 0; //标志数字的位数
int number = 1; //原子数量，初始化为一个
for (; ss[i+1] >= '0' && ss[i+1] <= '9'; i++) {
sign++; //表示数字位数
if (sign == 1) number = ss[i+1] - '0';
else number = number*10 + ss[i+1] - '0'; //若不是为一位数，则叠加
}
mass += operate(c,number);
}
printf("%.3lf\n", mass);
}
return 0;
} 习题3-3 数数字
把前n(n<=10000)个整数顺序写在一起：123456789101112...数一数0~9各出现多少次（输出10个整数，分别是0，1，...，9出现的次数）
样例输入：
2
3
13
样例输出：
0 1 1 1 0 0 0 0 0 0
1 6 2 2 1 1 1 1 1 1
#include<cstdio>
#include<cstring>
#define M 10005
int t,n,sum[20],num,cur;
int main(){
scanf("%d",&n);
while(n--){
scanf("%d",&num);
memset(sum,0,sizeof(sum));
for(int i=1;i<=num;i++){
cur = i;
while(cur>0){
t=cur%10;
sum[t]++;
cur/=10;
}
}
for(int j=0;j<=8;j++)
printf("%d ",sum[j]);
printf("%d ",sum[9]);
printf("\n");
}
}
习题3-4 周期串
如果一个字符可以由某个长度为k的字符串重复多次得到，则称该串以k为周期，例如，abcabcabc以3为周期（注意它也已6和12为周期）
输入一个长度不超过80的字符串，输出其最小周期
分析：我们可以从1为周期开始，对串进行尝试，只要符合所有周期，直接输出即可
样例输入：
1
HoHoHo
样例输出：
2
#include<cstdio>
#define M 85
char str[M];
int n,len,t,buf,ans,i,j,k;
int main(){
scanf("%d",&n);
while(n--){
scanf("%s",str);
len = -1;
while(str[++len]){}
for(i=1;i<len;i++){ //枚举所有可能的周期数
buf=0;
for(j=i;j<len;){ //从下一个周期开始逐个比较
for(k=0;k<i;k++){ //比较每个周期是否相符
if(str[j]==str[k]){ //相符则比较这个周期内的下一个字符
j++;
continue;
}
else{ //不相符，则标记退出
buf=1;break;
}
}
if(buf==1)break;//之前若标记，则尝试下一个周期
}
if(buf==0)break;//若所有周期都能匹配，输出最小周期数
}
if(n!=0)
printf("%d\n\n",i);//这个地方要注意以下，每输出一次就要额外打一个换行，否则PE
else
printf("%d\n",i);//最后一个还不能换行，否则WA
}
}
习题 3-5 谜题
有一个5*5的网格，其中恰好有一个格子是空的，其他格子各有一个字母。一共有4中指令：A,B,L,R,分别把格子上、下、左、右的相邻字母移到空格中。输入初始网格和指令序列（以数字0结束），输出指令执行完毕后的网格。如果有非法指令，应输出“This puzzle has no final configuration.”，例如，如左图执行ARRBBL0后，效果如右图所示。
样例输入：
TRGSJ
XDOKI
M VLN
WPABE
UQHCF
ARRBBL0
ABCDE
FGHIJ
KLMNO
PQRS
TUVWX
AAA
LLLL0
ABCDE
FGHIJ
KLMNO
PQRS
TUVWX
AAAAABBRRRLL0
Z
样例输出：
Puzzle #1:
T R G S J
X O K L I
M D V B N
W P A E
U Q H C F
Puzzle #2:
A B C D
F G H I E
K L M N J
P Q R S O
T U V W X
Puzzle #3:
This puzzle has no final configuration.
分析：本题解题思路很简单，只要按步骤执行就行了。就是输入太扯犊子了，要考虑序列最后一个为空格的情况（输入文件不包含空格，直接回车到下一行。），还有就是操作序列是不连续的，要逐个读字符直到遇到0结束。先是输入调试了半天，后来又遇到一大堆PE。。。无语。最后输入Z结束时不要再有换行，否则PE
#include<stdio.h>
#include<cstring>
#define M 10
char str[M],Map[M][M],t;
int x,y,len,buf,cur,temp;
int main()
{
while(true){
buf = 0;
for(int i=1;i<=5;i++){ //连续输入5行序列
fgets(str,10,stdin);
if(str[0]=='Z'){ //遇到首字母Z结束
return 0;
}
if(str[4]=='\n'){ //特殊情况，当序列最后一个为空格时
str[4]=' '; //输入不会打进去，这个时候要自己填补一下
str[5]='\n';
str[6]='\0';
}
for(int j=1;j<=5;j++){ //检测空格，找到后记录x，y坐标
Map[i][j]=str[j-1];
if(str[j-1]==' '){
x=i,y=j;
}
}
}
len=0;
while((t=getchar())!='0') //读操作序列，直到为0结束
if(t!='\n'){str[len++]=t;}
str[len]='\0';
for(int i=0;i<len;i++){ //根据操作序列，逐步操作四个方向的字母
switch(str[i]){
case 'A':
if(Map[x-1][y]==0){buf=1;break;}//超出方格的操作被视为不合法
Map[x][y]=Map[x-1][y];
Map[x-1][y]=' ';
x-=1;
break;
case 'B':
if(Map[x+1][y]==0){buf=1;break;}
Map[x][y]=Map[x+1][y];
Map[x+1][y]=' ';
x+=1;
break;
case 'L':
if(Map[x][y-1]==0){buf=1;break;}
Map[x][y]=Map[x][y-1];
Map[x][y-1]=' ';
y-=1;
break;
case 'R':
if(Map[x][y+1]==0){buf=1;break;}
Map[x][y]=Map[x][y+1];
Map[x][y+1]=' ';
y+=1;
break;
}
if(buf==1){//若不合法直接结束
break;
}
}
if(temp){printf("\n"),temp=0;}//最后一个不能换行，否则会PE
printf("Puzzle #%d:\n",++cur);
if(buf==1){
printf("This puzzle has no final configuration.\n");
}
else{
for(int i=1;i<=5;i++){
for(int j=1;j<=4;j++)
printf("%c ",Map[i][j]);
printf("%c",Map[i][5]);
printf("\n");
}
}
temp=1;
getchar();
}
}习题 3-6 纵横字谜的答案
输入一个r行c列的网格，黑格用*号表示，每个白格都填有一个字母。如果一个白格的左边相邻位置或者上边相邻位置没有白格（可能是黑格，也可能出了网格边界），则称这个白格是一个起始格。首先把所有起始格从左到右，从上到下顺序编号1，2，3，。。。。要求找出所有横向单词。这些单词必须从一个起始格开始，向右延伸到一个黑格的左边或者整个网格的最右边。最后找出所有的竖向单词。
分析：比上面那个题略难，但输入还是比较友好滴。只需注意最后结束时不要输出换行。基本思路为，先把第一行所有非黑格的纵向都要查找单词，从第二行开始，先看横向每个格左边有没有黑格，有的话遍历单词。再看这个格纵向上边有没有黑格，有的话也要遍历，直到边界或黑格为止。注意每次找单词时还要记录这是第几个单词，最后输出即可。
样例输入
2 2
AT
*O
6 7
AIM*DEN
*ME*ONE
UPON*TO
SO*ERIN
*SA*OR*
IES*DEA
0
样例输出
puzzle #1:
Across
1.AT
3.O
Down
1.A
2.TO
puzzle #2:
Across
1.AIM
4.DEN
7.ME
8.ONE
9.UPON
11.TO
12.SO
13.ERIN
15.SA
17.OR
18.IES
19.DEA
Down
1.A
2.IMPOSE
3.MEO
4.DO
5.ENTIRE
6.NEON
9.US
10.NE
14.ROD
16.AS
18.I
20.A
#include<cstdio>
#include<cstring>
#define M 15
#define M1 105
char str[M],Map[M][M],wordx[M1][M1],wordy[M1][M1];
int t,bt;
void x2word(int num,int x,int y){ //横向记录单词
int i=0;
while((Map[x][y]!='*')&&(Map[x][y]!=0)){
wordx[num][i++]=Map[x][y++];
}
wordx[num][i]='\0';
}
void y2word(int num,int x,int y){ //纵向记录单词
int i=0;
while((Map[x][y]!='*')&&(Map[x][y]!=0)){
wordy[num][i++]=Map[x++][y];
}
wordy[num][i]='\0';
}
int main(){
while(true){
memset(Map,0,sizeof(Map)); //初始化
memset(wordx,0,sizeof(wordx));
memset(wordy,0,sizeof(wordy));
int n=0,m=0,cur=1,curx=0,cury=0,buf=0;//cur用于记录第几个单词
scanf("%d",&n);
if(n==0)return 0; //若n=0则结束
scanf("%d",&m);
for(int i=1;i<=n;i++){
scanf("%s",str);
for(int j=1;j<=m;j++)
Map[i][j]=str[j-1];
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(Map[i][j]!='*'){
if(Map[i][j-1]=='*'||j==1){ //寻找横向单词
x2word(cur++,i,j);
buf=1;
curx++; //记录横向单词数量
}
if((Map[i-1][j]=='*'||i==1)){ //寻找纵向单词
if(buf==1){ //特殊情况：若之前横向标记过一次
//cur的标号纵向与横向相同
y2word(cur-1,i,j);
}
else{ //若之前横向没有标记过，则cur正常
y2word(cur++,i,j);
}
cury++; //记录纵向单词数量
}
}
buf=0;
}
}
if(bt++)printf("\n"); //最后结束时不要输出换行，防止PE
printf("puzzle #%d:\n",++t);
printf("Across\n");
int num=0;
for(int i=1;i<=curx;i++){//输出横向单词
while(!wordx[++num][0]&&num<=cur){}//由于是按标号寻找，所以要不断查找
if(num>9) //小于10的数要多打一个空格
printf(" %d.%s\n",num,wordx[num]);
else
printf(" %d.%s\n",num,wordx[num]);
}
printf("Down\n");
num=0;
for(int j=1;j<=cury;j++){//输出纵向单词
while(!wordy[++num][0]&&num<=cur){}
if(num>9)
printf(" %d.%s\n",num,wordy[num]);
else
printf(" %d.%s\n",num,wordy[num]);
}
}
}习题3-7 DNA序列
输入m个长度均为n的DNA序列，求一个DNA序列，到所有序列的汉明距离尽量小。两个等长字符串的汉明距离等于字符不同的位置个数，例如，ACGT和GCGA的汉明距离为2（左数第1，4个距离不同）
输入整数m和n（4<=m<=50,4<=n<=100）,以及m个长度为n的DNA序列（只包含字母 A,C,G,T），输出到m个序列的汉明距离和最小的DNA序列和对应的距离。如有多解，要求为字典序最小的解。例如，对于下面5个DNA序列最优解为TAAGATAC
TATGATAC
TAAGCTAC
AAAGATCC
TGAGATAC
TAAGATGT
样例输入
3
5 8
TATGATAC
TAAGCTAC
AAAGATCC
TGAGATAC
TAAGATGT
4 10
ACGTACGTAC
CCGTACGTAG
GCGTACGTAT
TCGTACGTAA
6 10
ATGTTACCAT
AAGTTACGAT
AACAAAGCAA
AAGTTACCTT
AAGTTACCAA
TACTTACCAA
样例输出
TAAGATAC
7
ACGTACGTAA
6
AAGTTACCAA
12
分析：对于每一列，需要找出该列出现次数最多的字符，并记录其出现的次数，最后用总字符个数减去每一列的最大出现次数，得到Hamming距离
#include<cstdio>
#include<cstring>
int main( ){
int t;
scanf("%d",&t);
while(t--){
int n,m;
scanf("%d %d",&n,&m);
char DNA[n][m+1];
for(int i=0;i<n;i++) scanf("%s",DNA[i]);
int list[4];
int num=0,num1;
for(int i=0;i<m;i++){
memset(list,0,sizeof(list));
for(int j=0;j<n;j++){
if(DNA[j][i]=='A') list[0]++;
else if(DNA[j][i]=='C') list[1]++;
else if(DNA[j][i]=='G') list[2]++;
else list[3]++;
}
int temp=0,ans;
for(int k=0;k<4;k++){
if(list[k]>temp) {
ans=k;
temp=list[k];
num1=n-list[k];
}
}
if(ans==0) printf("A");
else if(ans==1) printf("C");
else if(ans==2) printf("G");
else printf("T");
num+=num1;
}
printf("\n%d\n",num);
}
return 0;
}习题3-8 循环小数
输入整数a和b（0<=a<=3000,1<=b<=3000）,输入a/b的循环小数表示以及循环长度。例如a=5，b=43，小数表示为0.（116279069767441860465），循环节长度为21.
样例输入：
76 25
5 43
1 397
样例输出：
76/25 = 3.04(0)
1 = number of digits in repeating cycle
5/43 = 0.(116279069767441860465)
21 = number of digits in repeating cycle
1/397 = 0.(00251889168765743073047858942065491183879093198992...)
99 = number of digits in repeating cycle
分析：本题一开始可能不是太有思路，但仔细想一想可以得出这样一个结论：如果通过几次被除数除以除数后得到余数，再用余数除以除数得到第二个余数。反复这样后若某一次得到的等于前面某一次得到的余数的话，那么这个余数肯定会重复之前那个余数到这个余数之间的操作。
例如 11/13=0.846153846153846153....
110/13=8......6 第一步
60/13 =4......8
80/13 =6......2
20/13 =1......7
70/13 =5......5
50/13 =3......11
110/13 =8......6 与第一次的余数相同，所以这里将重复执行第一步。这一件的商即为一个循环节
所以我们只要检测是否遇到重复余数，即可可判断是否为循环节。
#include<cstdio>
#include<cstring>
#define M 100005
int a,b,c,cur,t;
int num[M],vis[M];//num用于记录除法的所有商，vis用于记录余数
int main(){
while(scanf("%d %d",&a,&b)!=EOF){
memset(num,0,sizeof(num));//初始化
memset(vis,0,sizeof(vis));
c=a%b;
c*=10;
cur=1; //题目保证不存在不循环小数，不必担心
while(!vis[c]){//如果遇到重复余数，即发现循环节，结束
num[cur]=c/b; //记录每次相除的商
vis[c]=cur++; //记录余数的位置
c%=b; //准备下一次除法操作
c*=10;
}
t=vis[c]; //找到循环节后，记录循环节开始位置
printf("%d/%d = %d.",a,b,a/b);//输出整数部分
for(int i=1;i<t;i++)//输出前面不是循环节的位置
printf("%d",num[i]);
printf("(");
if(cur-t<=50){
for(int i=t;i<cur;i++)
printf("%d",num[i]);//从循环开始位置到结束位置输出
}
else{
for(int i=t;i<t+50;i++)
printf("%d",num[i]);//对于大于50的循环节只输出50个
printf("...");
}
printf(")\n %d = number of digits in repeating cycle\n\n",cur-t);
//输出循环节长度
}
}
习题 3-9 子序列
输入量的字符串s和t，判断是否可以从t中删除0个或多个字符（其他字符顺序不变），得到字符串s，例如abcde可以得到bce，但无法得到dc
样例输入：
sequence subsequence
person compression
VERDI vivaVittorioEmanueleReDiItalia
caseDoesMatter CaseDoesMatter
样例输出：
Yes
No
Yes
No
分析：大水题，直接放代码
#include<cstdio>
#define M 1000005
char stra[M],strb[M];
int lena,lenb,i,j,buf;
int main(){
while(scanf("%s %s",stra,strb)!=EOF){
lena=-1,lenb=-1;
while(stra[++lena]){}
while(strb[++lenb]){}
j=0;
for(i=0;i<lena;i++){
buf=0;
for(;j<lenb;j++){
if(stra[i]==strb[j]){
j++;
buf=1;
break;buf=1;
}
}
}
if(buf) printf("Yes\n");
else printf("No\n");
}
}
习题3-10 盒子
给出6个矩形的长和宽wi和hi（1<=wi,hi<=100）,判断他们是否能构成长方体的六个面
样例输入
1345 2584
2584 683
2584 1345
683 1345
683 1345
2584 683
1234 4567
1234 4567
4567 4321
4322 4567
4321 1234
4321 1234
样例输出
POSSIBLE
IMPOSSIBLE
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct rectangle{
int x,y;
}r[6];
bool cmp(rectangle a,rectangle b){
return a.x!=b.x? a.x<b.x:a.y>b.y;
}
int main(){
int buf;
while(scanf("%d %d",&r[1].x,&r[1].y)!=EOF){
for(int i=2;i<=6;i++){
scanf("%d %d",&r[i].x,&r[i].y);
}
for(int i=1;i<=6;i++){
if(r[i].x>r[i].y)
swap(r[i].x,r[i].y);
}
sort(r+1,r+7,cmp);
buf=0;
if((r[1].x!=r[2].x)||(r[1].y!=r[2].y)||(r[3].x!=r[4].x)||(r[3].y!=r[4].y)||(r[5].x!=r[6].x)||(r[5].y!=r[6].y)){
buf=1;
}
if((r[1].x!=r[3].x)||(r[1].y!=r[5].y)||(r[3].y!=r[5].x)){
buf=1;
}
if(!buf)printf("POSSIBLE\n");
else printf("IMPOSSIBLE\n");
}
}习题3-11
给出两个长度分别为n1,n2(n1,n2<=100)且每列高度只为1或2的长条，需要将他们放入一个高度为3的容器（如下图所示），问能够容纳他们的最短容器长度
样例输入：
2112112112
2212112
12121212
21212121
2211221122
21212
样例输出：
10
8
15
分析：本题本质还是字符串比较，可以先从A的一个位置开始进行大循环，在每次大循环中再来一个B的小循环，在每次小循环中比较A与B对应位置的字符。如果某两个位置字符都为2的话，这种情况就不成立，跳出小循环。考虑下一种情况，求出最佳匹配。注意，现在只考虑了一个方向，还要换方向考虑。最终即可求得最短容器长度。
#include<cstdio>
#include<cstring>
#define M 205
char stra[M],strb[M];
int lena,lenb,pos,i,j,num,t;
bool flaga,flagb;
int main(){
while(scanf("%s\n%s",stra,strb)!=EOF){
lena=0,lenb=0,pos=0,num=M;
flaga = false,flagb = false;
while(stra[++lena]){}
while(strb[++lenb]){}
pos = lena<=lenb?lena:lenb;//以只要最小的那一个能够跟另一个匹配就可以
for(i=0;i<lena;i++){ //先以一个方向匹配
t=i;
for(j=0;j<pos;j++){
if(stra[t]=='2'&&strb[j]=='2')//如果两个高度都是2是不能匹配的
break;
t++;
}
if(j==pos){ //如果其中最小的一个已经全部匹配了，就根据位置取最小值
flaga=true;
if(i+lenb<lena){
num=lena;
}
else{
num=i+lenb;
}
break;
}
}
for(i=0;i<lenb;i++){//换另一个方向匹配，看有没有更小的情况
t=i;
for(j=0;j<pos;j++){
if(strb[t]=='2'&&stra[j]=='2')
break;
t++;
}
if(j==pos){//如果存在的话，还要跟之前的情况比较一下看谁最小
flagb=true;
if(i+lena<lenb&&i+lena<num){
num=lenb;
}
else if(i+lena<num){
num=i+lena;
}
break;
}
}
if(flaga==false&&flagb==false) num = lena + lenb;//如果都不能匹配，那就是最坏情况
printf("%d\n",num);
memset(stra,0,sizeof(stra));
memset(strb,0,sizeof(strb));
}
}习题3-12 浮点数
计算机常用阶码-尾数的方法保存浮点数。如下图所示，如果阶码有6位，位数有8位，可以表达的最大浮点数为
。注意小数点后一位必须为1，所以一共有9位小数。
这个数换算成十进制之后就是 
你的任务是根据这个最大浮点数，求出阶码的位数E和位数的位数M。输入格式为AeB，表示最大浮点数为 
.
，并且恰好包含15位有效数字。输入结束标志为0e0。对于每组数据，输出M和E。输入保证有唯一解，且
。在本题中，M+E+2不必为8的整数倍
分析：
换算公式为 
(A,B为10进制，C,D为2进制)
其中 ，我们可以打表列举这270（9*30）种情况与输入结果比对，当误差足够小时，我们即可输出对应的C,D.注意，而且是浮点数，容易超范围，所以要对十进制和二进制取一下对数。
取对数后的换算公式为： 
输入的A、B跟打好的表进行比对即可
#include<cstdio>
#include<cstring>
#include<cmath>
#define M 50
double e,m,num;
double Map[15][35];
int d,len;
char str[M];
bool flag;
int main(){
for(int i=0;i<=9;i++){//打表
for(int j=1;j<=30;j++){
m = 1 - pow(2,-1-i);
e = pow(2,j)-1;
Map[i][j] = log10(m) + e * log10(2.0);
}
}
while(scanf("%s",str)){
len=0;
flag = false;
while(str[++len]!='e'){}
str[len] = ' ';//格式化以下
sscanf(str,"%lf %d",&m,&d);//分离尾数和阶码
if(m==0&&d==0)break;
num = log10(m) + d;//将输入的尾数和阶码对数化
for(int i=0;i<=9;i++){//按表比对
for(int j=1;j<=30;j++){
if(fabs(Map[i][j]-num)<1e-5){//当误差足够小输出即可
printf("%d %d\n",i,j);
flag = true;
break;
}
}
if(flag)break;
}
}
}
847
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
