算法题解
做了一下，代码如下，楼主可以验证看看，有不对的地方可以找我改：
importjava.io.IOException;
importjava.util.Scanner;
publicclassTest{
publicstaticvoidmain(String[]args)throwsIOException{
Scannersc=newScanner(System.in);
System.out.print("请输入2个整数(以,隔开):");
Stringstr=sc.nextLine();
intn=Integer.parseInt(str.split(",")[0]),m=Integer.parseInt(str.split(",")[1]),flag=0;
longnum=(long)Math.pow(10,n);
int[]numArray=newint[m];
StringtempA="",tempB="";
for(inti=0;i<m;i++){
System.out.print("请输入第"+(i+1)+"个整数:");
numArray[i]=sc.nextInt();
tempA=numArray[i]+"";
flag=0;
for(intj=0;j<i;j++){
tempB=numArray[j]+"";
if(tempA.startsWith(tempB)){
flag=1;
break;
}elseif(tempB.startsWith(tempA)&&tempB.length()!=tempA.length()){
flag=1;
num-=(long)Math.pow(10,n-tempA.length())-(long)Math.pow(10,n-tempB.length());
break;
}
}
if(flag==0)num-=(long)Math.pow(10,n-tempA.length());
}
System.out.println(num);
}
}
示例1：
请输入2个整数(以,隔开):7,3
请输入第1个整数:0
请输入第2个整数:1
请输入第3个整数:911
7990000
示例2：
请输入2个整数(以,隔开):10,3
请输入第1个整数:0
请输入第2个整数:1
请输入第3个整数:911
7990000000
示例3：
请输入2个整数(以,隔开):3,2
请输入第1个整数:1
请输入第2个整数:11
900
楼主若觉得有所帮助，望采纳，谢谢！
2. python走迷宫算法题怎么解
示例：
#coding:UTF-8
globalm,n,path,minpath,pathnum
m=7
n=7
k=[0,1,2,3,4,5,6,7]#循环变量取值范围向量
a=[[0,0,1,0,0,0,0,0],
[1,0,1,0,1,1,1,0],
[0,0,0,0,1,0,0,0],
[1,1,1,1,1,0,0,0],
[0,0,0,0,0,1,1,0],
[0,0,0,0,0,0,0,0],
[0,0,1,1,1,1,1,1],
[0,0,0,0,0,0,0,0]]#迷宫矩阵
b=[[1,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0]] #状态矩阵
path=[]
minpath=[]
min=10000
step=0
pathnum=0
#print(a)
#print(b)
defnextone(x,y):
globalpath,minpath,m,n,min,step,pathnum
if(x==0)and(y==0):
path=[]
step=0
if(x==m)and(y==n):
pathnum+=1
print("step=",step)
print("path=",path)
ifstep<min:
min=step
minpath=path[:]
else:
if(x+1ink)and(yink):
if(b[x+1][y]==0)and(a[x+1][y]==0):
b[x+1][y]=1
path.append([x+1,y])
step+=1
nextone(x+1,y)
step-=1
path.remove([x+1,y])
b[x+1][y]=0#回溯
if(xink)and(y+1ink):
if(b[x][y+1]==0)and(a[x][y+1]==0):
b[x][y+1]=1
path.append([x,y+1])
step+=1
nextone(x,y+1)
step-=1
path.remove([x,y+1])
b[x][y+1]=0#回溯
if(x-1ink)and(yink):
if(b[x-1][y]==0)and(a[x-1][y]==0):
b[x-1][y]=1
path.append([x-1,y])
step+=1
nextone(x-1,y)
step-=1
path.remove([x-1,y])
b[x-1][y]=0#回溯
if(xink)and(y-1ink):
if(b[x][y-1]==0)and(a[x][y-1]==0):
b[x][y-1]=1
path.append([x,y-1])
step+=1
nextone(x,y-1)
step-=1
path.remove([x,y-1])
b[x][y-1]=0#回溯
nextone(0,0)
print()
print("min=",min)
print("minpath=",minpath)
print("pathnum=",pathnum)
3. 递归算法时间复杂度题目求解答....
1、递归
是指对一个问题的求解，可以通过同一问题的更简单的形式的求解来表示.
并通过问题的简单形式的解求出复杂形式的解.
递归是解决一类问题的重要方法.
递归程序设计是程序设计中常用的一种方法，它可以解决所有有递归属性的问题，并且是行之有效的.
但对于递归程序运行的效率比较低，无论是时间还是空间都比非递归程序更费，若在程序中消除递归调用，则其运行时间可大为节省.
以下讨论递归的时间效率分析方法，以及与非递归设计的时间效率的比较.
2
时间复杂度的概念及其计算方法
算法是对特定问题求解步骤的一种描述.
对于算法的优劣有其评价准则，主要在于评价算法的时间效率，算法的时间通过该算法编写的程序在计算机中运行的时间来衡量，所花费的时间与算法的规模n有必然的联系，当问题的规模越来越大时，算法所需时间量的上升趋势就是要考虑的时间度量.
算法的时间度量是依据算法中最大语句频度（指算法中某条语句重复执行的次数）来估算的，它是问题规模n的某一个函数f(n).
算法时间度量记作：t（n）=o（f（n））
它表示随问题规模n的增大，算法执行时间的增长率和f（n）的增长率相同，称作算法的时间复杂度，简称时间复杂度[2].
例如下列程序段：
（1）x=x+1;（2）for(i=1;i<=n;i++)
x=x+1;（3）for(j=1;j<=n;j++)
for(k=1;k<=n;k++)
x=x+1.
以上三个程序段中，语句x=x+1的频度分别为1，n，n2，则这三段程序的时间复杂度分别为o（1），o（n），o（n2）.
求解过程为：先给出问题规模n的函数的表达式，然后给出其时间复杂度t（n）.
但是在现实程序设计过程中，往往遇到的问题都是比较复杂的算法，就不能很容易地写出规模n的表达式，也比较难总结其时间复杂度.
递归函数就是属于这种情况.
下面举例说明递归函数的时间复杂度的分析方法.
4. 八数码广度优先算法题解C++
//主要思想是把每一个序列按字典序排序,那么每一个序列就会有一个固定的序列号,这个序列号是可以计算的,序列直接存下来.我是计算出来的.然后再去广搜,从起点开始搜.
#include<stdio.h>
#include<string.h>
int exist[363000];
int fac[10]={1};
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int rank(const int n[])
{
int sum,i,ans=0,j,used[10]={0};
for(i=0;i<9;i++)
{
sum=0;
for(j=1;j<n[i];j++)
if(used[j])
sum++;
ans+=(n[i]-1-sum)*fac[9-i-1];
used[n[i]]=1;
}
return ans;
}
void swap(int *a,int *b)
{
int temp;
temp=*a;
*a=*b;
*b=temp;
}
void BFS()
{
int front=-1,rear=0,i,size,step=0;
int queue[363000]={123456789},t,j;
int temp[3][3],k,matrix[3][3],x,y,tx,ty;
int n[10],ans,sum,u;
memset(exist,-1,sizeof(exist));
exist[0]=0;
while(front<rear)
{
size=rear-front;
step++;
while(size--)
{
front++;
t=queue[front];
i=0;
j=0;
while(t)
{
matrix[i][j]=t%10;
t/=10;
j++;
if(j%3==0&&j>0)
{
i++;
j=0;
}
}
swap(&matrix[0][0],&matrix[2][2]);
swap(&matrix[0][1],&matrix[2][1]);
swap(&matrix[0][2],&matrix[2][0]);
swap(&matrix[1][0],&matrix[1][2]);
for(i=0;i<3;i++)
for(j=0;j<3;j++)
if(matrix[i][j]==9)
{
x=i;
y=j;
break;
}
for(i=0;i<4;i++)
{
tx=x+dir[i][0];
ty=y+dir[i][1];
if(!(tx>=0&&tx<3&&ty>=0&&ty<3))
continue;
for(j=0;j<3;j++)
{
for(k=0;k<3;k++)
temp[j][k]=matrix[j][k];
}
k=temp[x][y];
temp[x][y]=temp[tx][ty];
temp[tx][ty]=k;
for(k=u=0;u<3;u++)
{
for(j=0;j<3;j++,k++)
n[k]=temp[u][j];
}
ans=rank(n);
if(exist[ans]>-1)
continue;
exist[ans]=step;
sum=0;
for(u=0;u<9;u++)
sum=sum*10+n[u];
rear++;
queue[rear]=sum;
}
}
}
}
main()
{
int i,n,temp[10],ans,j;
char s[100];
for(i=1;i<10;i++)
fac[i]=fac[i-1]*i;
BFS();
while(gets(s))
{
for(j=0,i=0;s[i]!='\0';i++)
{
if(s[i]!=' ')
{
if(s[i]!='x')
temp[j++]=s[i]-'0';
else
temp[j++]=9;
}
}
ans=rank(temp);
if(exist[ans]==-1)
printf("unsolveable\n");
else
printf("%d\n",exist[ans]);
}
}
5. 算法题求大佬提供一下解题思路啊,在线等急，万分感谢！
可以先将大的树苗先种下去，按照孔的间隔种植，然后种植小树苗，即一大一小的间隔排列，可以避免相邻的两颗树碰在一起。
6. 常见算法问题解析
将一个字符串进行反转输出。
可以使用双指针，一个指向字符串头部，一个指向字符串结尾，将头尾指针交换并令头指针右移，尾指针左移。循环的条件为头指针小于尾指针。
将一个链表反转。
取链表头部，获取下一个指针next，将链表头部的next置为Null，随后取next的next对象，修改next的next为上一个链表节点。
归并算法的归并
获取字符串中第一次出现的且只出现了一次的字符。
这里运用到hash表的建立方式，字符串占用长度为8位，可以表示256种字符，我们将字符串出现次数传入数组对应ASCII码的位置中，如a传入数组地97位记录下其出现次数。
遍历字符串，字符每出现一次就在数组对应位置++。
再遍历字符串，查找对应哈希表，当数组中所存储的值为1时，返回该字符串。
将两个视图的所有父视图分别存入两个数组，直到父视图为空。
反向遍历两个数组，判断元素是否相同。
通过快速排序，取首尾指针，首指针向右，尾指针向左，遍历，直至首指针找到大于最开始的数，尾指针找到小于最开始的数，交换元素。当首指针大于等于尾指针时，结束循环，交换首位指针的元素。这时候我们可以得出首指针左边的都小于他右边的元素，如果这时候首指针正好在中间，则说明次元素为中位数，否则，若大于中间，则说明中位数在左边，取左侧数组再排序，若小于中间则说明中位数在右边，则再排序。
7. 求教几个数据结构算法题的解法
1.试写算法让一个带头结点的单链表逆置，如L=(b1,b2,...,bn)逆置为L2=(bn,bn-1,...,b2,b1)
解法如下：
假定head为头节点，
p=head->next;
if(p==NULL) return;
pnow = NULL;
while(p->next)
{
q = p->next;
p->next = pnow;
pnow = p;
p = q;
}
p->next = pnow;
head->next = p;
8. 4-4算法题目详解
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
注解:其实这道题目不难,只有一点考察就是reverse运用
reverse 包含在#include 头文件下 ,反转[first, last )范围内的顺序. 左闭右开
9. 关于网络安全的一道算法题求解，谢谢
单表置换加密，将选好的密钥（一个句子）不重复地依次对应到各个字母上，密钥中未出现的字母在其后按顺序添加上即可，本题的置换表如下：
a b c d e f g h i j k l m n o p q r s t u v w x y z
t h e s n o w l a y i c k p d f r v b g j m q u x z
按上表解密该消息得：basilisk to leviathan blake is contact
这个表的置换方向并无要求，只要加密和解密是反着的就行，本题根据LZ的密文确定为解密由第一行到第二行置换。
当然，不同的实现可能有所不同。
单表置换加密属于最原始的古典加密算法，比Caesar密码好一些，但可以通过字母频率表来破解，安全性较弱。