馬的極小滿覆蓋演算法

『壹』 近似演算法的頂點覆蓋問題的近似演算法

問題描述：無向圖G=(V,E)的頂點覆蓋是它的頂點集V的一個子集V』，使得若(u,v)是G的一條邊，則v∈V』或u∈V』。頂點覆蓋V』的大小是它所包含的頂點個數|V』|。
VertexSet approxVertexCover ( Graph g )
{ cset=NULL；
e1=g.e；
while (e1 !=NULL) {
從e1中任取一條邊(u,v)；
cset=cset∪{u,v}；
從e1中刪去與u和v相關聯的所有邊；
}
return c
}
Cset用來存儲頂點覆蓋中的各頂點。初始為空，不斷從邊集e1中選取一邊(u,v)，將邊的端點加入cset中，並將e1中已被u和v覆蓋的邊刪去，直至cset已覆蓋所有邊。即e1為空。
圖(a)～(e)說明了演算法的運行過程及結果。(e)表示演算法產生的近似最優頂點覆蓋cset，它由頂點b,c,d,e,f,g所組成。(f)是圖G的一個最小頂點覆蓋，它只含有3個頂點：b,d和e。

『貳』 馬的遍歷 馬在8*8的棋盤上能遍歷嗎

此題涉及到貪婪法演算法，它是一種不追求最優解，只希望得到較為滿意解的方法。貪婪法一般可以快速得到滿意的解，因為它省去了為找最優解要窮盡所有可能而必須耗費的大量時間。貪婪法常以當前情況為基礎作最優選擇，而不考慮各種可能的整體情況，所以貪婪法不要回溯。

馬在某個方格，可以在一步內到達的不同位置最多有8個，如用二維數組board[ ][ ]表示棋盤，其元素記錄馬經過該位置時的步驟號。另對馬的8種可能走法（稱為著法）設定一個順序，如當前位置在棋盤的（i，j）方格，下一個可能的位置依次為（i+2，j+1）、（i+1，j+2）、（i-1，j+2）、（i-2，j+1）、（i-2，j-1）、（i-1，j-2）、（i+1，j-2）、（i+2，j-1），實際可以走的位置盡限於還未走過的和不越出邊界的那些位置。為便於程序的同意處理，可以引入兩個數組，分別存儲各種可能走法對當前位置的縱橫增量。
4 3
5 2
馬
6 1
7 0

對於本題，一般可以採用回溯法，這里採用Warnsdoff策略求解，這也是一種貪婪法，其選擇下一出口的貪婪標準是在那些允許走的位置中，選擇出口最少的那個位置。如馬的當前位置（i，j）只有三個出口，他們是位置（i+2，j+1）、（i-2，j+1）和（i-1，j-2），如分別走到這些位置，這三個位置又分別會有不同的出口，假定這三個位置的出口個數分別為4、2、3，則程序就選擇讓馬走向（i-2，j+1）位置。
由於程序採用的是一種貪婪法，整個找解過程是一直向前，沒有回溯，所以能非常快地找到解。但是，對於某些開始位置，實際上有解，而該演算法不能找到解。對於找不到解的情況，程序只要改變8種可能出口的選擇順序，就能找到解。改變出口選擇順序，就是改變有相同 出口時的選擇標准。以下程序考慮到這種情況，引入變數start，用於控制8種可能著法的選擇順序。開始時為0，當不能找到解時，就讓start增1，重新找解。細節以下程序。
【程序】
# include <stdio.h>
int delta_i[ ]={2,1,-1,-2,-2,-1,1,2};
int delta_j[ ]={1,2,2,1,-1,-2,-2,-1};
int board[8][8];
int exitn(int i,int j,int s,int a[ ])
{ int i1,j1,k,count;
for (count=k=0;k<8;k++)
{ i1=i+delta_i[(s+k)%8];
j1=i+delta_j[(s+k)%8];
if (i1>=0&&i1<8&&j1>=0&&j1<8&&board[I1][j1]==0)
a[count++]=(s+k)%8;
}
return count;
}

int next(int i,int j,int s)
{ int m,k,mm,min,a[8],b[8],temp;
m=exitn(i,j,s,a);
if (m==0) return –1;
for (min=9,k=0;k<m;k++)
{ temp=exitn(I+delta_i[a[k]],j+delta_j[a[k]],s,b);
if (temp<min)
{ min=temp;
kk=a[k];
}
}
return kk;
}

void main()
{ int sx,sy,i,j,step,no,start;
for (sx=0;sx<8;sx++)
for (sy=0;sy<8;sy++)
{ start=0;
do {
for (i=0;i<8;i++)
for (j=0;j<8;j++)
board[j]=0;
board[sx][sy]=1;
I=sx; j=sy;
For (step=2;step<64;step++)
{ if ((no=next(i,j,start))==-1) break;
I+=delta_i[no];
j+=delta_j[no];
board[j]=step;
}
if (step>64) break;
start++;
} while(step<=64)
for (i=0;i<8;i++)
{ for (j=0;j<8;j++)
printf(「%4d」,board[j]);
printf(「\n\n」);
}
scanf(「%*c」);
}
}

『叄』 馬的走法C語言演算法

#include<stdio.h>

/*
* 求(x1,y1)向右走到(y1,y2)可行的走法總數
*/
int getWays(int x1, int y1, int x2, int y2)
{
if(y1 > y2) //在目標右邊
return 0;
else if(y1 == y2 && x1 != x2) //在目標一條垂直線上，但不是同一點
return 0;
else if(y1 == y2 && x1 == x2) //跟目標是同一點
return 1;
else{ //分治，求四種走法的總和
int result =0;
if(x1 > 1) //可以上1
result += getWays(x1 - 1, y1 + 2, x2, y2);
if(x1 > 2) //可以上2
result += getWays(x1 - 2, y1 + 1, x2, y2);
if(x1 < 5) //可以下1
result += getWays(x1 + 1, y1 + 2, x2, y2);
if(x1 < 4) //可以下2
result += getWays(x1 + 2, y1 + 1, x2, y2);
return result;
}
}

void main(void)
{
int x,y; //目標坐標

printf("請輸入目標坐標：\n");
scanf("%d%d", &x, &y);

printf("總的不同走法：%d\n",getWays(1, 1, x, y));
}

不明白，再交流...

『肆』 在中國象棋棋盤上實現上一課題的任務：在中國象棋棋盤上，如果放置若干個馬後，使得整個棋盤後的任意空位

我想是這樣的吧。

『伍』 數據結構課程設計報告 馬的遍歷 麻煩了

//圖的遍歷演算法程序

//圖的遍歷是指按某條搜索路徑訪問圖中每個結點，使得每個結點均被訪問一次，而且僅被訪問一次。圖的遍歷有深度遍歷演算法和廣度遍歷演算法，程序如下：
#include <iostream>
//#include <malloc.h>
#define INFINITY 32767
#define MAX_VEX 20 //最大頂點個數
#define QUEUE_SIZE (MAX_VEX+1) //隊列長度
using namespace std;
bool *visited; //訪問標志數組
//圖的鄰接矩陣存儲結構
typedef struct{
char *vexs; //頂點向量
int arcs[MAX_VEX][MAX_VEX]; //鄰接矩陣
int vexnum,arcnum; //圖的當前頂點數和弧數
}Graph;
//隊列類
class Queue{
public:
void InitQueue(){
base=(int *)malloc(QUEUE_SIZE*sizeof(int));
front=rear=0;
}
void EnQueue(int e){
base[rear]=e;
rear=(rear+1)%QUEUE_SIZE;
}
void DeQueue(int &e){
e=base[front];
front=(front+1)%QUEUE_SIZE;
}
public:
int *base;
int front;
int rear;
};
//圖G中查找元素c的位置
int Locate(Graph G,char c){
for(int i=0;i<G.vexnum;i++)
if(G.vexs[i]==c) return i;
return -1;
}
//創建無向網
void CreateUDN(Graph &G){
int i,j,w,s1,s2;
char a,b,temp;
printf("輸入頂點數和弧數:");
scanf("%d%d",&G.vexnum,&G.arcnum);
temp=getchar(); //接收回車
G.vexs=(char *)malloc(G.vexnum*sizeof(char)); //分配頂點數目
printf("輸入%d個頂點.\n",G.vexnum);
for(i=0;i<G.vexnum;i++){ //初始化頂點
printf("輸入頂點%d:",i);
scanf("%c",&G.vexs[i]);
temp=getchar(); //接收回車
}
for(i=0;i<G.vexnum;i++) //初始化鄰接矩陣
for(j=0;j<G.vexnum;j++)
G.arcs[i][j]=INFINITY;
printf("輸入%d條弧.\n",G.arcnum);
for(i=0;i<G.arcnum;i++){ //初始化弧
printf("輸入弧%d:",i);
scanf("%c %c %d",&a,&b,&w); //輸入一條邊依附的頂點和權值
temp=getchar(); //接收回車
s1=Locate(G,a);
s2=Locate(G,b);
G.arcs[s1][s2]=G.arcs[s2][s1]=w;
}
}
//圖G中頂點k的第一個鄰接頂點
int FirstVex(Graph G,int k){
if(k>=0 && k<G.vexnum){ //k合理
for(int i=0;i<G.vexnum;i++)
if(G.arcs[k][i]!=INFINITY) return i;
}
return -1;
}
//圖G中頂點i的第j個鄰接頂點的下一個鄰接頂點
int NextVex(Graph G,int i,int j){
if(i>=0 && i<G.vexnum && j>=0 && j<G.vexnum){ //i,j合理
for(int k=j+1;k<G.vexnum;k++)
if(G.arcs[i][k]!=INFINITY) return k;
}
return -1;
}
//深度優先遍歷
void DFS(Graph G,int k){
int i;
if(k==-1){ //第一次執行DFS時,k為-1
for(i=0;i<G.vexnum;i++)
if(!visited[i]) DFS(G,i); //對尚未訪問的頂點調用DFS
}
else{
visited[k]=true;
printf("%c ",G.vexs[k]); //訪問第k個頂點
for(i=FirstVex(G,k);i>=0;i=NextVex(G,k,i))
if(!visited[i]) DFS(G,i); //對k的尚未訪問的鄰接頂點i遞歸調用DFS
}
}
//廣度優先遍歷
void BFS(Graph G){
int k;
Queue Q; //輔助隊列Q
Q.InitQueue();
for(int i=0;i<G.vexnum;i++)
if(!visited[i]){ //i尚未訪問
visited[i]=true;
printf("%c ",G.vexs[i]);
Q.EnQueue(i); //i入列
while(Q.front!=Q.rear){
Q.DeQueue(k); //隊頭元素出列並置為k
for(int w=FirstVex(G,k);w>=0;w=NextVex(G,k,w))
if(!visited[w]){ //w為k的尚未訪問的鄰接頂點
visited[w]=true;
printf("%c ",G.vexs[w]);
Q.EnQueue(w);
}
}
}
}

//主函數
void main(){
int i;
Graph G;
CreateUDN(G);
visited=(bool *)malloc(G.vexnum*sizeof(bool));
printf("\n廣度優先遍歷: ");
for(i=0;i<G.vexnum;i++)
visited[i]=false;
DFS(G,-1);
printf("\n深度優先遍歷: ");
for(i=0;i<G.vexnum;i++)
visited[i]=false;
BFS(G);
printf("\n程序結束.\n");
}
輸出結果為（紅色為鍵盤輸入的數據，權值都置為1）：
輸入頂點數和弧數:8 9
輸入8個頂點.
輸入頂點0:a
輸入頂點1:b
輸入頂點2:c
輸入頂點3:d
輸入頂點4:e
輸入頂點5:f
輸入頂點6:g
輸入頂點7:h
輸入9條弧.
輸入弧0:a b 1
輸入弧1:b d 1
輸入弧2:b e 1
輸入弧3:d h 1
輸入弧4:e h 1
輸入弧5:a c 1
輸入弧6:c f 1
輸入弧7:c g 1
輸入弧8:f g 1
廣度優先遍歷: a b d h e c f g
深度優先遍歷: a b c d e f g h
程序結束.

『陸』 最小滿覆蓋 中國象棋

呵呵
多看棋書會提高象棋水平的