演算法題解
做了一下，代碼如下，樓主可以驗證看看，有不對的地方可以找我改：
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密碼好一些，但可以通過字母頻率表來破解，安全性較弱。