當前位置:首頁 » 操作系統 » 八碼演算法

八碼演算法

發布時間: 2024-11-03 00:56:31

Ⅰ 兒童鞋子尺碼換算公式內長腳長

兒童鞋子是在孩子生長發育期間比較重要的,因為鞋子的舒適性會影響兒童腳部的發育,嚴重的是會影響到兒童的生長發育。所以說這個時候需要兒童鞋子尺碼換算公式。這樣就可以把孩子的腳長換算成正常的兒童鞋碼。就不會影響到孩子的腳了。

兒童鞋子尺碼換算公式內長腳長

無論是網購,還是去鞋店裡給孩子買兒童健康鞋的時候,媽媽們總會有一個苦惱:「要給孩子買幾碼的鞋子呢?」據健康鞋專業人員介紹,要知道孩子穿多大的鞋子,媽媽們不僅要知道孩子的腳長,還要知曉各國尺碼換算,這樣在買其他碼數規則的兒童健康鞋時,媽媽們才不會摸不著頭腦,給孩子挑選最合適的兒童健康鞋。同時健康鞋專業人員還提醒,寶寶學步鞋的挑選和孩子的兒童健康鞋不同,媽媽們也要注意。

怎麼給孩子測腳長,首先,要測量孩子的腳長與腳寬,雙腳著地後的尺寸是最準的,要讓寶寶站直,不能家長抱著測量,這樣的數據不準確。要在左右腳受力平衡時測量,並且注意他的腳趾有沒有彎曲。兩只腳都要測量,以較長較寬的一組數為准。

除此之外,兒童健康鞋內應有適宜的放餘量。腳趾在鞋腔內應有一定的活動餘地,鞋的前尖距最長的腳趾有一段空隙,叫做放餘量(測量時需要站立),在足尖與鞋頭之間應該有一指寬的距離(大約1.3cm)。除了鞋子前端需要約1.3厘米的空隙,兒童健康鞋的鞋寬也應該比腳的寬度多出大約1厘米(左右各5毫米的樣子)。

怎麼選擇合適的兒童健康鞋碼數,測量出孩子的腳長之後,要怎麼挑選合適的碼數呢?每個國家都有各自的兒童健康鞋碼數規則,那麼我們在買不同鞋碼規則的鞋子時,就需要進行換算。比如寶寶穿國內24碼的兒童健康鞋,那麼選美製鞋碼4碼的兒童健康鞋就好。

國內兒童健康鞋的演算法比較簡單,鞋子內長的演算法公式通常為:碼數-10 厘米數。國外兒童健康鞋的尺碼換算情況也很簡單,可能外國小孩的腳偏大,因此相應同樣的兒童健康鞋碼數的鞋子的內長偏大。其鞋子內長的演算法公式為:(碼數+10)/2 厘米。不同國家鞋子內長的演算法公式是這樣的:厘米數×2-10=歐制;厘米數-18+0.5=美製 ;厘米數-18-0.5=英制。比如:一雙歐制兒童健康鞋的碼數為24碼,按照公式 (24+10)/2=17 厘米,這雙兒童健康鞋的內長尺寸應該為17厘米。

童鞋選購誤區

尺碼買大一號:鞋子過大,走路時腳帶不起鞋,寶寶容易摔倒,腳在鞋裡不穩,會本能地用腳尖或腳後跟去帶鞋,容易形成內八、外八或歪歪扭扭的不良走路姿勢。

鞋底的彎曲度越大越好:童鞋鞋底要有適當的厚度和軟硬度,但過軟的鞋底不能支撐腳掌,易使寶寶產生疲勞感。

鞋幫、鞋面越軟越好:選擇軟的鞋底指的是軟在前掌彎曲的部位。孩子穿鞋鞋頭部就不應該軟,太軟不能夠保護腳趾。還有童鞋的後幫應硬挺、包腳,不過,腳背處的鞋面還是要柔軟些,以利於腳部的彎折。

有弓型鞋墊的鞋保健舒適:許多童鞋在鞋墊的腳心部位裝有一塊凸起的軟墊,媽媽們一般認為它能托起足弓,令寶寶感覺舒適,並具有保健作用。其實,這種鞋比較適合成人穿著,對於兒童來說,它卻縮小了足弓的伸展空間,使正處於發育期的足弓肌肉得不到必要的鍛煉,長此以往可能會令寶寶變成扁平足。

厚底鞋舒適防震:行走時鞋隨著腳部的運動需不斷地彎曲,鞋底越厚,彎曲就越費力,尤其對於愛跑愛跳的寶寶來說,厚底鞋更容易引起腳的疲勞,並進而影響到膝關節及腰部的健康。

Ⅱ 求八數碼問題演算法,並說明下該演算法優缺點,要演算法,不是源代碼(可以沒有)。

八數碼問題

一.八數碼問題
八數碼問題也稱為九宮問題。在3×3的棋盤,擺有八個棋子,每個棋子上標有1至8的某一數字,不同棋子上標的數字不相同。棋盤上還有一個空格,與空格相鄰的棋子可以移到空格中。要求解決的問題是:給出一個初始狀態和一個目標狀態,找出一種從初始轉變成目標狀態的移動棋子步數最少的移動步驟。所謂問題的一個狀態就是棋子在棋盤上的一種擺法。棋子移動後,狀態就會發生改變。解八數碼問題實際上就是找出從初始狀態到達目標狀態所經過的一系列中間過渡狀態。
八數碼問題一般使用搜索法來解。搜索法有廣度優先搜索法、深度優先搜索法、A*演算法等。這里通過用不同方法解八數碼問題來比較一下不同搜索法的效果。

二.搜索演算法基類
1.八數碼問題的狀態表示
八數碼問題的一個狀態就是八個數字在棋盤上的一種放法。每個棋子用它上面所標的數字表示,並用0表示空格,這樣就可以將棋盤上棋子的一個狀態存儲在一個一維數組p[9]中,存儲的順序是從左上角開始,自左至右,從上到下。也可以用一個二維數組來存放。
2.結點
搜索演算法中,問題的狀態用結點描述。結點中除了描述狀態的數組p[9]外,還有一個父結點指針last,它記錄了當前結點的父結點編號,如果一個結點v是從結點u經狀態變化而產生的,則結點u就是結點v的父結點,結點v的last記錄的就是結點u的編號。在到達目標結點後,通過last 可以找出搜索的路徑。
3.類的結構
在C++中用類來表示結點,類將結點有關的數據操作封裝在一起。
不同的搜索演算法具有一定共性,也有各自的個性,因此這里將不同搜索演算法的共有的數據和功能封裝在一個基類中,再通過繼承方式實現不同的搜索演算法。
4.結點擴展規則
搜索就是按照一定規則擴展已知結點,直到找到目標結點或所有結點都不能擴展為止。
八數碼問題的結點擴展應當遵守棋子的移動規則。按照棋子移動的規則,每一次可以將一個與空格相鄰棋子移動到空格中,實際上可以看作是空格作相反移動。空格移動的方向可以是右、下、左、上,當然不能移出邊界。棋子的位置,也就是保存狀態的數組元素的下標。空格移動後,它的位置發生變化,在不移出界時,空格向右、下、左和上移動後,新位置是原位置分別加上1、3、-1、-3,如果將空格向右、下、左和上移動分別用0、1、2、3表示,並將-3、3、-1、1放在靜態數組d[4]中,空格位置用spac表示,那麼空格向方向i移動後,它的位置變為spac+d[i]。空格移動所產生的狀態變化,反映出來則是將數組p[]中,0的新位置處的數與0交換位置。
5.八數碼問題的基類

八數碼問題的基類及其成員函數的實現如下:
#define Num 9
class TEight
{
public:
TEight(){}
TEight(char *fname); //用文件數據構造節點
virtual void Search()=0; //搜索
protected:
int p[Num];
int last,spac;
static int q[Num],d[],total;
void Printf();
bool operator==(const TEight &T);
bool Extend(int i);
};
int TEight::q[Num];//儲存目標節點
int TEight::d[]={1,3,-1,-3};//方向
int TEight::total=0;//步數

TEight::TEight(char *fname)
{
ifstream fin;
fin.open(fname,ios::in);
if(!fin)
{
cout<<"不能打開數據文件!"<<endl;
return;
}
int i;
for(i=0;i<Num;)//得到源節點
fin>>p[i++];
fin>>spac;
for(i=0;i<Num;)//得到目標節點
fin>>q[i++];
fin.close();
last=-1;
total=0;
}

void TEight::Printf()//把路徑列印到結果文件
{
ofstream fout;
fout.open("eight_result.txt",ios::ate|ios::app);
fout<<total++<<"t";
for(int i=0;i<Num;)
fout<<" "<<p[i++];
fout<<endl;
fout.close();
}

bool TEight::operator==(const TEight &T)//判斷兩個狀態是否相同
{
for(int i=0;i<Num;)
if(T.p[i]!=p[i++])
return 0;
return 1;
}

bool TEight::Extend(int i)//擴展
{
if(i==0 && spac%3==2 || i==1 && spac>5
|| i==2 && spac%3==0 || i==3 && spac<3)
return 0;
int temp=spac;
spac+=d[i];
p[temp]=p[spac];
p[spac]=0;
return 1;
}

數據文件的結構:
一共三行,第一行是用空格隔開的九個數字0~8,這是初始狀態。第二行是一個數字,空格(數字0)的位置,第三行也是用空格隔開的九個數字0~8,這是目標狀態。

三.線性表
搜索法在搜索過程中,需要使用一個隊列存儲搜索的中間結點,為了在找到目標結點後,能夠找到從初始結點到目標結點的路徑,需要保留所有搜索過的結點。另一方面,不同問題甚至同一問題的不同搜索方法中,需要存儲的結點數量相差很大,所以這里採用鏈式線性表作為存儲結構,同時,為適應不同問題,線性表設計成類模板形式。
template<class Type> class TList; //線性表前視定義

template<class Type> class TNode //線性表結點類模板
{
friend class TList<Type>;
public:
TNode(){}
TNode(const Type& dat);
private:
TNode<Type>* Next;
Type Data;
};

template<class Type> class TList
{
public:
TList(){Last=First=0;Length=0;} //構造函數
int Getlen()const{return Length;} //成員函數,返回線性表長度
int Append(const Type& T); //成員函數,從表尾加入結點
int Insert(const Type& T,int k); //成員函數,插入結點
Type GetData(int i); //成員函數,返回結點數據成員
void SetData(const Type& T,int k); //成員函數,設置結點數據成員
private:
TNode<Type> *First,*Last; //數據成員,線性表首、尾指針
int Length; //數據成員,線性表長度
};

template<class Type> int TList<Type>::Append(const Type& T)
{
Insert(T,Length);
return 1;
}

template<class Type> int TList<Type>::Insert(const Type& T,int k)
{
TNode<Type> *p=new TNode<Type>;
p->Data=T;
if(First)
{
if(k<=0)
{
p->Next=First;
First=p;
}
if(k>Length-1)
{
Last->Next=p;
Last=Last->Next;
Last->Next=0;
}
if(k>0 && k<Length)
{
k--;
TNode<Type> *q=First;
while(k-->0)
q=q->Next;
p->Next=q->Next;
q->Next=p;
}
}
else
{
First=Last=p;
First->Next=Last->Next=0;
}
Length++;
return 1;
}

template<class Type> Type TList<Type>::GetData(int k)
{
TNode<Type> *p=First;
while(k-->0)
p=p->Next;
return p->Data;
}

template<class Type> void TList<Type>::SetData(const Type& T,int k)
{
TNode<Type> *p=First;
while(k-->0)
p=p->Next;
p->Data=T;
}
線性表單獨以頭文件形式存放。

四.廣度優先搜索法
在搜索法中,廣度優先搜索法是尋找最短路經的首選。
1.廣度優先搜索演算法的基本步驟
1)建立一個隊列,將初始結點入隊,並設置隊列頭和尾指針
2)取出隊列頭(頭指針所指)的結點進行擴展,從它擴展出子結點,並將這些結點按擴展的順序加入隊列。
3)如果擴展出的新結點與隊列中的結點重復,則拋棄新結點,跳至第六步。
4)如果擴展出的新結點與隊列中的結點不重復,則記錄其父結點,並將它加入隊列,更新隊列尾指針。
5)如果擴展出的結點是目標結點,則輸出路徑,程序結束。否則繼續下一步。
6)如果隊列頭的結點還可以擴展,直接返回第二步。否則將隊列頭指針指向下一結點,再返回第二步。
2.搜索路徑的輸出
搜索到目標結點後,需要輸出搜索的路徑。每個結點有一個數據域last,它記錄了結點的父結點,因此輸出搜索路徑時,就是從目標結點Q出發,根據last找到它的父結點,再根據這個結點的last找到它的父結點,....,最後找到初始結點。搜索的路徑就是從初始結點循相反方向到達目標結點的路徑。
3.廣度優先搜索法TBFS類的結構
廣度優先搜索法TBFS類是作為TEight類的一個子類。其類的結構和成員函數的實現如下:
class TBFS:public TEight
{
public:
TBFS(){}
TBFS(char *fname):TEight(fname){}
virtual void Search();
private:
void Printl(TList<TBFS> &L);
int Repeat(TList<TBFS> &L);
int Find();
};

void TBFS::Printl(TList<TBFS> &L)
{
TBFS T=*this;
if(T.last==-1)
return;
else
{
T=L.GetData(T.last);
T.Printl(L);
T.Printf();
}
}

int TBFS::Repeat(TList<TBFS> &L)
{
int n=L.Getlen();
int i;
for(i=0;i<n;i++)
if(L.GetData(i)==*this)
break;
return i;
}

int TBFS::Find()
{
for(int i=0;i<Num;)
if(p[i]!=q[i++])
return 0;
return 1;
}

void TBFS::Search()
{
TBFS T=*this;
TList<TBFS> L;
L.Append(T);
int head=0,tail=0;
while(head<=tail)
{
for(int i=0;i<4;i++)
{
T=L.GetData(head);
if(T.Extend(i) && T.Repeat(L)>tail)
{
T.last=head;
L.Append(T);
tail++;
}
if(T.Find())
{
T.Printl(L);
T.Printf();
return;
}
}
head++;
}
}
4.廣度優先搜索法的缺點
廣度優先搜索法在有解的情形總能保證搜索到最短路經,也就是移動最少步數的路徑。但廣度優先搜索法的最大問題在於搜索的結點數量太多,因為在廣度優先搜索法中,每一個可能擴展出的結點都是搜索的對象。隨著結點在搜索樹上的深度增大,搜索的結點數會很快增長,並以指數形式擴張,從而所需的存儲空間和搜索花費的時間也會成倍增長。

五、A*演算法
1.啟發式搜索
廣度優先搜索和雙向廣度優先搜索都屬於盲目搜索,這在狀態空間不大的情況下是很合適的演算法,可是當狀態空間十分龐大時,它們的效率實在太低,往往都是在搜索了大量無關的狀態結點後才碰到解答,甚至更本不能碰到解答。
搜索是一種試探性的查尋過程,為了減少搜索的盲目性引,增加試探的准確性,就要採用啟發式搜索了。所謂啟發式搜索就是在搜索中要對每一個搜索的位置進行評估,從中選擇最好、可能容易到達目標的位置,再從這個位置向前進行搜索,這樣就可以在搜索中省略大量無關的結點,提高了效率。
2.A*演算法
A*演算法是一種常用的啟發式搜索演算法。
在A*演算法中,一個結點位置的好壞用估價函數來對它進行評估。A*演算法的估價函數可表示為:
f'(n) = g'(n) + h'(n)
這里,f'(n)是估價函數,g'(n)是起點到終點的最短路徑值(也稱為最小耗費或最小代價),h'(n)是n到目標的最短路經的啟發值。由於這個f'(n)其實是無法預先知道的,所以實際上使用的是下面的估價函數:
f(n) = g(n) + h(n)
其中g(n)是從初始結點到節點n的實際代價,h(n)是從結點n到目標結點的最佳路徑的估計代價。在這里主要是h(n)體現了搜索的啟發信息,因為g(n)是已知的。用f(n)作為f'(n)的近似,也就是用g(n)代替g'(n),h(n)代替h'(n)。這樣必須滿足兩個條件:(1)g(n)>=g'(n)(大多數情況下都是滿足的,可以不用考慮),且f必須保持單調遞增。(2)h必須小於等於實際的從當前節點到達目標節點的最小耗費h(n)<=h'(n)。第二點特別的重要。可以證明應用這樣的估價函數是可以找到最短路徑的。
3.A*演算法的步驟
A*演算法基本上與廣度優先演算法相同,但是在擴展出一個結點後,要計算它的估價函數,並根據估價函數對待擴展的結點排序,從而保證每次擴展的結點都是估價函數最小的結點。
A*演算法的步驟如下:
1)建立一個隊列,計算初始結點的估價函數f,並將初始結點入隊,設置隊列頭和尾指針。
2)取出隊列頭(隊列頭指針所指)的結點,如果該結點是目標結點,則輸出路徑,程序結束。否則對結點進行擴展。
3)檢查擴展出的新結點是否與隊列中的結點重復,若與不能再擴展的結點重復(位於隊列頭指針之前),則將它拋棄;若新結點與待擴展的結點重復(位於隊列頭指針之後),則比較兩個結點的估價函數中g的大小,保留較小g值的結點。跳至第五步。
4)如果擴展出的新結點與隊列中的結點不重復,則按照它的估價函數f大小將它插入隊列中的頭結點後待擴展結點的適當位置,使它們按從小到大的順序排列,最後更新隊列尾指針。
5)如果隊列頭的結點還可以擴展,直接返回第二步。否則將隊列頭指針指向下一結點,再返回第二步。
4.八數碼問題的A*演算法的估價函數
估價函數中,主要是計算h,對於不同的問題,h有不同的含義。那麼在八數碼問題中,h的含意是各什麼?八數碼問題的一個狀態實際上是數字0~8的一個排列,用一個數組p[9]來存儲它,數組中每個元素的下標,就是該數在排列中的位置。例如,在一個狀態中,p[3]=7,則數字7的位置是3。如果目標狀態數字3的位置是8,那麼數字7對目標狀態的偏移距離就是3,因為它要移動3步才可以回到目標狀態的位置。
八數碼問題中,每個數字可以有9個不同的位置,因此,在任意狀態中的每個數字和目標狀態中同一數字的相對距離就有9*9種,可以先將這些相對距離算出來,用一個矩陣存儲,這樣只要知道兩個狀態中同一個數字的位置,就可查出它們的相對距離,也就是該數字的偏移距離:
0 1 2 3 4 5 6 7 8
0 0 1 2 1 2 3 2 3 4
1 1 0 1 2 1 2 3 2 3
2 2 1 0 3 2 1 4 3 2
3 1 2 3 0 1 2 1 2 3
4 2 1 2 1 0 1 2 1 2
5 3 2 1 2 1 0 3 2 1
6 2 3 4 1 2 3 0 1 2
7 3 2 3 2 1 2 1 0 1
8 4 3 2 3 2 1 2 1 0
例如在一個狀態中,數字8的位置是3,在另一狀態中位置是7,那麼從矩陣的3行7列可找到2,它就是8在兩個狀態中的偏移距離。
估價函數中的h就是全體數字偏移距離之和。顯然,要計算兩個不同狀態中同一數字的偏移距離,需要知道該數字在每個狀態中的位置,這就要對數組p[9]進行掃描。由於狀態發生變化,個數字的位置也要變化,所以每次計算h都沿線掃描數組,以確定每個數字在數組中的位置。為了簡化計算,這里用一個數組存儲狀態中各個數字的位置,並讓它在狀態改變時隨著變化,這樣就不必在每次計算h時,再去掃描狀態數組。
例如,某個狀態中,數字5的位置是8,如果用數組r[9]存儲位置,那麼就有r[5]=8。
現在用數組r[9]存儲當前狀態的數字位置,而用s[9]存儲目標狀態的數字位置,那麼當前狀態數字i對目標狀態的偏移距離就是矩陣中r[i]行s[i]列對應的值。
5.A*演算法的類結構
A*演算法的類聲明如下:
class TAstar:public TEight
{
public:
TAstar(){} //構造函數
TAstar(char *fname); //帶參數構造函數
virtual void Search(); //A*搜索法
private:
int f,g,h; //估價函數
int r[Num]; //存儲狀態中各個數字位置的輔助數組
static int s[Num]; //存儲目標狀態中各個數字位置的輔助數組
static int e[]; //存儲各個數字相對距離的輔助數組
void Printl(TList<TAstar> L); //成員函數,輸出搜索路徑
int Expend(int i); //成員函數,A*演算法的狀態擴展函數
int Calcuf(); //成員函數,計算估價函數
void Sort(TList<TAstar>& L,int k); //成員函數,將新擴展結點按f從小到大順序插入待擴展結點隊列
int Repeat(TList<TAstar> &L); //成員函數,檢查結點是否重復
};

int TAstar::s[Num],TAstar::e[Num*Num];

TAstar::TAstar(char *fname):TEight(fname)
{
for(int i=0;i<Num;)
{
r[p[i]]=i; //存儲初始狀態個個數字的位置
s[q[i]]=i++; //存儲目標狀態個個數字的位置
}
ifstream fin;
fin.open("eight_dis.txt",ios::in); //打開數據文件
if(!fin)
{
cout<<"不能打開數據文件!"<<endl;
return;
}
for(int i=0;i<Num*Num;i++) //讀入各個數字相對距離值
fin>>e[i];
fin.close();
f=g=h=0; //估價函數初始值
}

void TAstar::Printl(TList<TAstar> L)
{
TAstar T=*this;
if(T.last==-1) return;
else
{
T=L.GetData(T.last);
T.Printl(L);
T.Printf();
}
}

int TAstar::Expend(int i)
{
if(Extend(i)) //結點可擴展
{
int temp=r[p[r[0]]]; //改變狀態後數字位置變化,存儲改變後的位置
r[p[r[0]]]=r[0];
r[0]=temp;
return 1;
}
return 0;
}

int TAstar::Calcuf()
{
h=0;
for(int i=0;i<Num;i++) //計算估價函數的 h
h+=e[Num*r[i]+s[i]];
return ++g+h;
}

void TAstar::Sort(TList<TAstar>& L,int k)
{
int n=L.Getlen();
int i;
for(i=k+1;i<n;i++)
{
TAstar T=L.GetData(i);
if(this->f<=T.f)
break;
}
L.Insert(*this,i);
}

int TAstar::Repeat(TList<TAstar> &L)
{
int n=L.Getlen();
int i;
for(i=0;i<n;i++)
if(L.GetData(i)==*this)
break;
return i;
}

void TAstar::Search()
{
TAstar T=*this; //初始結點
T.f=T.Calcuf(); //初始結點的估價函數
TList<TAstar> L; //建立隊列
L.Append(T); //初始結點入隊
int head=0,tail=0; //隊列頭和尾指針
while(head<=tail) //隊列不空則循環
{
for(int i=0;i<4;i++) //空格可能移動方向
{
T=L.GetData(head); //去隊列頭結點
if(T.h==0) //是目標結點
{
T.Printl(L);//輸出搜索路徑
T.Printf(); //輸出目標狀態
return; //結束
}
if(T.Expend(i)) //若結點可擴展
{
int k=T.Repeat(L); //返回與已擴展結點重復的序號
if(k<head) //如果是不能擴展的結點
continue; //丟棄
T.last=head; //不是不能擴展的結點,記錄父結點
T.f=T.Calcuf(); //計算f
if(k<=tail) //新結點與可擴展結點重復
{
TAstar Temp=L.GetData(k);
if(Temp.g>T.g) //比較兩結點g值
L.SetData(T,k); //保留g值小的
continue;
}
T.Sort(L,head) ; //新結點插入可擴展結點隊列
tail++; //隊列尾指針後移
}
}
head++; //一個結點不能再擴展,隊列頭指針指向下一結點
}
}

六、測試程序
A*演算法的測試:
int main()
{
TAstar aStar("eight.txt");
aStar.Search();
system("pauze");
return 0;
}
eight.txt文件中的數據(初始態和目標態):
一共三行,第一行是用空格隔開的九個數字0~8,這是初始狀態。第二行是一個數字,空格(數字0)的位置,第三行也是用空格隔開的九個數字0~8,這是目標狀態。

8 3 5 1 2 7 4 6 0
8
1 2 3 4 5 6 7 8 0

eight_dis.txt中的數據(估計函數使用)
0 1 2 1 2 3 2 3 4
1 0 1 2 1 2 3 2 3
2 1 0 3 2 1 4 3 2
1 2 3 0 1 2 1 2 3
2 1 2 1 0 1 2 1 2
3 2 1 2 1 0 3 2 1
2 3 4 1 2 3 0 1 2
3 2 3 2 1 2 1 0 1
4 3 2 3 2 1 2 1 0

eight_Result.txt中的結果(運行後得到的結果)

七、演算法運行結果
1.BFS演算法只能適用於到達目標結點步數較少的情況,如果步數超過15步,運行時間太長,實際上不再起作用。
2.對於隨機生成的同一個可解狀態,BFS演算法最慢,DBFS演算法較慢,A*演算法較快。但在15步以內,DBFS演算法與A*演算法相差時間不大,超過15步後,隨步數增加,A*演算法的優勢就逐漸明顯,A*演算法要比DBFS演算法快5倍以上,並隨步數增大而增大。到25步以上,DBFS同樣因運行時間過長而失去價值。
3.一般來說,解答的移動步數每增加1,程序運行時間就要增加5倍以上。由於八數碼問題本身的特點,需要檢查的節點隨步數增大呈指數形式增加,即使用A*演算法,也難解決移動步數更多的問題。

八、問題可解性
八數碼問題的一個狀態實際上是0~9的一個排列,對於任意給定的初始狀態和目標,不一定有解,也就是說從初始狀態不一定能到達目標狀態。因為排列有奇排列和偶排列兩類,從奇排列不能轉化成偶排列或相反。
如果一個數字0~8的隨機排列871526340,用F(X)表示數字X前面比它小的數的個數,全部數字的F(X)之和為Y=∑(F(X)),如果Y為奇數則稱原數字的排列是奇排列,如果Y為偶數則稱原數字的排列是偶排列。
例如871526340這個排列的
Y=0+0+0+1+1+3+2+3+0=10
10是偶數,所以他偶排列。871625340
Y=0+0+0+1+1+2+2+3+0=9
9是奇數,所以他奇排列。
因此,可以在運行程序前檢查初始狀態和目標狀態的窘是否相同,相同則問題可解,應當能搜索到路徑。否則無解。

PS:整理自網路

Ⅲ 美國戒指八號是中國的多少

相當於中國的16號。

戒指尺寸大小的標准也稱為手寸。手寸是以多少號來表示的,分為美式,港式,它們對應的直徑和周長各不相同,目前中國多採用港式。

根據國家的不同,使用的戒指尺寸也有差異。而中國又有港碼和內地尺碼之分。不知道自己戒指尺寸的人可以測量自己的手指圍,然後選取對應周長的戒指號。在戒指的尺寸對照表中,12號戒指是指直徑是16.9 mm和戒指周長是53.0 mm大小的戒指,53mm是大部分成年女性的手指周長,所以12號和13號也是購買最多的戒指尺寸。

拓展資料:

尺寸的測量方法

1、將您平常所戴的戒指放在尺子上,測量戒指內徑長度(即內周長),即可對照戒指圈號表。

2、用硬線(最好是細鐵絲)繞一個圈,調整到可佩帶的大小,脫下再如上測量。

3、用細線如上繞一圈後,剪斷拉直,測量長度即周長,再對照戒指圈號表。

4、利用紙尺或軟尺,在配戴戒指的手指繞一圈清楚記下得出的長度(以mm計算,將結果除以3.14,得出指環直徑),參照以下對照表,找出您的戒圈。


參考資料:美號-網路

熱點內容
設置密碼字元怎麼設置 發布:2024-11-03 03:22:50 瀏覽:26
腳本戰士是什麼意思 發布:2024-11-03 03:22:39 瀏覽:872
php的mysql擴展 發布:2024-11-03 03:22:01 瀏覽:394
編譯原理名字的性質的說明方式 發布:2024-11-03 02:58:58 瀏覽:152
密碼通常在自家網路的哪裡 發布:2024-11-03 02:58:05 瀏覽:928
吉利豪越七座有什麼配置 發布:2024-11-03 02:45:04 瀏覽:74
全局路由配置和代理怎麼設置 發布:2024-11-03 02:28:24 瀏覽:872
空間譜估計理論與演算法 發布:2024-11-03 02:25:47 瀏覽:249
linux括弧 發布:2024-11-03 02:19:06 瀏覽:111
安卓7自帶小游戲怎麼玩 發布:2024-11-03 02:17:59 瀏覽:159