ABC 218 C、D（思维 E（最小生成树 F（最短路

最新推荐文章于 2022-05-05 15:03:22 发布
最新推荐文章于 2022-05-05 15:03:22 发布
阅读量271 收藏 1
点赞数 1
分类专栏： 思维题 act刷题 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cosx_/article/details/120251114
版权

C - Shapes

比较有意思的一道题
存到vector一个一个匹配就行

code：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2e2 + 9;
const ll mod = 998244353;
const ll inf = 0x3f3f3f3f;
ll n, m, k;
ll sum = 0;
char s[maxn][maxn], t[maxn][maxn];
char m2[maxn][maxn],m3[maxn][maxn], m4[maxn][maxn];
vector <pair<int,int> > vt;
bool check(char a[][maxn])
{
	vector <pair<int,int> > va;
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			if(a[i][j] == '#')
				va.push_back({i, j});
	if(va.size() != vt.size()) return false;
	else 
	{
		int mx = va[0].first - vt[0].first, my = va[0].second - vt[0].second;
		for(int i = 1; i < va.size(); ++i)
		{
			if(va[i].first - vt[i].first != mx ||  va[i].second - vt[i].second != my)
				return false;
		}
		return true;
	}
}
void work()
{
	cin >> n;
	for(int i = 1; i <= n; ++i)
		cin >> (s[i] + 1);
	for(int i = 1; i <= n; ++i)
	{
		cin >> (t[i] + 1);
		for(int j = 1; j <= n; ++j)
			if(t[i][j] == '#')
				vt.push_back({i, j});
	}
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			m2[i][n-j+1] = s[j][i];
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			m3[i][n-j+1] = m2[j][i];		
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j)
			m4[i][n-j+1] = m3[j][i];
			
	if(check(s) || check(m2) || check(m3) || check(m4))
		cout << "Yes\n";
	else cout << "No\n";
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

D - Rectangles
题意：给你 n n n 个点，找这 n n n 个点能组成多少矩阵
思路：找矩阵对角线，标记已经找过的对角线
code：
（map太慢了）

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2e3 + 9;
const ll mod = 998244353;
const ll inf = 0x3f3f3f3f;
ll n, m, k;
struct node
{
	int x, y;
}a[maxn];
map <pair<int,int>, int> ma;
void work()
{
	cin >> n;
	for(int i = 1; i <= n; ++i)
	{
		cin >> a[i].x >> a[i].y;
		ma[{a[i].x, a[i].y}] = 1;
	}
	int sum = 0;
	for(int i = 1; i <= n; ++i)
	{
		for(int j = 1; j <= n; ++j)
		{
			if(!(a[i].x < a[j].x && a[i].y < a[j].y)) continue;
			if(i != j && a[i].x != a[j].x && a[i].y != a[j].y)
			{
				pair<int,int> t1 = {a[i].x, a[j].y}, t2 = {a[j].x, a[i].y};
				if(ma[t1] && ma[t2]) 	++sum;
 			}
		}
	}
	cout << sum<< endl;
}

int main()
{
	//ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

vector存坐标，用 b i n a r y binary binary_ s e a r c h search search 判断是否出现比 m a p map map 快的多的多
code：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2e3 + 9;
const ll mod = 998244353;
const ll inf = 0x3f3f3f3f;
ll n, m, k;

void work()
{
	cin >> n;
	vector <pair<int,int> > v(n);
	for(int i = 0; i < n; ++i)
		cin >> v[i].first >> v[i].second;
	sort(v.begin(), v.end());
	int sum = 0;
	for(int i = 0; i < n; ++i)
		for(int j = 0; j < n; ++j) if(v[i].first < v[j].first && v[i].second < v[j].second)
		{
			bool f1 = binary_search(v.begin(), v.end(), make_pair(v[i].first, v[j].second));
			bool f2 = binary_search(v.begin(), v.end(), make_pair(v[j].first, v[i].second));
			if(f1 && f2) ++sum;
		}
	cout << sum << endl;
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

E - Destruction
最小生成树，很水的一道题，比C、D都简单
code：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2e5 + 9;
const ll mod = 998244353;
const ll inf = 0x3f3f3f3f;
ll n, m, k;
ll f[maxn];
ll sum = 0;
struct node
{
	ll x, y, w;
	bool operator<(const node &B)const{
		return w < B.w;
	}
}e[maxn];
ll find(ll x)
{
	return x == f[x] ? x : f[x] = find(f[x]);
}
void work()
{
	cin >> n >> m;
	for(int i = 1; i <= m; ++i)
	{
		cin >> e[i].x >> e[i].y >> e[i].w;
		//if(e[i].w >= 0) sum += e[i].w;
	}
	for(ll i = 1; i <= n; ++i) f[i] = i;
	sort(e + 1, e + 1 + m);
	ll cnt = 0;
	ll pos = m + 1;
	for(int i = 1; i <= m; ++i)
	{
		ll xx = find(e[i].x), yy = find(e[i].y);
		if(xx != yy)
		{
			f[xx] = yy;
			++cnt;
			if(cnt == n - 1)
			{
				pos = i + 1;
				break;
			}
		}
		else if(e[i].w >= 0) sum += e[i].w;
	}
	//cout << pos << endl;
	for(int i = pos; i <= m; ++i)
	{
		if(e[i].w >= 0) sum += e[i].w;
	}
	cout << sum << endl;
}

int main()
{
	//ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

F - Blocked Roads
题意：删去第 i i i 个边时， 1 − > n 1->n 1−>n 的最短路是多少
思路：
先跑一边最短路，标记最短路上的所有边
然后如果删的边不在最短路上，就输出最短路，不然就跑一遍最短路
就 n − 1 n-1 n−1 条边在最短路上，因此最多跑 n n n 次，复杂度 n ( n l o g n ) n(nlogn) n(nlogn)
（好像也挺水的
code：
（这个代码有点问题，也能过，存的不全是1到n的最短路上的边，如果出现 1到2，1到3，1到4…1到n的最短路没有一条边是重复的，并且都是 i i i 条，这种比较极端的数据应该就会T）

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2e5 + 9;
const ll mod = 998244353;
const ll inf = 0x3f3f3f3f;
ll n, m, k;

int dis[409], vis[409];
int ans[maxn];
struct edge
{
	int w, to, next;
}e[maxn];
int head[maxn], cnt;
void add(int x, int y)
{
	e[++cnt].w = 1;
	e[cnt].to = y;
	e[cnt].next = head[x];
	head[x] = cnt;
}
map <pair<int,int>, int> ma;
int dij(int nx, int ny)
{
	memset(vis, 0, sizeof(vis));
	for(int i = 1; i <= n; ++i) dis[i] = inf;
	dis[1] = 0;
	priority_queue <pair<int,int>, vector<pair<int,int> > , greater<pair<int,int> > > q;
	q.push({0, 1});
	while(!q.empty())
	{
		int now = q.top().second;
		q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int tmp = e[i].to;
			if(!vis[tmp] && dis[tmp] > dis[now] + e[i].w && !(now==nx&&tmp==ny))
			{
				ma[{now, tmp}] = 1;
				dis[tmp] = dis[now] + e[i].w;
				q.push({dis[tmp], tmp});
			}
		}
	}
	return dis[n] == inf ? -1 : dis[n];
}
void work()
{
	cin >> n >> m;
	vector <pair<int,int> > v(m + 1);
	for(int i = 0; i < m; ++i)
	{
		cin >> v[i].first >> v[i].second;
		add(v[i].first, v[i].second);
	}
	int Min = dij(0, 0);
	for(int i = 0; i < m; ++i)
	{
		if(ma[{v[i].first, v[i].second}])
			ans[i+1] = dij(v[i].first, v[i].second);
		else ans[i+1] = Min;
	}
	
	for(int i = 1; i <= m; ++i)
		cout << ans[i] << endl;
}

int main()
{
	ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}

开一个 p r e pre pre 数组存路径，倒着找 1 1 1 到 n n n 的最短路
（这个代码跑的就比上一个快两倍）
code2：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2e5 + 9;
const ll mod = 998244353;
const ll inf = 0x3f3f3f3f;
ll n, m, k;

int dis[409], vis[409];
int ans[maxn];
struct edge
{
	int w, to, next;
}e[maxn];
int head[maxn], cnt;
void add(int x, int y)
{
	e[++cnt].w = 1;
	e[cnt].to = y;
	e[cnt].next = head[x];
	head[x] = cnt;
}
int pre[409];// 存路径 
int dij(int nx, int ny)
{
	memset(vis, 0, sizeof(vis));
	for(int i = 1; i <= n; ++i) dis[i] = inf;
	dis[1] = 0;
	priority_queue <pair<int,int>, vector<pair<int,int> > , greater<pair<int,int> > > q;
	q.push({0, 1});
	while(!q.empty())
	{
		int now = q.top().second;
		q.pop();
		if(vis[now]) continue;
		vis[now] = 1;
		for(int i = head[now]; i; i = e[i].next)
		{
			int tmp = e[i].to;
			if(!vis[tmp] && dis[tmp] > dis[now] + e[i].w && !(now==nx&&tmp==ny))
			{
				dis[tmp] = dis[now] + e[i].w;
				pre[tmp] = now;
				q.push({dis[tmp], tmp});
			}
		}
	}
	return dis[n] == inf ? -1 : dis[n];
}
void work()
{
	cin >> n >> m;
	vector <pair<int,int> > v(m + 1);
	for(int i = 0; i < m; ++i)
	{
		cin >> v[i].first >> v[i].second;
		add(v[i].first, v[i].second);
	}
	int Min = dij(0, 0);
	if(Min == -1){// 一开始跑不出来必须特判掉，不然下边原路返回永远不会终止 
		for(int i = 0; i < m; ++i)
			cout << -1 << endl;return;
	}
	vector <pair<int,int> > mark;	
	int pos = n;
	while(pos != 1)// 倒着找路
	{
		mark.push_back({pre[pos], pos});
		pos = pre[pos];
	}
	sort(mark.begin(), mark.end());
	for(int i = 0; i < m; ++i)
	{
		bool f = binary_search(mark.begin(), mark.end(), make_pair(v[i].first, v[i].second));
		if(f)
			ans[i+1] = dij(v[i].first, v[i].second);
		else ans[i+1] = Min;
	}
	
	for(int i = 1; i <= m; ++i)
		cout << ans[i] << endl;
}

int main()
{
	//ios::sync_with_stdio(0);
	//int TT;cin>>TT;while(TT--)
	work();
	return 0;
}
__Rain
关注
专栏目录
「ABC 218」解集
root的博客
09-12 196
E 倒流一下，然后把负权边置零后跑 MST 即可。 attempt。 F 跑出原图的最短路树，非树边删除不需要考虑，树边就重新跑一次最短路（规模 Θ(n)\Theta(n)Θ(n)）。 类似的题（原题）有 JOI 2020 Final Olympic Bus。 attempt。 G 其实五分钟能冲出来的……去了板子码长 800B。 跑出每个结点到根的中位数，这个随便拿个数据结构维护下就行了，然后做个树 DP，就考虑深度奇偶性，和 P7443 的那个 SG 函数一个套路。注意是自底向上跑的。 attempt。
AtCoder Beginner Contest 214 abc214_d D - Sum of Maximum Weights【最小生成树】【Kruskal】
Yucohny
08-15 237
题目链接   我们考虑最长的边会出现在何处。以这场边为中心，将这棵树分为两半，其中一半有xxx个点，另外一半有yyy个点，那么必然有x∗yx*yx∗y个点对的最短路，会经过这条最长边。于是我们考虑每条边作为最长边的状态。   于是考虑最小生成树，将边按照大小排序，对于每一条边加进来的时候，这条边已经是当前的最长边，于是我们考虑这条当前的最长边的两端的点的数量，然后我们用并查集维护即可。 #include <map> #include <queue> #include <cmat
AtCoder Beginner Contest 218 C - Shapes (模拟)
我们都有光明的未来
09-12 434
linkkkk 题意： 给两个n∗nn*nn∗n的矩阵，#\##表示物体所在位置，问111能否通过旋转90°90°90°和平移任意次得到222 思路： 啊大概就是暴力模拟判断一下，然后就没想好怎么模拟。 首先，如果两个矩阵的#个数不相等，一定是NoNoNo 然后，旋转90°90°90°任意次，其实只需要旋转444次就足够了。 平移的话，对于每次旋转后的图形，找到最左上的起点，然后判断其他点和这个点问位置关系。 代码： int n; int s[210][210],t[210][210]; int cnts=
AtCoder 218: C: Shapes(判断两个图形是否一样)
qq_45772236的博客
09-18 430
题目：题目链接 分析： 可通过旋转和移动变换来判断由#组成的两个图形是否一直。 解析： 先寻找最左最上的一个点，记录下位置。 然后开始每一个#进行判断，偏移量是否相同。 然后旋转三次，共四次每次重复上面操作。 Input 1: 5 ..... ..#.. .###. ..... ..... ..... ..... ....# ...## ....# Output 1: Yes Input 2: 5 ##### ##..# #..## ##### ..... ##### #..## ##..# ####
刷题总结（9.13）
ando_ando的博客
09-13 140
1.Shapes(abc218c): 难点在于如何比对两个需要图案是否能通过平移从而一致，考虑找标志点（如左上点），找到两个图案的标志点后，记下两个方向平移的单位，从而比对，另外如果变量超出范围，要考虑未移动的图案是否在此处有‘#’，若有，则也不满足条件。建议在纸上模拟一下。 ​​写代码时发现的问题： 1.error: reference to ‘is_same’ is ambiguous:原因是代码中两个变量重名或者是某个变量或函数与内置库重名了 2.二维数组传参，建议设置成全局变...
AtCoder Beginner Contest 218 C - Shapes
karshey的博客
09-11 283
C 一次原地和三次旋转，给我转麻了。记录一下。（但是写的很拉） #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=205; char s[N][N],t[N][N]; struct node { int x,y; }; int cmp1(node a,node b)//从左到右 从上到下 先y小 再x小 { if(a.y!=b.y) return a.y<b.y; else
图解红黑树
个人站点：javatv.net
07-26 739
写在前面 阅读本文你需具备知识点： 二叉树 平衡二叉树AVL 红黑树也是一棵二叉查找树，既然有了AVL树为什么还需要红黑树呢？ 之前在了平衡二叉树AVL实现中讲到了为什么使用平衡二叉树AVL（解决二叉查找树退化为类似链表的问题），最大的作用就是用于查找，其时间复杂度为O(logn)，但AVL树插入或删除节点后，若使得高度之差大于1，此时，AVL树的平衡状态就被破坏，需要旋转才能达到平衡。因此如果在插入和删除频繁的场景中就需要频繁的调整使之达到平衡，性能也随之下降。 因此，红黑树的提出是为了解决平衡树在插
【洛谷_T145192】【2020.8.23NOIP模拟赛】最优路线
你...你不要过来啊！！！
08-23 417
【2020.8.23NOIP模拟赛】最优路线 题目描述 一个 n 个点 m 条边的无重边无自环的无向图，点有点权，边有 边权，定义一条路径的权值为路径经过的点权的最大值乘边权最大 值。求任意两点间的权值最小的路径的权值。 输入 第一行两个整数 n,m，分别表示无向图的点数和边数。 第二行 n 个正整数，第 i 个正整数表示点 i 的点权。 接下来 m 行每行三个正整数 ui,vi,wi，分别描述一条边的两个端 输出 n 行每行 n 个整数，第 i 行第 j 个整数表示从 i 到 j 的路径的最小 权值，如
PTA数据结构期末练习-单选题
Gecko_F的博客
06-28 9949
数据结构练习题
普利姆算法解决最短修路问题
cai_ing的博客
09-28 1258
普利姆算法 1、应用场景-修路问题 2、最小生成树 3、普利姆算法介绍 4、普利姆算法的最为简单的理解（重点）： 理论上7个点要6条路就可以连通，随便从一个结点（村庄）出发（假设为A），先找该结点和邻居结点（村庄）距离最小的结点（村庄），假设为B，最小路径为A–>B ,这样子A和B连通了。 把B加入已访问的集合中，则为（A，B） 找A的其他邻居和B的其他邻居，然后找到距离A或者B最小的那个邻居结点，假设为C点，且路径为B–>C最小,则A–>B B–>C 这样A
AtCoder Beginner Contest 218-ABCDEF 题解
Reinhart_L的博客
09-12 545
https://atcoder.jp/contests/abc218/tasks A - Weather Forecast 水题 #include<iostream> #include<cstring> #include<algorithm> #include<cmath> #include<vector> #include<queue> #include<stack> #include<map> #includ
Atcode - ABC 218 - D - Rectangles
weixin_51942493的博客
09-19 158
D - make_pair Constructs a pair object with its first element set to x and its second element set to y. The template types can be implicitly deduced from the arguments passed to make_pair. pair objects can be constructed from other pair objects containing
补题补题补题
qq_62122039的博客
05-05 273
Blocked Roads - AtCoder abc218_f - Virtual Judge tags:dijkstra 题意:给你一个有向图,在去除一条边后,求源点到n的最短路 2≤N≤400 1≤M≤N(N−1) TLE:m(o(n*n+m)超时 #include<iostream> #include<algorithm> #include<cstring> #include<map> #define x first #de
【ABC218H】Red and Blue Lamps（带权二分）
qq_47903865的博客
09-12 256
题目链接 题目大意 有 NNN 盏灯，你可以把其中 RRR 盏染成红色，其他染成蓝色。当第 iii 盏和第 i+1i+1i+1 盏灯颜色不同时，你将获得 AiA_iAi​ 的收益，问最多可以获得多少收益。 思路 当 2R>N2R>N2R>N 时，可以将 RRR 换成 N−RN-RN−R。 可以证明，最优方案染红的灯一定是不连续的。 因此转化为，你将 RRR 盏灯染红，将第 iii 盏灯染红可以获得 Ai−1+AiA_{i-1}+A_iAi−1​+Ai​ 的收益，要求红灯不连续，求最大收益。
# 756 div3 E1 E2（dfs F（双指针
cosx_的博客
11-26 3142
E1. Escape The Maze (easy version) 题意： 一个人从节点 111 开始出发，但是有 kkk 个阻碍，起点在 xix_ixi​ 节点，如果中途遇到阻碍则会输掉游戏，每秒只能移动到相邻的节点，也可以不移动。 判断他能不能一定走到一个叶子节点，而不碰到阻碍。 思路： 显然他能胜利的条件就是存在一个叶子节点，111 到叶子节点的距离小于 kkk 个阻碍到叶子节点的距离 ans[i]ans[i]ans[i] 数组表示阻碍到节点 iii 的最小距离 dfsdfsdfs 暴搜两次即可 先
把一个数变成1的最小操作数
cosx_的博客
11-24 1087
A题目 小思维 #include<iostream> int main(){ int t; cin >> t; while (t--) { int n; cin >> n; if (n == 1) cout << 0 << "\n"; else if (n == 2) cout << 1 << "\n"; else if (n == 3) cout << 2 << "\
2021 RoboCom 世界机器人开发者大赛-本科组（初赛）
cosx_的博客
10-11 1023
7-2 芬兰木棋 (25 分) 被这题背刺了，最后才想明白wa点，想了一个小时，草了 code： #include<bits/stdc++.h> #define endl '\n' #define ll long long using namespace std; const int maxn = 1e5 + 9; const int mod = 1e9 + 7; const int inf = 0x3f3f3f3f; ll n, m; int x[maxn], y[maxn], p[maxn]
#762 (Div. 3) E. MEX and Increments（贪心构造
cosx_的博客
12-21 622
E. MEX and Increments 题意： 思路： 贪心加模拟 code： #include<bits/stdc++.h> #define endl '\n' #define ll long long #define ull unsigned long long #define ld long double #define all(x) x.begin(), x.end() #define eps 1e-6 using namespace std; const int maxn = 2e
2021ccpc 网络赛 补题 Time-division Multiplexing（二分） && Power Sum && Function
cosx_的博客
08-29 615
Power Sum-hdu-7105 这个题要知道一个性质： (x+1)2(x+1)^2(x+1)2−-−(x+2)2(x+2)^2(x+2)2−-−(x+3)2(x+3)^2(x+3)2+++(x+4)2(x+4)^2(x+4)2===444 用四个数为构造 nnn 贡献 444 的大小，然后 nnn modmodmod 444 =0,1,2,3=0,1,2,3=0,1,2,3，我们还可以发现 1=11=11=1，4−1=34-1=34−1=3，−1−4−9+16=2-1-4-9+16=2−1−4−9+1
C语言实现TSP问题启发式搜索与最小生成树构建
这里的启发式搜索方法结合了最小生成树算法来简化问题。 首先，作者使用Kruskal算法构建无向图G的最小生成树。Kruskal算法是一种贪心算法，它通过逐步添加权值最小的边，保持边集合中的图仍然是森林，直到形成一棵...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值