C++搜索与图论

hurricane_7

已于 2023-07-19 08:46:58 修改

阅读量99

点赞数

文章标签： c++ 图论开发语言

于 2023-07-18 19:28:19 首次发布

本文链接：https://blog.csdn.net/hurricane777777/article/details/131753933

版权

1.深度优先搜索 DFS

例题1：排列数字

#include <iostream>

using namespace std;

const int N = 10;

int n;
int path[N];
bool st[N];

void dfs(int u)
{
    if(u == n)
    {
        for(int i = 0; i < n; i ++ )    printf("%d ", path[i]);
        puts("");
        return;
    }

    for(int i = 1; i <= n; i ++)
    {
        if(!st[i])
        {
            path[u] = i; 
            st[i] = true;
            dfs(u + 1); 
            st[i] = false;
        }
    }
}

int main()
{
    cin >> n;
    dfs(0);
    return 0;
}

例题2：n皇后问题

// 第一种搜索顺序
#include <iostream>

using namespace std;

const int N = 20;

int n;
char g[N][N];
bool col[N], dg[N], udg[N];

void dfs(int u)
{
    if(u == n)
    {
        for(int i = 0; i < n; i ++ )    puts(g[i]);
        puts("");
        return;
    }

    for(int i = 0; i < n; i ++)
    {
        if(!col[i] && !dg[u + i] && !udg[n - u + i]) 
        {
            g[u][i] = 'Q'; 
            col[i] = dg[u + i] = udg[n - u + i] = true;
            dfs(u + 1); 
            col[i] = dg[u + i] = udg[n - u + i] = false;
            g[u][i] = '.';
        }
    }
}

int main()
{
    cin >> n;
    for(int i = 0; i < n ; i ++)
        for (int j = 0; j < n; j ++)
            g[i][j] = '.';

    dfs(0);
    return 0;
}

// 第二种搜索顺序
#include <iostream>

using namespace std;

const int N = 20;

int n;
char g[N][N];
bool row[N], col[N], dg[N], udg[N];

void dfs(int x, int y, int s)
{
    if(y == n)  y = 0, x ++;

    if(x == n) 
    {
        if(s == n)
        {
            for(int i = 0; i < n; i++)  puts(g[i]);
            puts("");
        }
        return;
    }

    // 不放皇后
    dfs(x, y + 1, s);

    // 放皇后
    if(!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n])
    {
        g[x][y] = 'Q';
        row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
        dfs(x, y + 1, s + 1);
        row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
        g[x][y] = '.';
    }

}

int main()
{
    cin >> n;
    for(int i = 0; i < n ; i ++)
        for (int j = 0; j < n; j ++)
            g[i][j] = '.';

    dfs(0, 0, 0);
    return 0;
}

2.宽度优先搜索 BFS

边权都为1，可以搜到最短路，一层一层搜索

例题1：走迷宫

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

typedef pair<int, int> PII;

const int N = 110;

int n, m;
int g[N][N];
int d[N][N];
PII q[N * N];

int bfs()
{
    int hh = 0, tt = 0;
    q[0] = {0, 0};

    memset(d, -1, sizeof d);
    d[0][0] = 0;
     
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

    while( hh <= tt)
    {
        auto t = q[hh++];
        
        for(int i = 0; i < 4; i++ )
        {
            int x = t.first + dx[i], y = t.second + dy[i]; 
            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
            {
                d[x][y] = d[t.first][t.second] + 1;
                q[++ tt] = {x, y};
            }
        }
    }
    return d[n - 1][m - 1];
}

int main()
{
    cin >> n >> m;
    for(int i = 0; i < n ; i ++)
        for (int j = 0; j < m; j ++)
            cin >> g[i][i];

    cout << bfs() << endl;    

    
    return 0;
}

3.树与图的存储

树是特殊的图（无环连通图）。

图分为2种：有向图和无向图

有向图：1.邻接矩阵g[a,b] 2.邻接表

4.树与图的深度优先遍历

例题1：树的重心

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 100010, M = N * 2;

int n;
int h[N], e[M], ne[M], idx;
bool st[N];

int ans = N;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++; 
}

// 以u为根的子树中点的数量
int dfs(int u)
{
    st[u] = true; // 标记一下，已经被搜过了

    int sum = 1, res = 0; //sum 当前子树的大小， res 把这个点删除后每一个连通块大小的最大值 
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];   
        if(!st[j]) 
        {
            int s = dfs(j); // 当前子树的大小
            res = max(res, s); 
            sum += s;
        }
    }

    res = max(res, n - sum);
    ans = min(ans, res);
    return  sum;
}

int main()
{
    cin >> n; 
    memset(h, -1, sizeof h);

    for(int i = 0; i < n - 1; i++)
    {
        int a, b;
        cin >> a >> b;
        add(a, b), add(b, a);
    }
    dfs(1);

    cout << ans << endl;

    return 0;
}

5.树与图的宽度优先遍历

例题1：图中点的层次

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], idx;
int d[N],q[N];


int ans = N;

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

int bfs()
{
    int hh = 0, tt = 0;
    q[0] = 1;

    memset(d, -1, sizeof d); 

    d[1] = 0;

    while(hh <= tt)
    {
        int t = q[hh ++];
        
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(d[j] == -1)
            {
                d[j] = d[t] + 1;
                q[ ++ tt] = j; 
            }
        }
    }
    return d[n];
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);

    for(int i = 0; i < m; i ++)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }

    cout << bfs() << endl;

    return 0;
}

6.拓扑排序

有向图拓扑序列有向无环图→拓扑图

例题：有向图的拓扑序列

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 100010;

int n, m;
int h[N], ne[N], e[N], idx;
int q[N], d[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

bool topsort()
{
    int hh = 0, tt = -1;
    for(int i = 1; i <= n; i ++)
        if(!d[i])
            q[++tt] = i;
    
    while(hh <= tt)
    {
        int t = q[hh ++];

        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            d[j] --;
            if(d[j] == 0)   q[++ tt] = j;
        }
    }

    return tt == n - 1;
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    
    for(int i = 0; i < m; i ++ )
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
        d[b] ++ ; // 入度+1
    }

    if(topsort())
    {
        for(int i = 0; i < n; i ++) printf("%d ", q[i]);
        puts("");
    }
    else    puts("-1");

    return 0;
}

7. 最短路

两大类：

（源点：起点；汇点：终点）

1.单源最短路

（1）所有边权都是正数

①朴素Dijkstra算法 O(n^2) (n是点的数量, m是边的数量)

②堆优化版的Dijkstra算法 O(mlogn) (n是点的数量 , m是边的数量)

（2）存在负权边

①Bellman-Ford O(nm)

②SPFA 一般O(m)，最坏O(nm)

2.多源汇最短路 Floyd算法 O(n^3)

（1）朴素Dijkstra

S：当前已确定最短距离的点

①dist[1] = 0, dist[i] = +∞

②for i 0 ~ n

t ⬅不在S中，距离最近的点

S⬅t

用t更新其他点的距离

例题1：Dijkstra求最短路Ⅰ

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 510;

int n, m;
int g[N][N];
int dist[N];
bool st[N];

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for(int i = 0 ; i < n; i ++ )
    {
        int t = -1;
        for(int j = 1; j <= n ; j ++)
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;   
        
        st[t] = true;

        for(int j = 1; j <= n; j ++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
    }

    if(dist[n] == 0x3f3f3f3f)   return -1;
    return dist[n];
}

int main()
{
    scanf("%d%d", &n , &m);

    memset(g, 0x3f, sizeof g);

    while(m --)
    {
        int a, b, c;
        scanf("%d%d%d", &a,  &b, &c);
        g[a][b] = min(g[a][b], c);
    }

    int t = dijkstra();

    printf("%d\n", t);

    return 0;
}