㈠ 有哪些經典的人工智慧演算法

不太明白你所說的「人工智慧演算法」指的是什麼？
我覺得像決策樹、MLP、邏輯回歸都算是經典的人工智慧演算法吧

㈡ 最常見的人工智慧演算法都有哪些

神經網路演算法、蟻群演算法、混合蛙跳演算法、蜂群演算法。

㈢ 問： 40 人工智慧及其應用期末作業 用A*演算法解決下面的八數碼難題。試定義估價函數，啟發函數，

#pragma warning(disable:4786)
#include <algorithm>
#include <cstdio>
#include <set>
#include <utility>
#include <ctime>
#include <cassert>
#include <cstring>
#include <iostream>
using namespace std;

/*item記錄搜索空間中一個結點
state 記錄用整數形式表示的8數碼格局
blank 記錄當前空格位置，主要用於程序優化，
擴展時可不必在尋找空格位置
g, h 對應g(n), h(n)
pre 記錄當前結點由哪個結點擴展而來 */
struct item
{
int state;
int blank;
int g;
int h;
int pre;
};

const int MAXSTEPS = 100000;
const int MAXCHAR = 100;
char buf[MAXCHAR][MAXCHAR]; //open表
item open[MAXSTEPS];
//vector<item> open;
int steps = 0;

//closed表，已查詢狀態只要知道該狀態以及它由哪個結點擴展而來即可，用於輸出路徑
//每次只需得到對應f值最小的待擴展結點，用堆實現提高效率
pair<int, int> closed[MAXSTEPS];
//讀入，將8數碼矩陣格局轉換為整數表示

bool read(pair<int,int> &state)
{
if (!gets(buf[0]))
return false;
if (!gets(buf[1]))
return false;
if (!gets(buf[2]))
return false;

//cout << strlen(buf[0]) << ' ' << strlen(buf[1]) << ' ' << strlen(buf[2]) << endl;
assert(strlen(buf[0]) == 5 && strlen(buf[1]) == 5 && strlen(buf[2]) == 5);
// astar.in中的每行數據長度必須為5
state.first = 0;
for (int i = 0, p = 1; i < 3; ++i)
{
for (int j = 0; j < 6; j += 2)
{
if (buf[i][j] == '0')
state.second = i * 3 + j / 2; // state.second為0（空格）在節點中的位置
else
state.first += p * (buf[i][j] - '0');
p *= 10;
}
}

/* 若初試節點為:
1 2 3
8 0 4
7 6 5
則state.first為567408321，state.second為4
*/
return true;
}

//計算當前結點距目標的距離
int calculate(int current, int target) // return h=the sum of distances each block have to move to the right position,這里的each block不包括空格
{
int c[9], t[9];
int i, cnt = 0;
for (i = 0; i < 9; ++i)
{
c[current % 10] = t[target % 10] = i;
current /= 10;
target /= 10;
}

for (i = 1; i < 9; ++i)
cnt += abs(c[i] / 3 - t[i] / 3) + abs(c[i] % 3 - t[i] % 3);

return cnt;
}

//open表中結點間選擇時的規則 f(n) = g(n) + h(n)

class cmp
{
public: inline bool operator()(item a, item b)
{
return a.g + a.h > b.g + b.h;
}
};

//將整數形式表示轉換為矩陣表示輸出
void pr(int state)
{
memset(buf, ' ', sizeof(buf));
for (int i = 0; i < 3; ++i)
{
for (int j = 0; j < 6; j += 2)
{
if (state % 10)
buf[i][j] = state % 10 + '0';
state /= 10;
}

buf[i][5] = '\0';
puts(buf[i]);
}
}

//用於判斷當前空格是否可以向對應方向移動
inline bool suit(int a, int b) //空格移動後的坐標為(a,b)
{
return (a >= 0 && a < 3 && b >= 0 && b < 3);
}

//遞歸輸出搜索路徑
void path(int index)
{
if (index == 0)
{
pr(closed[index].first);
puts("");
return;
}
path(closed[index].second);
pr(closed[index].first); //將整數形式表示轉換為矩陣表示輸出
puts("");
++steps;
}

int getNixuNum( int state ) //求節點的逆序對數
{
int sum = 0;
int result[9];
memset( result, 0, sizeof(result) );
//cout << result[8] << result[7] << endl;

char buf[10];
itoa( state, buf, 10 );
//cout << buf << endl;
int k = 0;
while( buf[k] != '\0' )
{
result[9-k-1] = buf[k] - '0';
k++;
}

for( int i = 0; i < 9; i++ )
{
for( int j = i + 1; j < 9; j++ )
{
if( result[i] && result[j] && result[i] > result[j] )
{
sum++;
}
}
}
return sum; //返回3*3方格數組的逆序對數
}

int main()
{
//cout << getNixuNum(87654321);
//open.resize(MAXSTEPS);
unsigned int t1 = clock();
//cout << open.size() << endl;
if( freopen("astar.in", "r", stdin) == NULL )
{
cout << "file not find\n";
exit(0);
};

freopen("astar2.out", "w", stdout);
set<int>states;
char tmp[100];
int i, x, y, a, b, nx, ny, end, next, index, kase = 0;
pair<int,int> start, target;
item head; //4個方向移動時的偏移量
const int xtran[4] = {-1, 0, 1, 0};
const int ytran[4] = {0, 1, 0, -1};
const int p[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};

while (read(start)) // 讀取初試狀態節點
{
unsigned int t2 = clock();
printf("Case %d:\n\n", ++kase);
gets(tmp);
read(target); // 讀取目標狀態節點
gets(tmp);

int targetNixuNum = getNixuNum(target.first);
//若兩者的逆序對數不是同為奇數或同為偶數，則無解
if( !(getNixuNum(start.first)&1 && targetNixuNum&1 || !(getNixuNum(start.first)&1) && !(targetNixuNum&1)) )
{
cout << "無法從初始節點到終態節點\n";
exit(0);
}
//初始化open表，將初始狀態加入
open[0].state = start.first;
open[0].h = calculate(start.first, target.first); // 計算當前節點到目標節點的估計距離
open[0].blank = start.second;
open[0].pre = -1; // 初始節點無父節點
open[0].g = 0; // 初始節點的g為0
index = 0;
states.insert(start.first); // 擴展過節點保存在states中，即出現過的狀態保存在states中，states為set<int>類型，其中的states中的元素唯一

//提取open表中f值最小元素放入closed表，並對該結點進行擴展
for (end = 1; end > 0; ++index) // end為open表中的元素個數，一直循環到open表為空
{
assert(index < MAXSTEPS);
//臨時存儲
head = open[0]; // 由於使用pop_heap函數和push_heap函數，所以open[0]為g+h最小的元素

//放入closed表記錄當前格局和由哪個結點擴展而來（該結點肯定已在closed表中）
closed[index].first = open[0].state; //放入close表中，表示已經擴展完的節點，下面的for循環會擴展其節點
closed[index].second = open[0].pre; // index表示當前close表中當前擴展節點的下標
//從open表中刪除該結點
pop_heap(open, open + end, cmp());//為algorithm文件中的函數，第一個參數指定開始位置，第二個指定結束，第三個指定比較函數
--end;

//得到結果，遞歸輸出路徑
if (head.state == target.first)
{
path(index);
break;
}

x = head.blank / 3;
y = head.blank % 3; //空格在3*3方格中的x,y坐標
/*
|2 0 3|
A = |1 8 4|
|7 6 5| // 看成3*3的數組
則head.blank=1
x=0,y=1,即空格的在3*3的數組中下標為(0,1)
*/
for (i = 0; i < 4; ++i)
{
nx = x + xtran[i];
ny = y + ytran[i];
/*
i=0時：(nx,ny）為當前空格向上移動一格後的坐標
i=1時：(nx,ny）為當前空格向右移動一格後的坐標
i=2時：(nx,ny）為當前空格向下移動一格後的坐標
i=3時：(nx,ny）為當前空格向左移動一格後的坐標
*/
if (suit(nx, ny)) // 判斷是否能夠移動
{
a = head.blank; // 空格當前位置,以上面矩陣A為例，a=1
b = nx * 3 + ny; // 空格移動後的新位置,開始是能夠向右邊移動，故b=0*3+2=2
//調換十進製表示整數對應兩個數字位
next = head.state + ((head.state % p[a + 1]) / p[a] - (head.state % p[b + 1]) / p[b]) * p[b] + ((head.state % p[b + 1]) / p[b] - (head.state % p[a + 1]) / p[a]) * p[a];
// 如head.state=567481302,空格向右移動一次後，next=567481032,即為移動後的節點

// 判斷能否由當前節點到達目標節點
if( ( getNixuNum(next)&1 && targetNixuNum&1 ) || ( !(getNixuNum(next)&1) && !(targetNixuNum&1) ) )
{
//判斷是否已經擴展過，即已經出現過
if (states.find(next) == states.end()) //沒出現就保存一下，也存入open表
{
states.insert(next);
open[end].pre = index; //擴展後的子節點，其父節點為當前擴展節點
open[end].blank = b;
open[end].state = next;
open[end].h = calculate(next,target.first);
open[end].g = head.g + 1;
++end; //open表中元素加1
push_heap(open, open + end, cmp()); //壓入堆中
}
}

}
}
}

if (end <= 0)
puts("No solution");
else
{
printf("Num of steps: %d\n", steps);
printf("Num of expanded: %d\n", index);
printf("Num of generated: %d\n", index + end);
printf("Time consumed: %d\n\n", clock() - t2);
}

states.clear();
steps = 0;
}
printf("Total time consumed: %d\n", clock() - t1);
return 0;
}

㈣ 人工智慧演算法是26個嗎

人工智慧演算法是發展很快的，每年都會有新的演算法問世，所以不能說只有26個。

㈤ 人工智慧演算法

編程與推理沒有關系，編程的智能建立在「是非」之上，以中斷判斷為基專礎。推箱子有很多種判屬斷，比如2*2*2……結果會特別多，而編程只是控制其中某一步，這樣每一步都有2種情況，相乘後，軟體就會有很多種通過方法，太多了。比如棋類軟體，我們只要控制某些局部，這些局部組成了「人工智慧」，而局部本身是「非智能」的，這么說明白？
即使是人腦的智能，本質上還是電信號的中斷處理，處理的速度「即人的聰明」，與人腦中資料庫的優化與數據量有關，也就是人腦的智能，其實是機械電子搜索匹配過程……

㈥ 人工智慧是智能演算法的實現,其核心內容在於什麼

人工智慧是計算機學科的一個分支，二十世紀七十年代以來被稱為世界三大尖端技術之一（空間技術、能源技術、人工智慧）。也被認為是二十一世紀三大尖端技術（基因工程、納米科學、人工智慧）之一。這是因為近三十年來它獲得了迅速的發展，在很多學科領域都獲得了廣泛應用，並取得了豐碩的成果，人工智慧已逐步成為一個獨立的分支，無論在理論和實踐上都已自成一個系統。
人工智慧是研究使計算機來模擬人的某些思維過程和智能行為（如學習、推理、思考、規劃等）的學科，主要包括計算機實現智能的原理、製造類似於人腦智能的計算機，使計算機能實現更高層次的應用。人工智慧將涉及到計算機科學、心理學、哲學和語言學等學科。可以說幾乎是自然科學和社會科學的所有學科，其范圍已遠遠超出了計算機科學的范疇，人工智慧與思維科學的關系是實踐和理論的關系，人工智慧是處於思維科學的技術應用層次，是它的一個應用分支。從思維觀點看，人工智慧不僅限於邏輯思維，要考慮形象思維、靈感思維才能促進人工智慧的突破性的發展，數學常被認為是多種學科的基礎科學，數學也進入語言、思維領域，人工智慧學科也必須借用數學工具，數學不僅在標准邏輯、模糊數學等范圍發揮作用，數學進入人工智慧學科，它們將互相促進而更快地發展。

㈦ 人工智慧是什麼 什麼是人工智慧演算法

《博弈聖經》人工智慧的定義；人們把理性看成智能、把智能看成（0、1、2、）三維數碼、把三維數碼看成邏輯，人工智慧，也就是理性的三維數碼邏輯（+-×÷）精確的運算。

博弈聖經著作人的理論學說；人工智慧是什麼，人們必須知道什麼是思考、什麼是思想、什麼是智慧？才能對人工智慧有一點粗略的認知。

博弈聖經著作人的理論學說；感覺、思維、意識，形成的觀念，它會自我構成一致性的思考；它會通過文化的傳播方式，以唯心主義的自信、以及對唯物主義認識的思考、在第三空地里產生思想；《博弈聖經》智慧的定義；智慧就是文化進程中獨創的執行力。（智能，是理性的三維數碼邏輯（+-×÷）的精確運算。

博弈聖經著作人的理論學說；人工智慧是數字化三維支點測量，博弈取勝的人工智慧，選擇一次，都要經過4加、2減、2乘、1除的運算；運算就是對三維支點的運算、三維支點的測量、三維支點的尋找；人工智慧是對「天平兩端與支點」，也類似於「杠桿兩端與支點」對三維空間上的數字、開啟數字邏輯的精密運算，測量其支點上，有關效應、常數、一個小目標，精準的給出，使自己提前知道未來取勝的結果。（提前知道一組組數字代碼中，給定的「地天代碼」數字，就是贏的博文尺度，同時「人天代碼」會精準的顯示贏了多少。）

博弈聖經著作人的理論學說；國正論的非絕對對立性，相當於「天平兩端與支點」類似於「杠桿兩端與支點」量化成四兩撥千斤「粒湍體博文代碼」；⑧1000-4668091=3047.6000（+-×÷）的精確運算，建立的人工智慧，他使計算機開始模仿博弈取勝的智慧；
三維支點感知、
三維支點思考、
三維支點意念、
它在三維支點上，進行的數碼邏輯運算給出了三個結果；
支點常數加1，結果小於1為神學，（人天代碼加地碼4000斤+1（-5000斤）=-1000斤）；
支點常數加1，結果大於1為科學，（人天代碼加地碼4000斤+1（5000斤）=+9000斤）；
天人代碼能夠被地碼整除（30000斤÷5000斤），天人代碼又能被地人代碼減、下餘一個小數為支點常數（效應、一個小目標）它的結果一定要小於1為博學，（30000斤-26000斤=4000斤）。
博弈取勝的人工智慧，「粒湍體博文代碼」，是人類認識未知世界，分別計算，神學、科學、博學，使用的數碼邏輯法則；
支點常數加1，結果小於1為神學，
支點常數加1，結果大於1為科學，
1除1減，支點常數小於1為博學。
它讓每一個人的手指上充滿人工智慧，點擊計算機鍵盤，體驗神學、科學、博學，觀賞人與自然博弈的神通，「一人、一指、一鍵，贏天下」。