蓝桥杯练习系统算法训练问题详解Java.docx

上传人:b****5 文档编号:14911752 上传时间:2023-06-28 格式:DOCX 页数:76 大小:29.63KB
下载 相关 举报
蓝桥杯练习系统算法训练问题详解Java.docx_第1页
第1页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第2页
第2页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第3页
第3页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第4页
第4页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第5页
第5页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第6页
第6页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第7页
第7页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第8页
第8页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第9页
第9页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第10页
第10页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第11页
第11页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第12页
第12页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第13页
第13页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第14页
第14页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第15页
第15页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第16页
第16页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第17页
第17页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第18页
第18页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第19页
第19页 / 共76页
蓝桥杯练习系统算法训练问题详解Java.docx_第20页
第20页 / 共76页
亲,该文档总共76页,到这儿已超出免费预览范围,如果喜欢就下载吧!
下载资源
资源描述

蓝桥杯练习系统算法训练问题详解Java.docx

《蓝桥杯练习系统算法训练问题详解Java.docx》由会员分享,可在线阅读,更多相关《蓝桥杯练习系统算法训练问题详解Java.docx(76页珍藏版)》请在冰点文库上搜索。

蓝桥杯练习系统算法训练问题详解Java.docx

蓝桥杯练习系统算法训练问题详解Java

ALGO-9

importjava.io.*;

publicclassMain{

publicstaticvoidmain(Stringargs[])throwsIOException{

BufferedReaderbf=newBufferedReader(newInputStreamReader(System.in));

intn=Integer.parseInt(bf.readLine());

System.out.println((int)(Math.pow(2,n)-n-1)*2);

}

}

10

importjava.io.*;

importjava.util.Arrays;

importjava.util.HashSet;

importjava.util.Iterator;

importjava.util.Set;

publicclassMain{

publicstaticvoidmain(String[]args)throwsIOException{

BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));

intn=Integer.parseInt(br.readLine());

int[]arr=newint[n];

Stringst[]=br.readLine().split("");

for(inta=0;a

arr[a]=Integer.parseInt(st[a]);

}

Arrays.sort(arr);

intm=Integer.parseInt(br.readLine());

int[]tag=newint[m];

Stringstr[]=br.readLine().split("");

for(inta=0;a

tag[a]=Integer.parseInt(str[a]);

}

Arrays.sort(tag);

func(arr,tag);

}

publicstaticvoidfunc(int[]arr,int[]tag){

intx;

for(inta=0;a

x=Arrays.binarySearch(tag,arr[a]);

if(x>=0){

System.out.print(arr[a]+"");

}

}

System.out.println();

Setset=newHashSet();

for(inta=0;a

set.add(arr[a]);

}

for(inta=0;a

set.add(tag[a]);

}

int[]sor=newint[set.size()];

Iteratorit=set.iterator();

while(it.hasNext()){

for(inta=0;a

sor[a]=it.next();

}

}

Arrays.sort(sor);

for(inta=0;a

System.out.print(sor[a]+"");

}

System.out.println();

inty;

for(inta=0;a

y=Arrays.binarySearch(tag,arr[a]);

if(y<0){

System.out.print(arr[a]+"");

}

}

System.out.println();

}

}

11

importjava.util.Scanner;

publicclassMain

{

publicstaticvoidmain(String[]args)

{

Scannerinput=newScanner(System.in);

intn=input.nextInt();

if(1<=n&&n<=10)

{

if(n==1)

{

System.out.println("1");

}

else

{

int[]tag=newint[n];

tag[0]=1;

tag[1]=2;

if(n==1)

{

System.out.println(tag[0]);

}

for(inta=2;a

{

tag[a]=tag[a-1]+tag[a-2];

}

System.out.println(tag[n-1]);

}

}

}

}

12

importjava.io.BufferedReader;

importjava.io.InputStreamReader;

publicclassMain{

publicstaticvoidmain(String[]args)throwsException{

BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));

intnumber=Integer.valueOf(br.readLine());

toString(Integer.toBinaryString(number));

}

privatestaticvoidtoString(Stringbinary){

char[]temp=binary.toCharArray();

booleancontrol=false;

for(inti=0;i

if(temp[i]=='1'){

if(control)

System.out.print("+");

else

control=true;

System.out.print("2");

intmi=temp.length-i-1;

if(mi==0)

System.out.print("(0)");

elseif(mi>1){

System.out.print("(");

toString(Integer.toBinaryString(mi));

System.out.print(")");

}

}

}

}

}

13

importjava.io.*;

importjava.util.*;

publicclassMain{

publicstaticvoidmain(Stringargs[])throwsIOException{

BufferedReaderbf=newBufferedReader(newInputStreamReader(System.in));

Strings=bf.readLine();

String[]ss=s.split("");

int[]numa=newint[ss.length];

int[]numb=newint[ss.length];

int[]numc=newint[ss.length];

for(inti=0;i

numa[i]=Integer.parseInt(ss[i]);

numb[i]=1;

numc[i]=1;

}

inta1=Integer.MIN_VALUE;

inta2=Integer.MIN_VALUE;

for(inti=0;i

for(intj=0;j

if(numa[i]

numb[i]=numb[j]+1;

}

a1=Math.max(a1,numb[i]);

}

}

for(inti=0;i

for(intj=0;j

if(numa[i]>numa[j]&&numc[i]

numc[i]=numc[j]+1;

}

}

a2=Math.max(a2,numc[i]);

}

System.out.println(a1);

System.out.println(a2);

}

 

}

14

importjava.io.BufferedReader;

importjava.io.IOException;

importjava.io.InputStreamReader;

publicclassMain{

privatestaticintn,count;

publicstaticvoidmain(String[]args)throwsIOException{

BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));

n=Integer.parseInt(br.readLine());

Stringm=br.readLine();

longa=Long.parseLong(m,n);

longb=Long.parseLong(newStringBuilder(m).reverse().toString(),n);

if(a==b)

System.out.println("STEP="+0);

else

func(a,b);

}

privatestaticvoidfunc(longa,longb){

count++;

if(count>30){

System.out.println("Impossible!

");

return;

}

longsum=a+b;

Stringstr="";

while(sum>=n){

longtmp=sum%n;

sum/=n;

if(tmp>=10)

str=(char)(55+tmp)+str;

else

str=tmp+str;

}

if(sum>=10)

str=(char)(55+sum)+str;

else

str=sum+str;

Stringreverse=newStringBuilder(str).reverse().toString();

if(!

str.equals(reverse)){

a=Long.parseLong(str,n);

b=Long.parseLong(reverse,n);

func(a,b);

}else{

System.out.println("STEP="+count);

return;

}

}

}

15

importjava.util.Scanner;

publicclassMain{

publicstaticvoidmain(String[]args){

double[][]p=newdouble[1024][1024];

Scannersc=newScanner(System.in);

inti,j,k=0;

doubled1=sc.nextDouble();

doublec=sc.nextDouble();

doubled2=sc.nextDouble();

p[0][1]=sc.nextDouble();

intn=sc.nextInt();

n++;

for(i=1;i

p[i][0]=sc.nextDouble();

p[i][1]=sc.nextDouble();

}

p[n++][0]=d1;

doublef=c*d2;

for(i=0;i

if(p[i+1][0]-p[i][0]>f){

System.out.println("NoSolution");

return;

}

}

doublemin=0,max,d;

for(i=0;i

d=p[i+1][0]-p[i][0];

while(d>0){

while(p[i+1][0]-p[k][0]-d>=f)

k++;

for(j=k;j<=i;j++)

if(p[j][1]

k=j;

max=f-(p[i+1][0]-p[k][0]-d);

if(max>d)

max=d;

d-=max;

min+=max/d2*p[k][1];

}

}

System.out.println(String.format("%.2f",min));

}

}

16

importjava.util.Scanner;

publicclassMain{

publicstaticvoidmain(String[]args){

Scannerscanner=newScanner(System.in);

intN=scanner.nextInt();

intR=scanner.nextInt();

char[]c="0123456789ABCDEFG".toCharArray();

Strings1=N+"=";

Strings="";

while(N!

=0){

intt=N%R;

if(t<0){

t=t-R;

N=N/R+1;

}else

N=N/R;

s=c[t]+s;

}

System.out.println(s1+s+"(base"+R+")");

}

}

17

importjava.io.BufferedReader;

importjava.io.IOException;

importjava.io.InputStreamReader;

importjava.io.StreamTokenizer;

publicclassMain{

publicstaticvoidmain(String[]args)throwsIOException{

StreamTokenizerst=newStreamTokenizer(newBufferedReader(newInputStreamReader(System.in)));

st.nextToken();

intN=(int)st.nval;

st.nextToken();

intK=(int)st.nval;

st.nextToken();

longM=(long)st.nval;

Stringstr=String.valueOf(M);

longdp[][]=newlong[K+1][N+1];

for(inti=1;i<=N;i++){

dp[0][i]=Long.parseLong(str.substring(0,i));

}

for(inti=1;i<=K;i++){

for(intj=1+i;j<=N;j++){

for(intk=i;k<=N;k++){

intfont=0;

for(intl=k;l

font=str.charAt(l)-'0'+font*10;

}

if(dp[i][j]

dp[i][j]=dp[i-1][k]*font;

}

}

}

System.out.println(dp[K][N]);

}

}

18

importjava.util.Scanner;

publicclassMain{

privatestaticString[]a=newString[20];

privatestaticint[]b=newint[20];

privatestaticintmax;

privatestaticintn;

publicstaticvoidmain(String[]args){

Scannerscanner=newScanner(System.in);

n=scanner.nextInt();

for(inti=0;i

a[i]=scanner.next();

Stringstring=scanner.next();

f(string,string.length());

System.out.println(max);

}

privatestaticvoidf(Strings,intlength){

for(inti=0;i

if(a[i].indexOf(s)==0&&b[i]<2){

intlength1=s.length();

intlength2=a[i].length();

b[i]++;

intp=1;

length=length+length2-length1;

while(p

f(a[i].substring(length2-p,length2),length);

p+=1;

}

length=length-length2+length1;

b[i]--;

}

max=length>max?

length:

max;

}

}

19

importjava.io.BufferedReader;

importjava.io.IOException;

importjava.io.InputStreamReader;

publicclassMain{

staticintx;

staticinty;

staticintn;

publicstaticvoidmain(String[]args)throwsIOException{

BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));

n=Integer.parseInt(br.readLine());

int[][]tag=newint[2*n+1][2*n+1];

int[][]arr=newint[n*n][2];

out:

for(inti=1;;i++){

String[]str=br.readLine().split("");

for(intj=0;j<1;j++){

x=arr[i][0]=Integer.parseInt(str[0]);

y=arr[i][1]=Integer.parseInt(str[1]);

tag[x][y]=Integer.parseInt(str[2]);

if(x==0&&y==0&&tag[x][y]==0){

dp(tag);

breakout;

}

}

}

}

publicstaticvoiddp(int[][]tag){

int[][]temp=newint[2*n][2*n];

intk;

for(inti=2;i<=2*n;i++){

for(intt=min(i,n),j=t;j>0;j--){

for(k=t;k>0;k--){

temp[j][k]=max(temp[j][k],temp[j-1][k-1]);

temp[j][k]=max(temp[j][k],temp[j

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > 人文社科 > 法律资料

copyright@ 2008-2023 冰点文库 网站版权所有

经营许可证编号:鄂ICP备19020893号-2