1.2n皇后问题(qdulq) (40分)
给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。
输入格式:
输入的第一行为一个整数n，表示棋盘的大小。 接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，如果一个整数为0，表示对应的位置不可以放皇后。
输出格式:
输出一个整数，表示总共有多少种放法。
输入样例1:
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
输出样例1:
2
输入样例2:
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1
输出样例2:
0#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
using namespace std;
int chess[9][9];//棋盘
int wqueen[9];//白皇后放置情况
int bqueen[9];//黑皇后放置情况
int n,count;
int check(int array[],int row,int col){
if(!chess[row][col])
return 0;
for(int i=1;i<row;i++){
if(array[i]==col||abs(array[i]-col)==row-i)
return 0;
}
return 1;
}
void wdfs(int row){//白皇后搜索
if(row==n+1){//白皇后搜到n+1行，可行放置数增加
count++;
return;
}
for(int i=1;i<=n;i++){
if(i==bqueen[row])//此位置已放置黑皇后
continue;
if(check(wqueen,row,i)){
wqueen[row]=i;
wdfs(row+1);
}
}
}
void bdfs(int row){//先黑皇后搜索
if(row==n+1){//黑皇后搜索结束，搜索白皇后
wdfs(1);
return;
}
for(int i=1;i<=n;i++){
if(check(bqueen,row,i)){
bqueen[row]=i;
bdfs(row+1);
}
}
}
int main(){
cin>>n;
count=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
scanf("%d",&chess[i][j]);
}
}
bdfs(1);
cout<<count<<endl;
return 0;
}
2.FJ的字符串(qdulq) (40分)
FJ在沙盘上写了这样一些字符串： A1 = “A” A2 = “ABA” A3 = “ABACABA” A4 = “ABACABADABACABA” … … 你能找出其中的规律并写所有的数列AN吗？
输入格式:
仅有一个数：N ≤ 26。
输出格式:
请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
输入样例:
3
输出样例:
ABACABA#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
char a[30]={"AABCDEFGHIJKLMNOPQRSTUVWXYZ"};
void FJ(int n){
if(n==0)
return;
FJ(n-1);
printf("%c",a[n]);
FJ(n-1);
}
int main(){
int n;
cin>>n;
FJ(n);
cout<<endl;
return 0;
}
3.Huffuman树(qdulq) (40分)
Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
给出一列数{pi}={p0, p1, …, pn-1}，
用这列数构造Huffman树的过程如下：
1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
2. 重复步骤1，直到{pi}中只剩下一个数。
在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。 本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。
例如，对于数列{pi}={5, 3, 8, 2, 9}，Huffman树的构造过程如下：
1. 找到{5, 3, 8, 2, 9}中最小的两个数，分别是2和3，从{pi}中删除它们并将和5加入，得到{5, 8, 9, 5}，费用为5。
2. 找到{5, 8, 9, 5}中最小的两个数，分别是5和5，从{pi}中删除它们并将和10加入，得到{8, 9, 10}，费用为10。
3. 找到{8, 9, 10}中最小的两个数，分别是8和9，从{pi}中删除它们并将和17加入，得到{10, 17}，费用为17。
4. 找到{10, 17}中最小的两个数，分别是10和17，从{pi}中删除它们并将和27加入，得到{27}，费用为27。
5. 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。
输入格式:
输入的第一行包含一个正整数n（n<=100）。
接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。
输出格式:
输出用这些数构造Huffman树的总费用。
输入样例:
5
5 3 8 2 9
输出样例:
59//敲哈夫曼树繁琐，竞赛时不如利用好C++ STL
#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
using namespace std;
struct cmp{
bool operator ()(int a,int b){
return a>b;
}
};
int main(){
int n,num,cost=0;
int t1,t2;
priority_queue <int,vector<int>,cmp> data;
cin>>n;
for(int i=1;i<=n;i++){
scanf("%d",&num);
data.push(num);
}
while(1){
t1=data.top();
data.pop();
if(data.empty()){
cout<<cost<<endl;
break;
}
t2=data.top();
data.pop();
data.push(t1+t2);
cost+=t1+t2;
}
return 0;
}
最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。
不妨设
An=sin(1–sin(2+sin(3–sin(4+...sin(n))...)
Sn=(...(A1+n)A2+n-1)A3+...+2)An+1
FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。
输入格式:
仅有一个数：N<201。
输出格式:
请输出相应的表达式Sn，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
输入样例:
3
输出样例:
((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int N;
void An(int n){//An的递归式不容易找，直接用非递归做简单易懂
for(int i=1;i<=n;i++){
printf("%s%d","sin(",i);
if(i!=n){
if(i%2==1)
printf("%c",'-');
else
printf("%c",'+');
}
}
for(int j=1;j<=n;j++)
printf("%c",')');
}
void S(int n){//Sn的递归式比较明显
if(n==1){//递归出口
An(1);
printf("%c%d",'+',N);
return;
}
else{
printf("%c",'(');
S(n-1);
printf("%c",')');
An(n);
printf("%c%d",'+',N+1-n);
}
}
int main(){
cin>>N;
S(N);
return 0;
}
给定当前的时间，请用英文的读法将它读出来。
时间用时h和分m表示，在英文的读法中，读一个时间的方法是：
如果m为0，则将时读出来，然后加上“o'clock”，如3:00读作“three o'clock”。
如果m不为0，则将时读出来，然后将分读出来，如5:30读作“five thirty”。
时和分的读法使用的是英文数字的读法，其中0~20读作：
0:zero, 1: one, 2:two, 3:three, 4:four, 5:five, 6:six, 7:seven, 8:eight, 9:nine, 10:ten, 11:eleven, 12:twelve, 13:thirteen, 14:fourteen, 15:fifteen, 16:sixteen, 17:seventeen, 18:eighteen, 19:nineteen, 20:twenty。
30读作thirty，40读作forty，50读作fifty。
对于大于20小于60的数字，首先读整十的数，然后再加上个位数。如31首先读30再加1的读法，读作“thirty one”。
按上面的规则21:54读作“twenty one fifty four”，9:07读作“nine seven”，0:15读作“zero fifteen”。
输入格式:
输入包含两个非负整数h和m，表示时间的时和分。非零的数字前没有前导0。h小于24，m小于60。
输出格式:
输出时间时刻的英文。
输入样例:
0 15
输出样例:
zero fifteen
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char *t[24]={"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty","thirty","forty","fifty"};
void GetHour(int hour){
if(hour<=20)
printf("%s",t[hour]);
else{
printf("%s",t[18+hour/10]);
if(hour%10)
printf(" %s",t[hour%10]);
}
}
void GetMinute(int minute){
if(minute==0)
printf("%s","o'clock");
else if(minute<=20)
printf("%s",t[minute]);
else{
printf("%s",t[18+minute/10]);
if(minute%10)
printf(" %s",t[minute%10]);
}
}
int main(){
int hour,minute;
scanf("%d%d",&hour,&minute);
GetHour(hour);
putchar(' ');
GetMinute(minute);
return 0;
}
求出区间[a,b]中所有整数的质因数分解。
提示
先筛出所有素数，然后再分解。
数据规模和约定
2<=a<=b<=10000
输入格式:
输入两个整数a，b。
输出格式:
每行输出一个数的分解，形如k=a1a2a3...(a1<=a2<=a3...，k也是从小到大的)(具体可看样例)
输入样例:
3 10
输出样例:
3=3
4=2*2
5=5
6=2*3
7=7
8=2*2*2
9=3*3
10=2*5
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main(){
int a,b;
bool book[10001];
book[0]=book[1]=false;
for(int i=2;i<=10000;i++)
book[i]=true;
for(int i=2;i<=5000;i++){
if(book[i]==true){
for(int j=i+i;j<=10000;j+=i)
book[j]=false;
}
}
cin>>a>>b;
for(int i=a;i<=b;i++){
int flag=1,t=i;
cout<<i<<'=';
for(int j=2;j<=i;j++){
if(book[j]==true){
while(t%j==0){
if(flag){
printf("%d",j);
flag=0;
}
else
printf("*%d",j);
t/=j;
}
}
}
cout<<endl;
}
return 0;
}
#include <cstdio>
#include <iostream>
using namespace std;
int main(){
int a,b,num,flag;
cin>>a>>b;
for(int i=a;i<=b;i++){
flag=0;
num=i;
cout<<num<<'=';
for(int j=2;num>1;j++){
while(num>1&&num%j==0){
if(flag){
cout<<'*';
}
cout<<j;
num/=j;
flag=1;
}
}
cout<<endl;
}
return 0;
}
输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。
算法描述
由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。
定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。
计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加，这时还应将低位进上来的值r也加起来，即C[1]应该是A[1]、B[1]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C[1]中。依此类推，即可求出C的所有位。
最后将C输出即可。
输入格式:
输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。
输出格式:
输出一行，表示a + b的值。
输入样例:
20100122201001221234567890
2010012220100122
输出样例:
20100122203011233454668012
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
void Reverse(char *a){
int i,top;
char temp[105];
for(i=strlen(a)-1,top=0;i>=0;i--,top++)
temp[top]=a[i];
temp[top]='\0';
strcpy(a,temp);
}
void Add(char *s,int *top,char *a,int temp){
int sum;
for(int i=*top+1;a[i];i++){
sum=(a[i]-'0')+temp;
s[++(*top)]=sum%10+'0';
temp=sum/10;
}
while(temp){
s[++(*top)]=temp%10+'0';
temp/=10;
}
s[++(*top)]='\0';
}
int main(){
int sum,top=-1,temp=0;
char a[105],b[105],s[105];
scanf("%s%s",a,b);
Reverse(a);
Reverse(b);
for(int i=0,j=0;a[i]&&b[j];i++,j++){
sum=(a[i]-'0')+(b[j]-'0')+temp;
s[++top]=sum%10+'0';
temp=sum/10;
}
if(strlen(a)>=strlen(b))
Add(s,&top,a,temp);
else
Add(s,&top,b,temp);
for(int i=top-1;i>=0;i--)
printf("%c",s[i]);
cout<<endl;
return 0;
}
话说这个世界上有各种各样的兔子和乌龟，但是 研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。
于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔 子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以 上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。
然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1 米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找 到了你请求帮助，
请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果。
输入格式:
输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，其中(v1,v2<=100;t<=300;s<=10;l<=10000且为v1,v2的公倍数)。
输出格式:
输出包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。
第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。
输入样例1:
10 5 5 2 20
输出样例1:
D
4
输入样例2:
10 5 5 1 20
输出样例2:
R
3
输入样例3:
10 5 5 3 20
输出样例3:
T
4
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main(){
int v1,v2,t,s,len;
int d1=0,d2=0;
cin>>v1>>v2>>t>>s>>len;
for(int i=1;i<=len/v2;i++){
d1+=v1;
d2+=v2;
if(d1==len&&d2<len){
printf("R\n%d\n",i);
break;
}
else if(d2==len&&d1<len){
printf("T\n%d\n",i);
break;
}
else if(d1==len&&d2==len){
printf("D\n%d\n",i);
break;
}
else if(d1-d2>=t){
if(i+s>=len/v2){
printf("T\n%d\n",len/v2);
break;
}
else{
d2=d2+v2*s;
i+=s;
}
}
}
return 0;
}
回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转90度。一开始位于矩阵左上角，方向向下。
输入格式:
输入第一行是两个不超过200的正整数m, n，表示矩阵的行和列。接下来m行每行n个整数，表示这个矩阵。
输出格式:
输出只有一行，共mn个数，为输入矩阵回形取数得到的结果。数之间用一个空格分隔，行末不要有多余的空格。
输入样例1:
3 3
1 2 3
4 5 6
7 8 9
输出样例1:
1 4 7 8 9 6 3 2 5
输入样例2:
3 2
1 2
3 4
5 6
输出样例2:
1 3 5 6 4 2
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main(){
int m,n;
int count,x,y;
int matrix[200][200],book[200][200];
cin>>m>>n;
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
cin>>matrix[i][j];
}
}
memset(book,0,sizeof(book));
count=1;
x=y=0;
book[0][0]=1;
printf("%d",matrix[0][0]);
while(count<m*n){
while(x+1<m&&!book[x+1][y]){
count++;
book[x+1][y]=1;
printf(" %d",matrix[++x][y]);
}
while(y+1<n&&!book[x][y+1]){
count++;
book[x][y+1]=1;
printf(" %d",matrix[x][++y]);
}
while(x-1>=0&&!book[x-1][y]){
count++;
book[x-1][y]=1;
printf(" %d",matrix[--x][y]);
}
while(y-1>=0&&!book[x][y-1]){
count++;
book[x][y-1]=1;
printf(" %d",matrix[x][--y]);
}
}
return 0;
}
输入一个正整数n，输出n!的值。
其中n!=123…n。
算法描述
n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。
输入格式:
输入包含一个正整数n，n<=1000。
输出格式:
输出n!的准确值。
输入样例:
10
输出样例:
3628800
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main(){
int n,top=0;
char result[10000];
result[0]='1';
cin>>n;
for(int i=2;i<=n;i++){
int temp=0;
for(int j=0;j<=top;j++){
int p=i*(result[j]-'0')+temp;
result[j]=p%10+'0';
temp=p/10;
}
while(temp){
result[++top]=temp%10+'0';
temp/=10;
}
}
for(int i=top;i>=0;i--)
printf("%c",result[i]);
cout<<endl;
return 0;
}
平面上有两个矩形，它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形，我们给出它的一对相对顶点的坐标，请你编程算出两个矩形的交的面积。
输入格式:
输入仅包含两行，每行描述一个矩形。
在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。
输出格式:
输出仅包含一个实数，为交的面积，保留到小数后两位。
输入样例:
1 1 3 3
2 2 4 4
输出样例:
1.00
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main(){
double x11,y11,x12,y12;//矩阵1
double x21,y21,x22,y22;//矩阵2
double left,right,up,down;
double max,min;
cin>>x11>>y11>>x12>>y12;
cin>>x21>>y21>>x22>>y22;
//左大
left=x11<x12?x11:x12;
min=x21<x22?x21:x22;
left=left>min?left:min;
//右小
right=x11>x12?x11:x12;
max=x21>x22?x21:x22;
right=right<max?right:max;
//上小
up=y11>y12?y11:y12;
max=y21>y22?y21:y22;
up=up<max?up:max;
//下大
down=y11<y12?y11:y12;
min=y21<y22?y21:y22;
down=down>min?down:min;
//交为空
if(left>=right||up<=down)
printf("%.2f\n",0.0);
else
printf("%.2f\n",(right-left)*(up-down));
return 0;
}
给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
例如：
A =
1 2
3 4
A的2次幂
7 10
15 22
输入格式:
第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数
接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值
输出格式:
输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开
输入样例:
2 2
1 2
3 4
输出样例:
7 10
15 22
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
struct matrix{
int mat[31][31];
};
int n,m;
struct matrix Mul(struct matrix a,struct matrix b){
struct matrix e;
memset(e.mat,0,sizeof(e.mat));
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(a.mat[i][j]){
for(int t=1;t<=n;t++)
e.mat[i][t]+=a.mat[i][j]*b.mat[j][t];
}
}
}
return e;
}
struct matrix Expo(struct matrix a,int m){
struct matrix e;
if(m==1)
return a;
memset(e.mat,0,sizeof(e.mat));
for(int i=1;i<=n;i++)
e.mat[i][i]=1;
if(m==0)
return e;
while(m){
if(m&1)
e=Mul(a,e);
a=Mul(a,a);
m=m>>1;
}
return e;
}
int main(){
struct matrix a,b;
while(scanf("%d%d",&n,&m)!=EOF){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
scanf("%d",&a.mat[i][j]);
}
}
b=Expo(a,m);
for(int i=1;i<=n;i++){//格式坑笔
for(int j=1;j<=n;j++)
printf("%d ",b.mat[i][j]);
cout<<endl;
}
}
return 0;
}
13.时间转换(qdulq-java) (40分)
给定一个以秒为单位的时间t，要求用 “::”的格式来表示这个时间。表示时间，表示分钟， 而表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。
输入格式:
输入只有一行，是一个整数t（0<=t<=86399）。
输出格式:
输出只有一行，是以“::”的格式所表示的时间，不包括引号。
输入样例1:
0
输出样例1:
0:0:0
输入样例2:
5436
输出样例2:
1:30:36#include <cstdio>
#include <iostream>
using namespace std;
int main(){
int t;
int hour,minute,second;
cin>>t;
hour=t/3600;
minute=t%3600/60;
second=t%60;
cout<<hour<<':'<<minute<<':'<<second<<endl;
return 0;
}
Tom教授正在给研究生讲授一门关于基因的课程，有一件事情让他颇为头疼：一条染色体上有成千上万个碱基对，它们从0开始编号，到几百万，几千万，甚至上亿。
比如说，在对学生讲解第1234567009号位置上的碱基时，光看着数字是很难准确的念出来的。
所以，他迫切地需要一个系统，然后当他输入12 3456 7009时，会给出相应的念法：
十二亿三千四百五十六万七千零九
用汉语拼音表示为
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
这样他只需要照着念就可以了。
你的任务是帮他设计这样一个系统：给定一个阿拉伯数字串，你帮他按照中文读写的规范转为汉语拼音字串，相邻的两个音节用一个空格符格开。
注意必须严格按照规范，比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”读作“shi wan”而不是“yi shi wan”，“2000”读作“er qian”而不是“liang qian”。
输入格式:
有一个数字串，数值大小不超过2,000,000,000。
输出格式:
是一个由小写英文字母，逗号和空格组成的字符串，表示该数的英文读法。
输入样例:
1234567009
输出样例:
shi er yi san qian si bai wu shi liu wan qi qian ling jiu
#include <cstdio>
#include <cstring>
#include <vector>
#include <iostream>
using namespace std;
int main(){
string number[]={"ling","yi","er","san","si","wu","liu","qi","ba","jiu"};
string dight[]={"","shi","bai","qian","wan","shi","bai","qian","yi","shi"};
string data;
vector<string> result;//存储结果序列
cin>>data;//原始数据
int len=data.size();
for(int i=0;i<len;i++){
if(data[i]!='0'){
if(data[i]=='1'&&(len-i-1==5||len-i-1==9))//...一十万,...一十亿 这样打印不对
result.push_back(dight[len-i-1]);
else if(i!=len-1){
result.push_back(number[data[i]-'0']);
result.push_back(dight[len-i-1]);
}
else
result.push_back(number[data[i]-'0']);
}
else{
if(len-i-1==8)//当数字能到亿位且亿位是零，说明十亿位必不为零 yi还是得打印
result.push_back(dight[len-i-1]);
else if(len-i-1==4){//当数字能到万位且万位是零
if(len<9||data.compare(i-3,3,"000")>0)//当不到亿位 或者到了亿位且千万，百万，十万位不全为零 打印
result.push_back(dight[len-i-1]);
}
else if(i+1<len&&data[i+1]!='0')//普通的是零
result.push_back("ling");
}
}
for(int i=0;i<result.size();i++)
cout<<result[i]<<(i==result.size()-1?'\n':' ');
return 0;
}
//注意：当个位为零，不加入打印序列，这点最外面的else处理好了。
//但当个位不为零，要注意，虽空字符串不打印，但不可把dight中个位对应的空字符串加入vector数组，这样vector的size也会增加
//最后打印数据时，会造成最后有一个空格加一个回车，导致格式错误
15.完美的代价(qdulq) (40分)
回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
交换的定义是：交换两个相邻的字符
例如mamad
第一次交换 ad : mamda
第二次交换 md : madma
第三次交换 ma : madam (回文！完美！)
输入格式:
第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
第二行是一个字符串，长度为N.只包含小写字母
输出格式:
如果可能，输出最少的交换次数。
否则输出Impossible
输入样例:
5
mamad#include <stdio.h>
#include <stdlib.h>
int main(){
int i,j,t;
int n,end,count=0,sum=0;
char a[8005];
scanf("%d%s",&n,a);
end=n-1;//当前 字符串处理部分 末尾
for(i=0;i<end;i++){
for(j=end;j>i;j--){
if(a[j]==a[i]){
for(t=j;t<end;t++)
a[t]=a[t+1];
a[end]=a[i];
sum=sum+end-j;
end--;
break;
}
}
if(j==i){
count++;
if(n%2==0||count>1){
printf("Impossible\n");
return 0;
}
//到这里，若字符串可回文，则找到了中点字符a[i]
//但不去把a[i]换到中间来
sum+=n/2-i;
}
}
printf("%d\n",sum);
return 0;
}
//总结：假设字符串可回文：
//以n为奇数为例，因为第一步中 从左到右处理 完全适用于n为偶数
//第一步：从左到右处理，对于每个字符，从end位置向左找第一个与之相等的，配对（此步的正确性可证，贪心算法） 直到遇到中点字符（单独而不配对的一个字符，最后回文完位于中间位置）
//第二步：先不着急把中点字符换过去，而是先去处理剩余部分
//因为找到的中点字符会移动到中间是肯定的且步数是一定的，只是何时移动的问题，而可证，按照错误代码，找到中间字符就移动会出现错误
//换个思路找解决方式，其实就相当于剩余部分为一个偶字符串，处理完，把中点字符插入中间 剩余部分这样处理能保证最小值的正确性 建立在上一个正确性可证
//
//按照错误代码，找到中间字符就移动会出现错误 举例：
//比如此时：aa c ddee aa
//按照正确代码，处理ddee子串
//而按照错误代码，此时交换:aa ddcee aa 再去处理后 aa dceed aa,中间字符c移动了！！！错误代码错在不能保证中间字符移完在中间不动
/*
错误代码：
#include <cstdio>
#include <iostream>
using namespace std;
int main(){
int i,j;
int n,count=0,sum=0;
char data[8005],temp;
cin>>n;
scanf("%s",data);
int end=n%2==0?(n-1)/2:n/2-1;
for(i=0;i<=end;i++){
for(j=n-i-1;j>i;j--){
if(data[i]==data[j]){
temp=data[j];
for(int t=j;t<n-i-1;t++)
data[t]=data[t+1];
data[n-i-1]=temp;
sum+=(n-i-j-1);
break;
}
}
if(j==i){
count++;
if(n%2==0||count>1){
cout<<"Impossible"<<endl;
return 0;
}
temp=data[i];
for(int t=i;t<n/2;t++)
data[t]=data[t+1];
data[n/2]=temp;
sum+=(n/2-i);
printf("%d %d\n",sum,i);
puts(data);
i--;
}
}
cout<<sum<<endl;
return 0;
}
*/
有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。
每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。
给出所有芯片的测试结果，问哪些芯片是好芯片。
输入格式:
输入数据第一行为一个整数n，表示芯片个数。
第二行到第n+1行为n*n的一张表，每行n个数据。表中的每个数据为0或1，在这n行中的第i行第j列（1≤i, j≤n）的数据表示用第i块芯片测试第j块芯片时得到的测试结果，1表示好，0表示坏，i=j时一律为1（并不表示该芯片对本身的测试结果。芯片不能对本 身进行测试）。
输出格式:
按从小到大的顺序输出所有好芯片的编号。
输入样例:
3
1 0 1
0 1 0
1 0 1
输出样例:
1 3
//思路题，由于好芯片比坏芯片多，因此若是好芯片，测试出的其为好芯片的结果肯定大于半数
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main(){
int n,flag,top=-1;
int test[25][25],s[25];
cin>>n;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
cin>>test[i][j];
}
}
for(int i=1;i<=n;i++){
int count=0;
for(int j=1;j<=n;j++)
if(test[j][i])
count++;
if(count>n/2)
s[++top]=i;
}
for(int i=0;i<=top;i++)
printf("%d%c",s[i],i==top?'\n':' ');
return 0;
}
给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
1：两个字符串长度不等。比如 Beijing 和 Hebei
2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。
输入格式:
包括两行，每行都是一个字符串。
输出格式:
仅有一个数字，表明这两个字符串的关系编号。
输入样例:
BEIjing
beiJing
输出样例:
3
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int Ignore(char *a,char *b){
for(int i=0;a[i]&&b[i];i++)
if(tolower(a[i])!=tolower(b[i]))
return 0;
return 1;
}
int main(){
char a[1000],b[1000];
gets(a);
gets(b);
if(strlen(a)!=strlen(b))
cout<<1<<endl;
else if(strcmp(a,b)==0)
cout<<2<<endl;
else if(Ignore(a,b))
cout<<3<<endl;
else
cout<<4<<endl;
return 0;
}
5793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
