HDU - 1241-day4G

本文详细解析了一种用于探测地下油田分布的算法实现。通过构建网格模型,利用BFS(宽度优先搜索)算法来确定不同油田的具体位置和数量。算法在处理大型矩形区域时,能有效识别并计数独立的油藏沉积。代码示例展示了如何遍历网格,标记已检测到的油藏,并统计总油藏数。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

问题来源

HDU - 1241

问题描述

The GeoSurvComp geologic survey company is responsible for detecting underground oil deposits. GeoSurvComp works with one large rectangular region of land at a time, and creates a grid that divides the land into numerous square plots. It then analyzes each plot separately, using sensing equipment to determine whether or not the plot contains oil. A plot containing oil is called a pocket. If two pockets are adjacent, then they are part of the same oil deposit. Oil deposits can be quite large and may contain numerous pockets. Your job is to determine how many different oil deposits are contained in a grid.

输入

The input file contains one or more grids. Each grid begins with a line containing m and n, the number of rows and columns in the grid, separated by a single space. If m = 0 it signals the end of the input; otherwise 1 <= m <= 100 and 1 <= n <= 100. Following this are m lines of n characters each (not counting the end-of-line characters). Each character corresponds to one plot, and is either *', representing the absence of oil, or@’, representing an oil pocket.

输出

For each grid, output the number of distinct oil deposits. Two different pockets are part of the same oil deposit if they are adjacent horizontally, vertically, or diagonally. An oil deposit will not contain more than 100 pockets.

例子

input

1 1
*
3 5
*@*@*
**@**
*@*@*
1 8
@@****@*
5 5 
****@
*@@*@
*@**@
@@@*@
@@**@
0 0 

output

0
1
2
2

解题思路

bfs判断油田有多少个,八个方向判断
找到就把它消去。

AC的代码

#include <iostream>
#include<cstdio>
#include<queue>
#include<string>
using namespace std;
char aa[102][102];
int vis[102][102];
int dy[] = { -1,-1,-1,1,1,1,0,0 };
int dx[] = { -1,1,0,1,-1,0,-1,1 };
struct nn
{
	int x,y;
};
void bfs(int m,int n)
{
	queue<nn>q;
	int sum=0;
	memset(vis, 0, sizeof(vis));
	for (int f = 1; f <= m; f++)
	{
		for (int e = 1; e <= n; e++)
		{
			if (aa[f][e] == '@')
			{
				sum++;
				aa[f][e] = '*';
				nn temp;
				temp.x = f;
				temp.y = e;
				q.push(temp);
				while (!q.empty())
				{
					nn temp1 = q.front();
					q.pop();
					for (int r = 0; r < 8; r++)
					{
						int xx = temp1.x;
						int yy = temp1.y;
						if (aa[xx + dx[r]][yy + dy[r]] == '@' && !vis[xx + dx[r]][yy + dy[r]])
						{
							nn temp2;
							temp2.x = xx + dx[r];
							temp2.y = yy + dy[r];
							q.push(temp2);
							vis[xx + dx[r]][yy + dy[r]] = 1;
							aa[xx+dx[r]][yy+dy[r]] = '*';
						}
					}
				}

			}
		}


	}
	cout << sum << endl;
}

int main()
{
	int m, n;
	while (cin >> m >> n &&m)
	{
		for (int f = 1; f <= m; f++)
			for (int e = 1; e <= n; e++)
			{
				cin >> aa[f][e];
			}
		bfs(m, n);

	}
}
HDU-3480 是一个典型的动态规划问题,其题目标题通常为 *Division*,主要涉及二维费用背包问题或优化后的动态规划策略。题目大意是:给定一个整数数组,将其划分为若干个连续的子集,每个子集最多包含 $ m $ 个元素,并且每个子集的最大值与最小值之差不能超过给定的阈值 $ t $,目标是使所有子集的划分代价总和最小。每个子集的代价是该子集最大值与最小值的差值。 ### 动态规划思路 设 $ dp[i] $ 表示前 $ i $ 个元素的最小代价。状态转移方程如下: $$ dp[i] = \min_{j=0}^{i-1} \left( dp[j] + cost(j+1, i) \right) $$ 其中 $ cost(j+1, i) $ 表示从第 $ j+1 $ 到第 $ i $ 个元素构成一个子集的代价,即 $ \max(a[j+1..i]) - \min(a[j+1..i]) $。 为了高效计算 $ cost(j+1, i) $,可以使用滑动窗口或单调队列等数据结构来维护区间最大值与最小值,从而将时间复杂度优化到可接受的范围。 ### 示例代码 以下是一个简化版本的动态规划实现,使用暴力方式计算区间代价,适用于理解问题结构: ```cpp #include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const int MAXN = 10010; int a[MAXN]; int dp[MAXN]; int main() { int T, n, m; cin >> T; for (int Case = 1; Case <= T; ++Case) { cin >> n >> m; for (int i = 1; i <= n; ++i) cin >> a[i]; dp[0] = 0; for (int i = 1; i <= n; ++i) { dp[i] = INF; int mn = a[i], mx = a[i]; for (int j = i; j >= max(1, i - m + 1); --j) { mn = min(mn, a[j]); mx = max(mx, a[j]); if (mx - mn <= T) { dp[i] = min(dp[i], dp[j - 1] + mx - mn); } } } cout << "Case " << Case << ": " << dp[n] << endl; } return 0; } ``` ### 优化策略 - **单调队列**:可以使用两个单调队列分别维护当前窗口的最大值与最小值,从而将区间代价计算的时间复杂度从 $ O(n^2) $ 降低到 $ O(n) $。 - **斜率优化**:若问题满足特定的决策单调性,可以考虑使用斜率优化技巧进一步加速状态转移过程。 ### 时间复杂度分析 原始暴力解法的时间复杂度为 $ O(n^2) $,在 $ n \leq 10^4 $ 的情况下可能勉强通过。通过单调队列优化后,可以稳定运行于 $ O(n) $ 或 $ O(n \log n) $。 ### 应用场景 HDU-3480 的问题模型可以应用于资源调度、任务划分等场景,尤其适用于需要控制子集内部差异的问题,如图像分块压缩、数据分段处理等[^1]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值