暑期集训第三周

最新推荐文章于 2024-07-24 09:58:02 发布

晰里不糊涂

最新推荐文章于 2024-07-24 09:58:02 发布

阅读量95

点赞数 1

分类专栏：暑期集训文章标签：深度优先算法图论广度优先

本文链接：https://blog.csdn.net/L_txi/article/details/132011311

版权

暑期集训专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细介绍了图论中的深度优先搜索（DFS）和广度优先搜索（BFS）算法，包括它们在解决最短路径和连通性问题中的应用。同时，讨论了链式前向星作为图存储结构的使用，并给出了具体的编程题示例和解题思路。

摘要由CSDN通过智能技术生成

一、本周

1.手速赛dayday + 排位赛

2.图论【dfs，bfs，最短路径，树与图的存储遍历】

3.好多好多好多题没补。。。。。。

二、收获++

一、知识点总结：

一、DFS

feel：化成一棵树，从树的顶一直深入到尾，再从尾往上回溯

注意点：

1.递归函数写完，恢复现场很重要【因为深处的枝条对浅处的枝条没有影响，要vis恢复】

2.位于叶子结点满足条件的时候【eg.u>v】输出答案

典中典

题目：【活动 - AcWing】

题目：给定一个整数 n，将数字 1∼n排成一排，将会有很多种排列方法。现在，请你按照字典序将所有的排列方法输出。

思路：按顺序放数字，画树枝图，dfs出答案！递归每一层，且每一层都循环一遍数字，若前者无用则可放

代码实现：

vector<int> ans;
vector<bool> vis;
int n;
void dfs(int u)//第i个数递归，层数递归
{
    if (u == n+1)//第三个数遍历完，也就是第三层遍历完，才能够输出答案！
    {
        for (int i = 1; i <= n; i++)
        {
            cout << ans[i] << " ";
        }
            cout << endl;
            return; 
    }
    else
    {
        for (int i = 1; i <= n; i++)
        {
            if (!vis[i])
            {
                vis[i] = true;
                ans[u] = i;
                dfs(u + 1);
                vis[i] = false;
            }
        }
    }
}
void solve()
{
    vis.clear(),ans.clear();

    cin >> n;

    ans.resize(n + 1);
    vis.resize(n + 1);

    dfs(1);

}

巩固

题目：

有一个n，m的地图，.表示空地，#表示墙，求放k个X使空地依旧可连通

【Problem - 377A - Codeforces】

思路：

可联通--->连通联想到深搜，一条路可以走到黑，那么要放的地方就是最后的叶子，对前面的联通不会造成影响

逆向思维：要放k个X使剩下的.可联通《---》要放t-k个.使点可联通

代码实现：

int n, m, k,cnt;
vector<string>s;
vector<vector<int>>vis;
void dfs(int x,int y)
{	
	if (cnt == k)
	{
		return;
	}
	int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
	for (int i = 0; i < 4; i++)
	{
		int nx = x + dx[i], ny = y + dy[i];
		if ( nx >= 1 && nx <= n && ny >= 1 && ny <= m && vis[nx][ny] == 0 && s[nx][ny] == '.' )
		{
			vis[x][y] = 1;//走没走过的记录很重要，如果没有的话，会无限回溯啊！！！
			dfs(nx, ny); 
			//一条路走到黑，最后叶子的操作
			if (cnt < k)
			{
				s[nx][ny] = 'X';
				cnt++;
			}

		}
	}
	
	
}
void solve()
{

	cin >> n >> m >> k;
	s.resize(n + 1);
	vis.resize(n + 1);
	for (int i = 1; i <= n; i++)
		vis[i].resize(m + 1);

	for (int i=1; i <= n; i++)
	{
		string a;
		cin >> a;
		s[i] = " " + a;
	}
	cnt = 0;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			if (s[i][j] == '.')
			{
				vis[i][j] = 1;
				dfs(i,j);
				break;
			}
		}
	}

	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
			cout << s[i][j];
		cout << endl;
	}
}

二、BFS

feel：求权值为1的最短路【VS dp，一类特殊的最短路问题，没有环的最短路】

收获++：

1.输出路径：用一个pre来存储回溯的点，不断回溯输出！

2.有滞后性不可用dp！！！

典中典

题目：【活动 - AcWing】

走迷宫，由（1，1）到（n，m）的最短距离

思路：由于有滞后性，所以不能用dp来写【！！！！】

代码实现：

int n, m;
vector < vector<int>>a,vis;
pair<int, int> pre[N][N];
void solve()
{
    cin >> n >> m;
    a.clear(), vis.clear();
    //pre.clear();

    a.resize(n + 5), vis.resize(n + 5);
    //pre.resize(n + 5);

    for (int i = 1; i <= n; i++)
    {
        a[i].resize(m + 5);
        vis[i].resize(m +5, -1);
        //pre[i].resize(m + 1);
    }
    queue<pair<int, int>> q;

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
            cin >> a[i][j];
    }
    q.push({ 1,1 });
    vis[1][1] = 0;
    int dx[4] = { 1,0,-1,0 }, dy[4] = { 0,-1,0,1 };
  
    while (q.size())
    {
        int x = q.front().first, y = q.front().second;

        

        for (int i = 0; i < 4; i++)
        {
            int nx = dx[i] + x, ny = dy[i] + y;
            if ( nx >= 1 && nx <= n && ny >= 1 && ny <= m&& !a[nx][ny] && vis[nx][ny] == -1 )
            {
                q.push({ nx,ny });
                pre[nx][ny] = q.front();
                vis[nx][ny] = vis[x][y] + 1;
            }
        }
        q.pop();
    }
    int x = n, y = m;
    while (x != 1 && y != 1)
    {
        cout << x << " " << y << endl;
        x = pre[x][y].first, y = pre[x][y].second;
    }
    cout << vis[n][m];

}

三、图的存储

链式前向星

一、用处

树和有向图的存储，遍历所有的点，每个点遍历所有的边

二、重要思想

1.回溯，head里面存储的是回溯的上一个位置的边的编号，=-1则说明当前点散发出去的边都遍历完了

2.存储，结构体edge来存储

三、小板板

存图：

const int maxn = 1005;//点数最大值
int n, m, cnt;//n个点，m条边

struct Edge
{
    int to, ne, w;//指向重点，同起点的上一个编号，权重
}edge[maxn];

int head[maxn];//存储第i条边的回溯编号

void init()//初始化
{
    for (int i = 1; i <= n; i++)
        head[i] = -1;
    cnt = 0;
}
void add(int u, int v, int w)//加边
{
    edge[cnt].to = v;//编号为cnt的边指向的终点下标
    edge[cnt].w = w;
    edge[cnt].ne = head[u];//编号为cnt的边回溯的上一个编号
    head[u] = cnt++;//回溯点的更新
}

int main()
{
    cin >> n >> w;
    int u, v, w;

    init();//初始化

    for (int i = 1; i <= n; i++)
    {
        cin >> u >> v >> w;
        add(u, v, w);
        //若加的是双向边
        //add(u,v,w)
        //add(v,u,w)
        //双向奔赴的u，v
    }

    //每一个点有的边的遍历
    for (int i = 1; i <= n; i++)
    {
        cout << i << endl;
        for (int j = head[i]; j != -1; j = edge[j].ne)//每个点有的边都遍历一遍
        {
            cout << i << " " << edge[j].to << " " << edge[j].w << endl;
        }
        cout << endl;
    }
    return 0;

}

四、图的搜索

一：深搜

题目：【找不到页面 - AcWing】

int ans = inf;
int dfs(int u)
{
	vis[u] = 1;
	int sum = 1;//第u层的总数值量
	int res = 0;//连通块中点数的最大值
	for (int i = h[u]; i != -1; i = edge[i].ne)
	{
		int v = edge[i].to;
		if (!vis[v])
		{
			int s = dfs(v);//分支的数量
			sum+= s;
			res = max(s, res);
		}
	}
	res = max(sum, res);
	ans = min(ans, res);

	//要回溯前的操作
	return sum;
}

二、广搜

题目：【找不到页面 - AcWing】

void bfs()
{
	memset(dis, -1, sizeof dis);
	queue<int>q;
	dis[1] = 0;
	vis[1] = 1;
	q.push(1);
	while (q.size())
	{
		int u = q.front();
		for (int i = h[u]; i != -1; i = edge[i].ne)
		{
			int v = edge[i].to;
			if (!vis[v])
			{
				dis[v] = dis[u] + 1;
				vis[v] = 1;
			}
		}
	}
}