Altruistic Amphibians (dfs)

最新推荐文章于 2024-04-07 10:22:37 发布
最新推荐文章于 2024-04-07 10:22:37 发布
阅读量238 收藏
点赞数
分类专栏： 搜索与图论 文章标签： 深度优先 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34682765/article/details/122107449
版权

原题链接

思路

每关一盏灯，我们就标记一下，dfs时，我们只搜可以到达终点和终点的点，如果搜到小精灵，则立刻返回，说明只要关闭这盏灯就可以有小精灵逃出去了。

详情看代码注释

代码

#include <bits/stdc++.h> 
using namespace std;
const int N = 550;
int n, m, k;
int flag[N][N]; //标记小精灵位置
int safe[N][N];//标记点是否可以到达终点 
int light[N][N];//标记关灯位置 
int f = 0; 
int ans = 0;

//方向数组
int xx[4] = {1, 0, -1, 0};
int yy[4] = {0, 1, 0, -1};


void dfs(int x, int y)
{
//	cout << x << y << endl;
	if (x == 0 || x == n - 1 || y == 0 || y == n - 1 || safe[x][y]) //只搜可以到达终点的点或终点
	{
		for (int i = 0; i < 4; i ++ )
		{
			int dx = x + xx[i];
			int dy = y + yy[i];
			if (dx >= 0 && dx < n && dy >= 0 && dy < n) //如果不出界 
			{
				if (!safe[dx][dy]) //非可以到达终点的点
				{
					safe[dx][dy] = 1; //标记为可以到达终点的点，因为搜索限制，我们一定是从终点的点或终点搜过来的，所以这个点一定也可以达到终点，同时起到去重作用
					if (flag[dx][dy]) //找到小精灵 
					{
						f = 1;//改变状态
						return;//返回
					}
					if (light[dx][dy]) dfs(dx, dy); //如果下一个点是关灯的（因为只可以走关灯的地方）
				}
			}
		}
	}
}

int main()
{
	cin >> n >> m >> k;
	for (int i = 1; i <= m; i ++ ) //小精灵位置 
	{
		int x, y;
		cin >> x >> y;
		flag[x][y] = 1;
		if (x == 0 || x == n - 1 || y == 0 || y == n - 1) f = 1;
	}
	for (int i = 1; i <= k; i ++ ) //关灯 
	{
		int x, y;
		cin >> x >> y;
		light[x][y] = 1;//标记为关灯

		if (f == 0)
		{
			dfs(x, y);
			if (f == 1)//状态被改变
			{
				ans = i; //得到答案
			}
		}
	}
	cout << ans << endl;
	return 0;
}

总结

遇到题目时，总是不能确定正确的策略。

比如这题，刚开始想的是用所有小精灵的位置dfs，只走灯会被关的地方，然后整条途径上所有的灯光取最大值，最后所有路径的最大值再取最小值。。。

虽然感觉没什么毛病，但是WA96，我想这可能是因为返回时没有回复现场吧，然后有情况漏了，但是回复现场又会超时。。。

错误代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 550;
int ans = 0x3f3f3f3f;
int g[N][N];
int n, m, k;
pair<int, int> p[N * N];

bool check(int x, int y)
{
	if ((x == 0 || y == 0 || x == n - 1 || y == n - 1) && (x >= 0 && x < n && y >= 0 && y < n)) return true;
	return false;
}

//方向数组
int xx[4] = {1, 0, -1, 0};
int yy[4] = {0, 1, 0, -1};

bool st[N][N];
bool f = 0;
void dfs(int x, int y, int maxn)
{
	if (check(x, y))
	{
		ans = min (maxn, ans);
		return;
	}
	
	for (int i = 0; i < 4; i ++ )
	{
		int dx = x + xx[i];
		int dy = y + yy[i];
		
		if (dx >= 0 && dx < n && dy >= 0 && dy < n)
		{
			if (!st[dx][dy] && g[dx][dy] != -1)
			{
				st[dx][dy] = 1;
				dfs(dx, dy, max(maxn, g[dx][dy]));
//				st[dx][dy] = 0;
			}
		}
		
		
	}
	
}

signed main()
{
	
	memset(g, -1, sizeof g);
	cin >> n >> m >> k;
	for (int i = 0; i <= n; i ++ )
	{
		for (int j = 1; j <= n; j ++ )
		{
			g[i][j] = -1;
		}
	}
	
	for (int i = 1; i <= m; i ++ ) //存入小精灵的点数 
	{
		int x, y;
		cin >> x >> y;
		p[i] = {x, y};
		if (check(x, y)) f = 1;
	}
	for (int i = 1; i <= k; i ++ ) //存入所有的灯 
	{
		int x, y;
		cin >> x >> y;
		g[x][y] = i;
	}
	if (f)
	{
		cout << 0 << endl;
		return 0;
	}
	
	for (int i = 1; i <= m; i ++ )
	{
		int x = p[i].first;
		int y = p[i].second;
		memset(st, 0, sizeof st);
//		for (int j = 0; j <= n; j ++ )
//		{
//			for (int k = 1; k <= n; k ++ )
//			{
//				st[i][j] = 0;
//			}
//		}
		dfs(x, y, 0);
	}
	
	cout << ans << endl;
	return 0;
}

顽强拼搏

在这里插入图片描述
在这里插入图片描述
经历了WA1，WA77，WA83，WA96，T56，T75，T93，RE1……
写了数不清的版本


#include<bits/stdc++.h>
using namespace std;
const int N = 550;
int n, mm, k; //n*n的坐标，m只小精灵，k盏灯 
int g[N][N];
pair<int, int> p[N];
queue<pair<int, int>> q;
bool st[N][N];

map <pair<int, int>, int> m;

bool check(int x, int y)
{
	if (x == 0 || x == n - 1 || y == 0 || y == n - 1) return true;
	return false;
}

int xx[4] = {1, 0, -1, 0};
int yy[4] = {0, 1, 0, -1};


int bfs()
{
	
	while (!q.empty())
	{
		auto t = q.front();
		q.pop();
		
		int d = m[t];
		
		
		
		g[p[d].first][p[d].second] = 0;
		int x = t.first;
		int y = t.second;
		
		
		cout << x << " " << y << " " << d << endl;
		if (check(x, y)) return min(d, k);
		bool f = 0;
		for (int i = 0; i < 4; i ++ )
		{
			int dx = x + xx[i];
			int dy = y + yy[i];
			if (g[dx][dy] == -1 &&  !f)
			{
				f= 1;
				m[{x, y}] = d + 1;
				q.push({x, y});
			}
			else
			{
				if (dx >= 0 && dx < n && dy >= 0 && dy < n && g[dx][dy] == 0)
				{
					if (!m.count({dx, dy}))
					{
						m[{dx, dy}] = d + 1;
						g[dx][dy] = 1;
						q.push({dx, dy});
					}
				}
			}
		}
	}
	
}


int main()
{
	cin >> n >> mm >> k;
	
	
	for (int i= 1; i <= k; i ++ )
	{
		int x, y;
		cin >> x >> y;
		g[x][y] = -1;
		p[i] = {x, y};
	}
	for (int i= 1; i <= mm; i ++ ) 
	{
		int x, y;
		cin >> x >> y;
		q.push({x, y});
		st[x][y] = 1;
		m[{x, y}] = 0;
		g[x][y] = 1;
	}
	cout << bfs() + 1;
	
	return 0;
}
//
//#include<bits/stdc++.h>
//#define int long long
//using namespace std;
//const int N = 550;
//int ans = 0x3f3f3f3f;
//int g[N][N];
//int n, m, k;
//pair<int, int> p[N * N];
//
//bool check(int x, int y)
//{
//	if ((x == 0 || y == 0 || x == n - 1 || y == n - 1) && (x >= 0 && x < n && y >= 0 && y < n)) return true;
//	return false;
//}
//
//int xx[4] = {1, 0, -1, 0};
//int yy[4] = {0, 1, 0, -1};
//
//bool st[N][N];
//bool f = 0;
//void dfs(int x, int y, int maxn)
//{
//	if (check(x, y))
//	{
//		ans = min (maxn, ans);
//		return;
//	}
//	if (maxn > ans) return;
//	st[x][y] = 1;
//	for (int i = 0; i < 4; i ++ )
//	{
//		int dx = x + xx[i];
//		int dy = y + yy[i];
//		
//		if (dx >= 0 && dx < n && dy >= 0 && dy < n)
//		{
//			if (!st[dx][dy] && g[dx][dy] != -1)
//			{
//				st[dx][dy] = 1;
//				
//				if (g[dx][dy] >= maxn)
//				{
//					dfs(dx, dy, max(maxn, g[dx][dy]));
//				}
//				else
//				{
//					dfs(dx, dy, maxn + 1);
//				}
				st[dx][dy] = 0;
//			}
//		}
//		
//		
//	}
//	
//}
//
//signed main()
//{
//	
//	memset(g, -1, sizeof g);
//	memset(st, 0, sizeof st);
//	cin >> n >> m >> k;
//	for (int i = 0; i <= n; i ++ )
//	{
//		for (int j = 0; j <= n; j ++ )
//		{
//			st[i][j] = 0;
//			g[i][j] = -1;
//		}
//	}
//	
//	for (int i = 1; i <= m; i ++ ) //存入小精灵的点数 
//	{
//		int x, y;
//		cin >> x >> y;
//		g[x][y] = 0;
//		p[i] = {x, y};
//		if (check(x, y)) f = 1;
//	}
//	
//	for (int i = 1; i <= k; i ++ ) //存入所有的灯 
//	{
//		int x, y;
//		cin >> x >> y;
//		g[x][y] = i;
//	}
//	if (f)
//	{
//		cout << 0 << endl;
//		return 0;
//	}
//	
//	for (int i = 1; i <= m; i ++ )
//	{
//		int x = p[i].first;
//		int y = p[i].second;
//		memset(st, 0, sizeof st);
//		dfs(x, y, 0);
//	}
//	
//	cout << min(ans, k) << endl;
//	return 0;
//}
//
//#include<bits/stdc++.h>
#define int long long
//using namespace std;
//const int N = 550;
//int ans = 0x3f3f3f3f;
//int g[N][N];
//int n, m, k;
//pair<int, int> p[N * N];
//
//bool check(int x, int y)
//{
//	if ((x == 0 || y == 0 || x == n - 1 || y == n - 1) && (x >= 0 && x < n && y >= 0 && y < n)) return true;
//	return false;
//}
//
//int xx[4] = {1, 0, -1, 0};
//int yy[4] = {0, 1, 0, -1};
//
//bool st[N][N];
//bool f = 0;
//void dfs(int x, int y, int maxn)
//{
//	st[x][y] = 1;
//	if (maxn > ans)  return;
//	for (int i = 0; i < 4; i ++ )
//	{
//		int dx = x + xx[i];
//		int dy = y + yy[i];
//		
//		if (dx >= 0 && dx < n && dy >= 0 && dy < n)
//		{
//			if (!st[dx][dy])
//			{
//				st[dx][dy] = 1;
//				
//				if (g[dx][dy] == 0)
//				{
//					ans = min (maxn, ans);
//					return;
//				}
//				
//				if (g[dx][dy] > maxn && g[dx][dy] != -1)
//				{
//					dfs(dx, dy, max(maxn, g[dx][dy]) + 1);
//				}
//				else if(g[dx][dy] != -1)
//				{
//					dfs(dx, dy, maxn + 1);
//				}
//				
//			}
//		}
//		
//		
//	}
//	
//}
//
//signed main()
//{
//	
//	memset(g, -1, sizeof g);
//	memset(st, 0, sizeof st);
//	cin >> n >> m >> k;
//	for (int i = 0; i <= n; i ++ )
//	{
//		for (int j = 0; j <= n; j ++ )
//		{
//			st[i][j] = 0;
//			g[i][j] = -1;
//		}
//	}
//	
//	for (int i = 1; i <= m; i ++ ) //存入小精灵的点数 
//	{
//		int x, y;
//		scanf("%d%d", &x, &y);
//		g[x][y] = 0;
//		if (check(x, y)) f = 1;
//	}
//	int cnt = 1;
//	for (int i = 1; i <= k; i ++ ) //存入所有的灯 
//	{
//		int x, y;
//		scanf("%d%d", &x, &y);
//		g[x][y] = i;
//		if (check(x, y)) p[cnt ++ ] = {x, y};
//	}
//	
//	if (f)
//	{
//		cout << 0 << endl;
//		return 0;
//	}
//	
//	for (int i = 1; i < cnt; i ++ )
//	{
//		int x = p[i].first;
//		int y = p[i].second;
//		memset(st, 0, sizeof st);
//		dfs(x, y, g[x][y]);
//	}
//	
//	cout << min(ans, k) << endl;
//	return 0;
//}

//#include <bits/stdc++.h>
//using namespace std;
//const int N = 505;
//
小精灵的位置 
//map<pair<int, int>, int> q;
//
存储小精灵的位置 
//pair<int, int> a[N * N];
//
临时变量 
//pair<int, int> t;
//
方向数组 
//int dx[] = { -1, 0, 1, 0};
//int dy[] = {0, -1, 0, 1};
//
//int ans[N][N];//存点是否能达到出口
// 
//int n, ff = 0;
//
//int ma[N][N];// 点是否为已经灭灯的点
//
//void dfs(int x, int y) 
//{
//	cout << x  << " " << y << endl;
//    if (x == 0 || y == 0 || x == n - 1 || y == n - 1 || ans[x][y]) //如果该点是终点或是能到达终点的点                           
//    {
//        for (int j = 0; j < 4; j ++ ) 
//        {
//            if (x + dx[j] >= 0 && x + dx[j] < n && y + dy[j] >= 0 && y + dy[j] < n) //如果不出界 
//            {
//                if (ans[x + dx[j]][y + dy[j]] == 0) //如果该点不能到达终点 
//                {
//                    ans[x + dx[j]][y + dy[j]] = 1; //标记为可以到达终点 
//                    t.first = x + dx[j];
//                    t.second = y + dy[j];
//                    if (q[t]) //判断是否是小精灵的位置 
//                    {
//                        ff = 1; //标记为存在方案 
//                        return; //返回 
//                    }
//                    if (ma[x + dx[j]][y + dy[j]] == 1) dfs(x + dx[j], y + dy[j]); //如果是已经关掉的灯 
//                        
//                }
//            }
//        }
//        
//    }
//}
//int main() 
//{
//    ios::sync_with_stdio(false);
//    int m, k, x, y, w, i, j;
//    cin >> n >> m >> k;
//    int flag = 1;
//    memset(ans, 0, sizeof(ans));
//    memset(ma, 0, sizeof(ma));
//    for (i = 0; i < m; i++) 
//    {
//        cin >> x >> y;
//        if (x == 0 || y == 0 || x == n - 1 || y == n - 1) 
//        {
//            flag = 0;
//        }
//        a[i].first = x;
//        a[i].second = y;
//        q[a[i]] = 1; //标记小精灵 
//    }
//    
//    if (flag == 0) w = 0; //原本就在终点
// 
//    for (i = 1; i <= k; i++)  //关灯位置 
//    {
//    	cout << endl<<endl;
//        cin >> x >> y;
//        cout << " :::  ";
//        cout << endl<<endl;
//        if (flag)  //如果没有小精灵在终点 
//        {
//            ma[x][y] = 1; //标记为已关闭的灯 
//            dfs(x, y); //dfs 
//            
//            if (ff) //如果已经找到了小精灵 
//            {
//                flag = 0;
//                w = i;
//            }
//        }
//    }
//    cout << w << endl;
//    return 0; 
//}


#include <bits/stdc++.h> 
using namespace std;
const int N = 550;
int n, m, k;
int flag[N][N]; //标记小精灵位置
int safe[N][N];//标记点是否可以到达终点 
int light[N][N];//标记关灯位置 
int f = 0; 
int ans = 0;

int xx[4] = {1, 0, -1, 0};
int yy[4] = {0, 1, 0, -1};

void dfs(int x, int y)
{
//	cout << x << y << endl;
	if (x == 0 || x == n - 1 || y == 0 || y == n - 1 || safe[x][y])
	{
		for (int i = 0; i < 4; i ++ )
		{
			int dx = x + xx[i];
			int dy = y + yy[i];
			if (dx >= 0 && dx < n && dy >= 0 && dy < n) //如果不出界 
			{
				if (!safe[dx][dy]) 
				{
					safe[dx][dy] = 1; //非安全点则标为安全点 
					if (flag[dx][dy]) //找到小精灵 
					{
						f = 1;
						return;
					}
					if (light[dx][dy]) dfs(dx, dy);
				}
			}
		}
	}
}

int main()
{
	cin >> n >> m >> k;
	for (int i = 1; i <= m; i ++ ) //小精灵位置 
	{
		int x, y;
		cin >> x >> y;
		flag[x][y] = 1;
		if (x == 0 || x == n - 1 || y == 0 || y == n - 1) f = 1;
	}
	for (int i = 1; i <= k; i ++ ) //关灯 
	{
		int x, y;
		cin >> x >> y;
		light[x][y] = 1;
//		safe[x][y] = 1;
		if (f == 0)
		{
			dfs(x, y);
			if (f == 1)
			{
				ans = i;
			}
		}
	}
	cout << ans << endl;
	return 0;
}

虽然说，我现在还很垃圾，我很菜，我也很笨，但是，我相信，只要坚持下去，就一定可以看到胜利的曙光，早晚有一天，我也可以成为别人眼中比较厉害的人！

x-d-xxh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【DP】Gym101933A Altruistic Amphibians
Tooc0ld
10-27 586
Source:Source:Source:2018-2019 ACM-ICPC Nordic Collegiate Programming Contest (NCPC 2018) Problem:Problem:Problem:坑里有一堆青蛙，青蛙有身高、跳跃高度、体重。青蛙可以叠罗汉，但是不可以撑起超过自己体重的重量。问有多少青蛙可以跳出去。体重总和&lt;=1e8 Idea:Idea:Idea...
多校A题Altruistic Amphibians
weixin_43331783的博客
03-13 193
这道题一开始看到就没想到01背包，原本觉得尽量让跳跃高度较小的青蛙往外跳，这样就可以使跳出去的青蛙尽量多，其实这种思路逻辑是正确的。但是实现困难，也是对算法不够理解，其实这道题应该想，如何使一个青蛙重量允许下叠的高度尽量高，这样也就实现了尽量跳跃高度小的青蛙能跳出去。所以问题就在于，如何使一个青蛙重量下叠罗汉的高度尽量高，想到这一方面背包就很明显了。首先不管跳高这只在判断时使用。考虑两个数值，容量...
ncpc2018 Gym 101933A Altruistic Amphibians
binarycopycode
03-10 189
题目还没看队友就写完了，不过感觉还是很有趣的一道DP 由题意，可以想到必然是大青蛙垫下面，小青蛙先往上跳 所以我们从大往小枚举，看大的搭在一起，能不能将当前这个小的跳出去，能的话，ans就++。 按照原来的题意，其实实际情况是从小到大跳出的，而跳出又是由比他大的青蛙提供的，所以可以DP dp[i]表示到当前位置，重量为i的青蛙能跳到的最大高度为多少，如果dp[w]+l&gt;d，那么ans...
2018-2019 ACM-ICPC Nordic Collegiate Programming Contest (NCPC 2018)A. Altruistic Amphibians(贪心+dp)
IQ^QI的博客
10-05 351
A. Altruistic Amphibians 题意： 输入n(1e5),d(1e18)n(1e5),d(1e18)n(1e5),d(1e18) 接下来nnn行，每行l,w,hl,w,hl,w,h表示每只青蛙的跳跃高度、
A.Altruistic Amphibians---Gym101933（01背包的运用）
孤风的博客
03-10 559
Altruistic Amphibians Time Limit: 6 Sec Memory Limit: 1024 Mb 题目链接http://acm.csu.edu.cn:20080/csuoj/contest/problem?cid=2178&amp;amp;amp;amp;amp;pid=A Description A set of frogs have accidentally fallen to the bo...
加强互惠
02-22
加强互惠
开展慈善众筹工作：以主观排序促进捐赠者贡献的项目推广的实证研究-研究论文
05-20
世界各地的许多慈善事业都迫切需要资金。 众筹提供了直接联系产品，原因和组织支持者的能力。 但是，由于众筹平台上的项目供过于求，绝大多数慈善项目未能引起捐助者的关注和贡献。 他们还缺乏金钱上的诱因，这使得...
Flexible resource allocation adaptive to communication strategy selection for cellular clients using Stackelberg game
02-21
In cooperative communication Networks (or cooperative cognitive radio networks), a source node usually recruits non-altruistic relays to execute cooperative communication with a target node, through ...
新世纪大学英语系列教材综合教程3词汇.doc
11-28
30. altruistic（无私）：出于对他人的关心和帮助，而非自我利益的行为。 这些词汇涉及日常对话、学术讨论和职业场景，掌握这些词汇将有助于提升英语听说读写的能力，为在不同场合的沟通交流打下坚实基础。
Peer-to-Peer Multimedia Sharing based on Social Norms.pdf
07-19
Introduction. With the explosion of communication technologies and multimedia signal processing,... System model. We consider a P2P multimedia sharing ...Protocol designs for networks with altruistic...
CSU 2249 Altruistic Amphibians DP
Monster_ixx的博客
03-10 270
今天是这个学期第一场湖南多校训练赛，打的是真的自闭。 这个题是这场比赛的A题，想了n久，最后还是GG 题目链接：http://acm.csu.edu.cn:20080/csuoj/problemset/problem?pid=2249 题目大意，有n只青蛙想从一个深度为d的井中跳出去，因此青蛙需要叠罗汉。青蛙有3个属性，体重，身高，和跳跃力。叠罗汉唯一一个限制就是每只青蛙身上的青蛙的体重之和不能超...
2019多校第一场——A——Altruistic Amphibians
Q755100802的博客
03-11 550
题目链接：http://acm.csu.edu.cn:20080/csuoj/contest/problem?cid=2178&amp;pid=A 大意是，井底有一些青蛙，他们都有自己的高度，重量和跳跃高度，现在可以用别的青蛙搭梯子，任何一个青蛙身上的叠加重量不能超过他自身，问最佳情况下能逃离多少青蛙 简单推论后发现，假设当前最上面的青蛙的重量为wi，再往上累加青蛙wj的重量应满足2*wj&l...
A - Altruistic Amphibians Gym - 101933A （贪心+dp）
untilyouydc
10-28 699
题意：坑里有一堆青蛙，青蛙有身高、跳跃高度、体重。青蛙可以叠罗汉，但是不可以撑起超过自己体重的重量。问有多少青蛙可以跳出去。体重总和&lt;=1e8 思路：因为最重的青蛙肯定不能出去，所以应该是保证体重轻的能出去，而重的在底下，所以，先按体重排序。 设dp[i]表示，体重为i的最大高度可以达到多少，那么判断dp[i]+h与d 的大小关系就知道这只青蛙能否出去了。 因为能托起的青蛙不能超过最底...
Gym 101933 A（dp）
weixin_30337251的博客
11-10 127
传送门： 题面： A. Altruistic Amphibians time limit per test 3.0 s memory limit per test 512 MB input standard input output standard output A set of frogs have accidentally fallen to ...
2019杭电多校第七场1001:A + B = C
天真有邪的博客
08-13 226
A + B = C 题意： 给定 a b c 求出 x y z 使得 a * 10^x + b * 10^y = c * 10 ^z 。 思路： a + b = c,要么a+b有进位，要么没有进位。那么判断题目是否有解只要判断 b | ( c - a ) (|)是整除符号。 b | ( c*10 - a ) , a | ( c*10 - b ) ,a | ( c- b ) 四种情...
【LCA】Gym101669I Divide and Conquer
Tooc0ld
10-07 226
Source:Source:Source: 2017-2018 ACM-ICPC Southeastern European Regional Programming Contest (SEERC 2017) Problem:Problem:Problem: n=1e5,m=2n−1n=1e5, m=2n-1n=1e5,m=2n−1的图，其中n−1n-1n−1条边构成A树，另n−1n-1n−1条边...
2019牛客暑期多校训练营（第一场） E ABBA
birdmanqin的博客
07-19 141
dp[i][j]表示的是当有i个A，j个B时，符合要求的字符串数。转移方程详情看注释。 参考博客：https://blog.csdn.net/chenshibo17/article/details/96455518 #include <bits/stdc++.h> #define ll long long using namespace std; const int...
2019湖南多校第一场-20190310
打过ICPC/CCPC，学习ACM算法，Linux内核，Openharmony，加油努力开心珍惜
03-11 380
（有问题欢迎提出来 文章目录A：Altruistic AmphibiansB：Baby BitesC：Code CleanupsD：Delivery DelaysE：Explosion ExploitF：Firing the PhaserG：Game SchedulingH：House LawnI：Intergalactic BiddingJ：Jumbled StringK：King's Colo...
AtCoder 080E Young Maids
Tooc0ld
08-06 1033
与题意相反，从左往右进行构造。 注意到对每一段区间[L, R]选取最小对{x, y}时，x必须处于与L同奇偶性的位子，而y必须处于与x奇偶性相反的位子。选取最小的x以及最小的y可以用两个RMQ维护原数组，奇偶各一个。 当选完一对{x, y}时，区间分裂为[L, pos[x]-1], [pos[x]+1, pos[y]-1], [pos[y]+1, R]三个区间，可以用优先队列进行BFS，保证字典
岛屿个数（dfs)
最新发布
初九·潜龙勿用的博客
04-07 5113
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值