Algorithm --> DFS和BFS

定义结点

struct MGraph
{
    int vexs[MAXVEX];        //顶点数组
    int arc[MAXVEX][MAXVEX]; //邻接矩阵
    int numVertex, numEdges;  //定点数 边数
};

深度优先遍历

图示

     

参考代码

bool visited[MAX];
void DFS(MGraph G, int i)
{
    cout << G.vexs[i] << " ";
　　 visited[i] = true;
    for (int j = 0; j < G.numVertex; ++j)
    {
        if (G.arc[i][j] == 1 && !visited[j])
            DFS(G, j);
       }
}
void DFSTranverse(MGraph G)
{
    for (int i = 0; i < G.numVertex; ++i)
        visited[i] = false;
    for (int i = 0 ; i < G.numVertex; ++i)  //如果是连通图，只执行一次
    {
        if (!visited[i])
            DFS(G, i);
    }
}

广度优先遍历

图示

     

参考代码

void BFSTranverse(MGraph G)
{
    queue<int> q;
    bool visited[G.numVertex];
    for (int i = 0; i < G.numVertex; ++i)
        visited[i] = false;
    for (int i = 0; i < G.numVertex; ++i)
    {
        if (!visited[i])
        {
            cout << G.vexs[i] << " ";
            q.push(i);
             visited[i] = true;
             while (!q.empty())
              {
                   int k = q.top();
                   q.pop();
                    for (int j = 0; j < G.numVertex; ++j)
                    {
                        if (G.arc[i][j] == 1 && !visitied(j))
                            {
                                cout << G.vexs[j] << " ";
                                visited[j] = true;
                                q.push(j);
                            }
                     }
                }
            }
　　　}//for
}

另一种：

void BFS()
{
    visited[1] = 1;
    queue q;
    q.push(1);
    while(!q.empty())
    {
       int top = q.front();
       cout << top<<" ";//输出
       q.pop();
       int i ;
       for(i = 1; i <= M; ++i)
       {
        if(visited[i] == 0 && matrix[top - 1][i - 1 ] == 1)
        {
         visited[i] = 1;
         q.push(i);
        }
       }
    }
}

/******************* 2015.07.06 update ************************/

BFS:

#include <stdio.h>

int o[4][2] = { { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, -1 } };
int map[10][10] = { 0 };

int queue[100][2] = {0};
int front = 0;
int back = 0;
int parent[10][10][2] = {0};

void BFS(int sY, int sX, int eY, int eX)
{
    queue[back][0] = sY;
    queue[back++][1] = sX;
    map[sY][sX] = 1;
    while (front < back)
    {
        int Y = queue[front][0];
        int X = queue[front][1];
        for (int i = 0; i < 4; i++)
        {
            int newY = Y + o[i][0];
            int newX = X + o[i][1];
            if (map[newY][newX] == 0)continue;
            if (map[newY][newX] > (map[Y][X] + 1))
            {
                map[newY][newX] = map[Y][X] + 1;
                parent[newY][newX][0] = Y;
                parent[newY][newX][1] = X;
                if ((newY == eY) && (newX == eX))
                {
                    return;
                }
                queue[back][0] = newY;
                queue[back++][1] = newX;
            }
        }

        front++;
    }
}

int main(int argc, char** argv)
{
    freopen("input.txt", "r", stdin);
    int N;
    scanf("%d
", &N);
    for (int case_num = 0; case_num < N; case_num++)
    {
        for (int i = 1; i <= 8; i++)
        {
            for (int j = 1; j <= 8; j++)
            {
                scanf("%d
", &map[i][j]);
                if (map[i][j] == 1)map[i][j] = 100;
            }
            scanf("
");
        }
    }

    BFS(1, 1, 8, 8);
    if (map[8][8] == 100)printf("failed
");
    else printf("%d
", map[8][8]);

    int x = 8, y = 8;
    int stack[100][2] = {0};
    int step = 0;
    while (x > 0 || y > 0)
    {
        stack[step][0] = y;
        stack[step++][1] = x;
        int newY = parent[y][x][0];
        int newX = parent[y][x][1];
        x = newX;
        y = newY;
    }

    for (int i = step - 1; i >= 0; i--)
    {
        printf("%d %d
", stack[i][0], stack[i][1]);
    }
}

DFS:

#include <stdio.h>

int o[4][2] = { { 1, 0 }, { 0, 1 }, { -1, 0 }, { 0, -1 } };
int map[10][10] = {0};
int minStep = 100;
int stack[100][2] = {0};
int step = 0;
int minStack[100][2] = {0};

void DFS(int sY, int sX, int eY, int eX)
{
    if (step >= minStep)return;
    if (map[sY][sX] == 0)return;
    stack[step][0] = sY;
    stack[step++][1] = sX;
    map[sY][sX] = 0;
    if ((sY == eY) && (sX == eX))
    {
        if (minStep > step)
        {
            minStep = step;
            for (int i = 0; i < step; i++)
            {
                minStack[i][0] = stack[i][0];
                minStack[i][1] = stack[i][1];
            }
        }
        map[sY][sX] = 1;
        step--;
        return;
    }
    for (int i = 0; i < 4; i++)
    {
        (DFS(sY + o[i][0], sX + o[i][1], eY, eX));
    }

    map[sY][sX] = 1;
    step--;
    return;
}

int main(int argc, char** argv)
{
    freopen("input.txt", "r", stdin);
    int N;
    scanf("%d
", &N);
    for (int case_num = 0; case_num < N; case_num++)
    {
        for (int i = 1; i <= 8; i++)
        {
            for (int j = 1; j <= 8; j++)
            {
                scanf("%d
", &map[i][j]);
            }
            scanf("
");
        }
    }

    DFS(1,1,8,8);
    printf("%d
", minStep-1);
    for (int i = 0; i < minStep; i++)
    {
        printf("%d %d
", minStack[i][0], minStack[i][1]);
    }
    //if (ret)printf("success
");
    //else printf("failed
");
}

input:

1
1 2 0 1 1 1 0 1 
2 3 0 1 1 0 0 1
2 3 1 3 0 0 1 1 
2 0 0 0 1 1 1 1 
2 3 3 0 1 1 0 1 
2 0 1 1 1 0 0 1 
2 0 0 0 1 0 0 1 
0 1 1 1 1 1 1 1