搜素与图论总结（一）

最新推荐文章于 2024-07-12 18:56:03 发布

尘封陌路

最新推荐文章于 2024-07-12 18:56:03 发布

阅读量86

点赞数

文章标签：算法队列图论 dfs

本文链接：https://blog.csdn.net/weixin_51670469/article/details/113483104

版权

DFS模板

以全排列为例子

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
int a[10];
int n;
bool st[10];

void dfs(int u)
{
    if(u==n) 
    {
        for(int i=0;i<n;i++) cout<<a[i]<<' ';
        cout<<endl;
        return ;
    }
    for(int i=1;i<=n;i++)
    {
        if(!st[i])
        {
            a[u]=i;
            st[i]=true;
            dfs(u+1);
            st[i]=false;
        }
    }
    
}

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

2.n皇后问题

在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
const int N=15;
char g[N][N];
int n;
bool row[N],dg[N],udg[N];
void dfs(int u)
{
    if(u==n) 
    {
        for(int i=0;i<n;i++) cout<<g[i]<<endl;
        cout<<endl;
        return ;
    }
    for(int i=0;i<n;i++)
    {
        if(!row[i]&&!dg[u+i]&&!udg[-u+i+n])
        {
            g[u][i]='Q';
            row[i]=dg[u+i]=udg[-u+i+n]=true;
            dfs(u+1);
            row[i]=dg[u+i]=udg[-u+i+n]=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;
}

BFS模板
在这里插入图片描述
1.数组模拟队列

#include<bits/stdc++.h>
using namespace std;
const int N=110;
typedef pair<int,int> PII;

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][j];
	}
	cout<<bfs()<<endl;
	return 0;
}

2.STL队列实现

#include<bits/stdc++.h>
using namespace std;
const int N=110;
//typedef pair<int,int> PII;

int n,m;
int g[N][N];
int d[N][N];
//PII q[N*N];
queue<pair<int,int>> q;
int bfs()
{
	q.push({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(q.size())
	{
		auto t=q.front();//取队头+弹出队头 
		q.pop();
		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.push({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][j];
	}
	cout<<bfs()<<endl;
	return 0;
}

最短路问题

在这里插入图片描述
朴素Dijkstra 算法
思路：

#include<bits/stdc++.h>
using namespace std;
const int N=510,M=100010;
int dist[N],g[N][N];
int n,m;
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;
    else return dist[n];
}
int main()
{
    cin>>n>>m;
    memset(g,0x3f,sizeof(g));
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);
    }
    cout<<dijkstra()<<endl;
    return 0;
}

堆优化的dijkstra算法

#include<bits/stdc++.h>
using namespace std;
const int N=150010;
int h[N],w[N],e[N],idx,ne[N],dist[N];
int d[N];
bool st[N];
int n,m;
typedef pair<int,int> PII;
void add(int a,int b,int c)
{
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}
int dijkstra()
{
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    priority_queue<PII,vector<PII>,greater<PII>> heap;
    heap.push({0,1});
    while(heap.size())
    {
        auto t=heap.top();
        heap.pop();
        int ver=t.second,distance=t.first;
        if(st[ver]) continue;
        st[ver]=true;
        for(int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>distance+w[i])
            {
                dist[j]=distance+w[i];
                heap.push({dist[j],j});
            }
        }
    }
    if(dist[n]==0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    memset(h,-1,sizeof(h));
    cin>>n>>m;
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    cout<<dijkstra()<<endl;
    return 0;
    
}

Bellman_ford算法

使用条件：
题目中有负权边，且限定只能走k条边。
在这里插入图片描述

思路：
在这里插入图片描述

#include<iostream>
#include<cstring>

using namespace std;

const int N = 510, M = 10010;

struct Edge {
    int a;
    int b;
    int w;
} e[M];//把每个边保存下来即可
int dist[N];
int back[N];//备份数组防止串联
int n, m, k;//k代表最短路径最多包涵k条边

int bellman_ford() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < k; i++) {//k次循环
        memcpy(back, dist, sizeof dist);
        for (int j = 0; j < m; j++) {//遍历所有边
            int a = e[j].a, b = e[j].b, w = e[j].w;
            dist[b] = min(dist[b], back[a] + w);
            //使用backup:避免给a更新后立马更新b, 这样b一次性最短路径就多了两条边出来
        }
    }
    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    else return dist[n];

}

int main() {
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 0; i < m; i++) {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        e[i] = {a, b, w};
    }
    int res = bellman_ford();
    if (res == -1) puts("impossible");
    else cout << res;

    return 0;
}

Spfa算法

**
spfa算法是bellman_ford的队列优化版本, bfs实现
优化的是dist[b] = min(dist[b], dist[a]+w)
因为只有dist[a]更新之后变小, dist[b]更新之后才有可能变小
需要st[i]数组，保证队列里面只有一个i;

在这里插入图片描述

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

const int N=1e5+10;

#define fi first
#define se second

typedef pair<int,int> PII;//到源点的距离，下标号

int h[N],e[N],w[N],ne[N],idx=0;
int dist[N];//各点到源点的距离
bool st[N];
int n,m;
void add(int a,int b,int c){
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}

int spfa(){
    queue<PII> q;
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    q.push({0,1});
    st[1]=true;
    while(q.size()){
        PII p=q.front();
        q.pop();
        int t=p.se;
        st[t]=false;//从队列中取出来之后该节点st被标记为false,代表之后该节点如果发生更新可再次入队
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                if(!st[j]){//当前已经加入队列的结点，无需再次加入队列，即便发生了更新也只用更新数值即可，重复添加降低效率
                    st[j]=true;
                    q.push({dist[j],j});
                }
            }
        }
    }
    if(dist[n]==0x3f3f3f3f) return -1;
    else return dist[n];
}

int main(){
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    while(m--){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    int res=spfa();
    if(res==-1) puts("impossible");
    else printf("%d",res);

    return 0;
}

尘封陌路

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
搜素与图论总结（一）

DFS模板以全排列为例子#include<bits/stdc++.h>using namespace std;int a[10];int n;bool st[10];void dfs(int u){ if(u==n) { for(int i=0;i<n;i++) cout<<a[i]<<' '; cout<<endl; return ; } for(in
复制链接

扫一扫