基本算法DFS以及BFS

图的深搜

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>

using namespace std;
const int maxn = 100;

int G[maxn][maxn], vis[maxn];
int n, m;
vector<int> ans;

void dfs(int start) {
    vis[start] = 1;
    ans.push_back(start);

    for(int i = 0; i < n; i++)
        if(!vis[i] && G[start][i])  dfs(i);
}

int main()
{
    printf("please enter the number of  nodes and sides:\n");
    scanf("%d", &n);    scanf("%d", &m);

    int u, v, val;      memset(G, 0, sizeof(G));        //首先要清空临接矩阵
    printf("crate the matrix:\n");
    for(int i = 0; i < m; i++) {        //建立临接矩阵
        scanf("%d%d%d", &u, &v, &val);
        G[u][v] = val;
//        G[v][u] = val;  //如果是无向图就得加上这句话
    }

    printf("enter the start:\n");
    int start;  scanf("%d", &start);

    ans.clear();        //首先要清空ans里面的残留数据
    memset(vis, 0, sizeof(vis));
    dfs(start);

    printf("the search path:\n");
    printf("%d", ans[0]);
    for(int i = 1; i < ans.size(); i++)         printf("-->%d", ans[i]);
    printf("\n");
    return 0;
}

当某种情况需要的节点过多，必须直接开较大的数组，如果依然用二维数组来保存临接矩阵，这时就会出现一下的异常：

所以采用如下方法将数组变成用vector的一维数组

/*对于节点过多的情况，直接开数组来表示临接矩阵就不可行了，
而采用临接链表的方式查找一条边又很麻烦，一下代码是基本就是临接链表做了一点改进*/
#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>

using namespace std;
const int maxn = 10000000 + 5;

struct Side {   //如果是有权图的话需要用结构体来存储权值
    int u, v, val;
    Side(int u = 0, int v = 0, int val = 0) : u(u), v(v), val(val) {}
};

vector<Side> sideVec;   //用这个vec来存储边
vector<int> G[maxn];    /*可以把这个vec看成类似临接链表中的主链表，也可以写成vector<vector<int> > G;能提升运行效率，因为初始化vector数组也需要大量时间,注意两个'>'要分开，不然编译器无法识别*/
vector<int> ans;            //用来存放节点访问顺序
int n, m, start;                        //节点的个数以及边的数量

void addSide(int a, int b, int cos) {
    sideVec.push_back(Side(a, b, cos));
    int dex = sideVec.size() - 1;
    G[a].push_back(dex);    //只保存在sideVec中的下标而不是节点b是为了能够访问到权值
}

void dfs(int start, bool vis[]) {
    vis[start] = true;
    for(int i = 0; i < G[start].size(); i++) {
        int idex = G[start][i];
        int v = sideVec[idex].v;    //v是与start相邻的节点
        if(!vis[v])     {ans.push_back(v);  dfs(v, vis);}
    }
}

int main()
{
    printf("enter the number of nodes and sides\n");
    scanf("%d%d", &n, &m);

    int u, v, val;
    printf(("create the matrix\n"));
    for(int i = 0; i < m; i++) {    //先创建图的整体结构
        scanf("%d%d%d", &u, &v, &val);
        addSide(u, v, val); //增加边
//        addSide(v, u, val); //暂且先假设为无向图
    }

    printf("enter the start node:\n");
    scanf("%d", &start);
    ans.clear();
    ans.push_back(start);

    bool vis[n + 5];
    memset(vis, 0, sizeof(vis));
    dfs(start, vis);

    printf("the search path:\n");
    printf("%d", ans[0]);
    for(int i = 1; i < ans.size(); i++)         printf("-->%d", ans[i]);
    printf("\n");
    return 0;
}

图的广搜

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>

using namespace std;
const int maxn = 100;

int G[maxn][maxn], vis[maxn];
int n, m;   //图的节点和边
vector<int> ans;

void bfs(int start) {
    queue<int> q;
    q.push(start);
    memset(vis, 0, sizeof(vis));    vis[start] = 1;
    int u;

    while(!q.empty()) {
        u = q.front();
        ans.push_back(u);
        q.pop();
        for(int i = 0; i < n; i++)
            if(!vis[i] && G[u][i]) {q.push(i);      vis[i] = 1;}
    }
}

int main()
{
    printf("please enter the number of  nodes and sides:\n");
    scanf("%d", &n);    scanf("%d", &m);

    int u, v, val;      memset(G, 0, sizeof(G));        //首先要清空临接矩阵
    printf("crate the matrix:\n");
    for(int i = 0; i < m; i++) {        //建立临接矩阵
        scanf("%d%d%d", &u, &v, &val);
        G[u][v] = val;
        G[v][u] = val;  //如果是无向图就得加上这句话
    }

    printf("enter the start:\n");
    int start;  scanf("%d", &start);

    ans.clear();        //首先要清空ans里面的残留数据
    bfs(start);

    printf("the search path:\n");
    printf("%d", ans[0]);
    for(int i = 1; i < ans.size(); i++)         printf("-->%d", ans[i]);
    printf("\n");
    return 0;
}

对于处理数量较大节点的BFS同样如下：

#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>

using namespace std;
const int maxn = 10000000 + 5;

struct Side {   //如果是有权图的话需要用结构体来存储权值
    int u, v, val;
    Side(int u = 0, int v = 0, int val = 0) : u(u), v(v), val(val) {}
};

vector<Side> sideVec;   //用这个vec来存储边
vector<int> G[maxn];    //可以把这个vec看成类似临接链表中的主链表
vector<int> ans;            //用来存放节点访问顺序
int n, m, start;               //节点的个数以及边的数量

void addSide(int a, int b, int cos) {
    sideVec.push_back(Side(a, b, cos));
    int dex = sideVec.size() - 1;
    G[a].push_back(dex);    //只保存在sideVec中的下标而不是节点b是为了能够访问到权值
}

void bfs(int start, bool vis[]) {
    queue<int> q;
    q.push(start);  vis[start] = true;

    int u;
    while(!q.empty()) {
        u = q.front();  q.pop();
        for(int i = 0; i < G[u].size(); i++) {
            int idex = G[u][i];
            int v = sideVec[idex].v;
            if(!vis[v]) {
                ans.push_back(v);
                q.push(v);
                vis[v] = true;
            }
        }
    }
}

int main()
{
    printf("enter the number of nodes and sides\n");
    scanf("%d%d", &n, &m);

    int u, v, val;
    printf(("create the matrix\n"));
    for(int i = 0; i < m; i++) {    //先创建图的整体结构
        scanf("%d%d%d", &u, &v, &val);
        addSide(u, v, val); //增加边
//        addSide(v, u, val); //暂且先假设为无向图
    }

    printf("enter the start node:\n");
    scanf("%d", &start);
    ans.clear();
    ans.push_back(start);

    bool vis[n + 5];
    memset(vis, 0, sizeof(vis));
    bfs(start, vis);

    printf("the search path:\n");
    printf("%d", ans[0]);
    for(int i = 1; i < ans.size(); i++)         printf("-->%d", ans[i]);
    printf("\n");
    return 0;
}

接下来是例题，uvaOJ1599。上面处理大量节点的DFS/BFS代码基本来自于此题，照搬RuJia
题目描述：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=51300
代码如下：

/*这道题可以用BFS解决，但是记录父节点的方法不能保证打印出来的路径字典序最小，所以解决方法是从终点倒着BFS，得到每个节点到终点的最小距离d[i]（注意此时的图要看作无向无权图）。然后就可从起点开始BFS，到达一个节点时要保证d值减少1*/
#include <iostream>
#include <cstdio>
#include <vector>   //因为直接开数组占用的内存会过大而无法运行，所以使用vector
#include <queue>
#include <cstring>
#include <algorithm>

using namespace std;
const int maxn = 100000 + 5;
const int INF = 1000000000;

struct Side {
    int u, v, val;
    Side(int u = 0, int v = 0, int val = 0) : u(u), v(v), val(val) {}
};

vector<Side> sideVec;
vector<int> winLoad;
vector<int> graph[maxn];
int n, m, d[maxn];
int visit[maxn];

void addSide(int a, int b, int val) {
    sideVec.push_back(Side(a, b, val));
    int dex = sideVec.size() - 1;
    graph[a].push_back(dex);
}

void revBfs() {
    queue<int> q;
    memset(visit, 0, sizeof(visit));
    q.push(n - 1);      visit[n - 1] = 1;
    d[n-1] = 0;

    while(!q.empty()) {
        int k = q.front();  q.pop();
        for(int i = 0; i < graph[k].size(); i++) {
            int dex = graph[k][i];
            int u = sideVec[dex].v;
            if(!visit[u]) {
                visit[u] = 1;
                d[u] = d[k] + 1;
                q.push(u);
            }
        }
    }
}

void bfs() {
    memset(visit, 0, sizeof(visit));
    visit[0] = 1;
    winLoad.clear();

    vector<int> next;
    next.push_back(0);
    for(int i = 0; i < d[0]; i++) {
        int minVal = INF;
        for(int j = 0; j < next.size(); j++) {  //负责把最小的颜色编号存进winLoad中
            int u = next[j];
            for(int k = 0; k < graph[u].size(); k++) {
                int dex = graph[u][k];
                int v = sideVec[dex].v;
                if(d[u] == d[v] + 1)    minVal = min(minVal, sideVec[dex].val);
            }
        }

        winLoad.push_back(minVal);

        vector<int> next2;
        for(int j = 0; j < next.size(); j++) {
            int u = next[j];
            for(int k = 0; k < graph[u].size(); k++) {
                int dex = graph[u][k];
                int v = sideVec[dex].v;
                if(d[u] == d[v] + 1 && !visit[v] && sideVec[dex].val == minVal) {
                    visit[v] = 1;
                    next2.push_back(v);
                }
            }
        }
        next = next2;
    }

        printf("%d\n", winLoad.size());
        printf("%d", winLoad[0]);
        for(int i = 1; i < winLoad.size(); i++) printf(" %d", winLoad[i]);
        printf("\n");
}

int main()
{
    while(scanf("%d%d", &n, &m) == 2) {
        //sideVec.size();
        for(int i = 0; i < n; i++)     graph[i].clear();

        int a, b, val;
        for(int i = 1; i <= m; i++) {
            scanf("%d%d%d", &a, &b, &val);
            addSide(a-1, b-1, val);
            addSide(b-1, a-1, val);
        }
        revBfs();    //从终点开始bfs,求出每个点到终点的最小无权距离
        bfs();


    }
    return 0;
}