CF1439 Codeforces Round #684 (Div. 1)

最新推荐文章于 2022-08-07 16:36:35 发布
最新推荐文章于 2022-08-07 16:36:35 发布
阅读量187 收藏
点赞数
分类专栏： codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/micaudience/article/details/109776411
版权

CF 1439 Codeforces Round #684 (Div. 1)

A1

题意

一个0 / 1二维矩阵，每次操作可以选一个四宫格，并将其中三个数取反，找到在3nm步骤内将矩阵变成全0矩阵的方法。

思路

在这里插入图片描述
如果执行上图中的三个操作，四宫格内只有一个位置被操作了奇数次，其他位置都被操作了偶数次，因而相当于没有改变。因此，只需对每一个为1的位置都进行类似的操作就可以了。

Ａ2

题意

一个0 / 1二维矩阵，每次操作可以选一个四宫格，并将其中三个数取反，找到在nm步骤内将矩阵变成全0矩阵的方法。

思路

  1. 考虑一个四宫格内，如何将步数减少到4步以内。在一个四宫格内共有四种不同的操作。我们发现，按照上面的思路分别将四宫格内的数全部变为0时，有些操作是重复出现的。重复偶数次的步骤相当于不做，因此可以统计每一种操作出现的次数，然后只做出现奇数次的操作。这样，处理一个四宫格内的数最多4次就可以了。
  2. 考虑只有n* 2（即只有两列）的情况。对于前n-2行，如果这一行有一个1，那么就选择这一个1和下一行的两列做一次操作；如果这一行有两个1，那么就选择这两个1和下一行的一个位置做一次操作；如果没有1，那么就无需做操作了。这样就可以将n * 2的棋盘最终缩小成四宫格。
  3. 对于nm的棋盘，先处理其中的(n-2)(m-2)的位置，如果mp[i][j]是1，就将mp[i][j],mp[i+1][j],mp[i][j+1]同时操作。这样就可以将棋盘缩成两行+两列，然后，将最后的两行/列分别按照2.中的方法消除，最终变成一个四宫格。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
const int N = 110; 
struct NODE{
	int x1, y1, x2, y2, x3, y3;
	NODE(int a = 0, int b = 0, int c = 0, int d = 0, int e = 0, int f = 0)
	{
		x1 = a;
		y1 = b;
		x2 = c;
		y2 = d;
		x3 = e;
		y3 = f;
	}
};
int mp[N][N];
char s[N][N];
int cnt[5];
vector<NODE>ans;
int main()
{
	int T;
	scanf("%d", &T);
	while(T)
	{
		T--;
		ans.clear();
		int n, m;
		scanf("%d%d", &n, &m);
		for(int i = 1; i <= n; i++)
			scanf("%s", s[i] + 1);
		for(int i = 1 ; i <= n; i++)
			for(int j = 1; j <= m; j++)
				mp[i][j] = s[i][j] - '0';
		for(int i = 1; i <= n - 2; i ++)
		{
			for(int j = 1; j <= m - 2; j++)
			{
				if(mp[i][j])
				{
					ans.push_back(NODE(i, j, i + 1, j, i, j + 1));
					mp[i][j] ^= 1;
					mp[i][j + 1] ^= 1;
					mp[i + 1][j] ^= 1;
				}
			} 
		}
		for(int i = 1; i <= n - 2; i++)
		{
			if(mp[i][m - 1] && mp[i][m])
			{
				ans.push_back(NODE(i, m - 1, i, m, i + 1, m - 1));
				mp[i][m - 1] ^= 1;
				mp[i][m] ^= 1;
				mp[i + 1][m - 1] ^= 1;	
			}
			else
			{
				if(mp[i][m - 1])
				{
					ans.push_back(NODE(i, m - 1, i + 1, m - 1, i + 1, m));
					mp[i][m - 1] ^= 1;
					mp[i + 1][m - 1] ^= 1;
					mp[i + 1][m] ^= 1;
				}
				else
				{
					if(mp[i][m])
					{
						ans.push_back(NODE(i, m, i + 1, m - 1, i + 1, m));
						mp[i][m] ^= 1;
						mp[i + 1][m - 1] ^= 1;
						mp[i + 1][m] ^= 1;
					} 
				} 
			} 
		}
		for(int j = 1; j <= m - 2; j++)
		{
			if(mp[n - 1][j] && mp[n][j])
			{
				ans.push_back(NODE(n - 1, j, n, j, n - 1, j + 1));
				mp[n - 1][j] ^= 1;
				mp[n][j] ^= 1;
				mp[n - 1][j + 1] ^= 1;
			}
			else
			{
				if(mp[n - 1][j])
				{
					ans.push_back(NODE(n - 1, j, n - 1, j + 1, n, j + 1));
					mp[n - 1][j] ^= 1;
					mp[n - 1][j + 1] ^= 1;
					mp[n][j + 1] ^= 1;
				}
				else
				{
					if(mp[n][j])
					{
						ans.push_back(NODE(n, j, n - 1, j + 1, n, j + 1));
						mp[n][j] ^= 1;
						mp[n - 1][j + 1] ^= 1;
						mp[n][j + 1] ^= 1;
					}
				}
			}
		}
		cnt[1] = cnt[2] = cnt[3] = cnt[4] = 0;
		if(mp[n - 1][m - 1])
		{
			cnt[1]++;
			cnt[2]++;
			cnt[3]++;
		}
		if(mp[n - 1][m])
		{
			cnt[1]++;
			cnt[2]++;
			cnt[4]++;
		}
		if(mp[n][m - 1])
		{
			cnt[1]++;
			cnt[3]++;
			cnt[4]++;
		}
		if(mp[n][m])
		{
			cnt[2]++;
			cnt[3]++;
			cnt[4]++; 
		} 
		if(cnt[1] % 2)
		{
			ans.push_back(NODE(n - 1, m - 1, n, m - 1, n - 1, m));
			mp[n - 1][m - 1] ^= 1;
			mp[n][m - 1] ^= 1;
			mp[n - 1][m] ^= 1;
		}
		if(cnt[2] % 2)
		{
			ans.push_back(NODE(n - 1, m - 1, n - 1, m, n, m));
			mp[n - 1][m - 1] ^= 1;
			mp[n - 1][m] ^= 1;
			mp[n][m] ^= 1; 
		}
		if(cnt[3] % 2)
		{
			ans.push_back(NODE(n - 1, m - 1, n, m - 1, n, m));
			mp[n - 1][m - 1] ^= 1;
			mp[n][m - 1] ^= 1;
			mp[n][m] ^= 1;
		} 
		if(cnt[4] % 2)
		{
			ans.push_back(NODE(n - 1, m, n, m - 1, n, m));
			mp[n - 1][m] ^= 1;
			mp[n][m - 1] ^= 1;
			mp[n][m] ^= 1;
		}
		printf("%d\n", ans.size());
		for(int i = 0; i < ans.size(); i++)
			printf("%d %d %d %d %d %d\n", ans[i].x1, ans[i].y1, ans[i].x2, ans[i].y2, ans[i].x3, ans[i].y3);
	}	
	return 0;
}

C - Greedy Shopping

题意

n家商店排成一列，价格 a i a_{i} ai​是一个单调不增的序列。有两种操作：

  1. 将1~x家商店的价格改成 m a x ( a i , y ) max(a_{i}, y) max(ai​,y)
  2. 总y元，从第x家商店开始购物，走到第i家商店时，如果剩下的钱足够 a i a_{i} ai​，则消费 a i a_{i} ai​元，否则走到下一家，求出一个可以在多少家商店购物。

思路

线段树。
对于1操作，先找出第一个比y小的数的位置pos，如果pos <= x，则修改[pos, x]区间为y。为防止找不到比y小的数，可以在末尾加一个0。
对于2操作，记录区间和，如果区间和小于当前剩余的钱数，答案加上区间长度；否则，继续二分。但是这样处理，遍历到的区间数最大可达到 n 2 \frac{n}{2} 2n​，TLE。考虑最坏的情况，即每隔一家商店购物一次的情况。此时，设走到[i, i + 1]区间， y ≤ a i + a i + 1 ≤ 2 a i y \leq a_{i} + a_{i + 1} \leq 2a_{i} y≤ai​+ai+1​≤2ai​，则有 y − a i ≤ y 2 y-a_{i} \leq \frac{y}{2} y−ai​≤2y​，也就是说，每次走到一个可以购物的区间，y至少减少一半。那么总共的可购物区间不超过 l o g 2 y log_{2}{y} log2​y个，如果只对可购物区间进行询问，那么时间复杂度会大大降低。因此，在二分区间之前，先判断这个区间的最小值是否小于钱数，如果小于，则继续二分区间，否则不能在该区间购物。总时间复杂度为O( q ∗ l o g 2 n ∗ l o g 2 y q * log_{2}n * log_{2}y q∗log2​n∗log2​y)。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
const int N = 2e5 + 10;
int val[N * 4], mina[N * 4];
LL sum[N * 4];
bool flag[N * 4];
int a[N];
void pushdown(int x, int l, int r)
{
	int mid = (l + r) >> 1;
	if(flag[x])
	{
		val[x * 2] = val[x * 2 + 1] = val[x];
		mina[x * 2] = mina[x * 2 + 1] = mina[x];  
		sum[x * 2] = (LL)val[x] * (LL)(mid - l + 1);
		sum[x * 2 + 1] = (LL)val[x] * (LL)(r - mid); 
		flag[x * 2] = flag[x * 2 + 1] = true;
		flag[x] = false;
	 } 
}
void pushup(int x)
{
	sum[x] = sum[x * 2] + sum[x * 2 + 1];
	mina[x] = mina[x * 2 + 1];
}
void build(int x, int l, int r)
{
	if(l == r)
	{
		val[x] = a[l];
		sum[x] = a[l];
		mina[x] = a[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(x * 2, l, mid);
	build(x * 2 + 1, mid + 1, r); 
	pushup(x);
}
int get_lower(int x, int l, int r, int v)
{
	if(l == r)
		return l;
	int mid = (l + r) >> 1;
	pushdown(x, l, r);
	if(mina[x * 2] >= v)
		return get_lower(x * 2 + 1, mid + 1, r, v);
	return get_lower(x * 2, l, mid, v); 
}
void update(int x, int l, int r, int ll, int rr, int v)
{
	if(r < ll || rr < l)
		return;
	if(ll <= l && r <= rr)
	{
		flag[x] = true;
		val[x] = v;
		mina[x] = v;
		sum[x] = (LL)v * (LL)(r - l + 1);
		return;
	}
	pushdown(x, l, r);
	int mid = (l + r) >> 1;
	update(x * 2, l, mid, ll, rr, v);
	update(x * 2 + 1, mid + 1, r, ll, rr, v);
	pushup(x);
} 
int query(int x, int l, int r, int ll, int rr, int *v)
{
	if(r < ll || rr < l || mina[x] > (*v))
		return 0;
	if(ll <= l && r <= rr && sum[x] <= (LL)(*v))
	{
		(*v) -= sum[x];
		return r - l + 1;
	}
	if(l == r) return 0;
	pushdown(x, l, r);
	int mid = (l + r) >> 1;
	int ans = query(x * 2, l, mid, ll, rr, v);
	ans += query(x * 2 + 1, mid + 1, r, ll, rr, v);
	return ans;
}
int main()
{
	int n, q;
	scanf("%d%d", &n, &q);
	for(int i = 1; i <= n; i++)
		scanf("%d", &a[i]);
	build(1, 1, n + 1);
	for(int i = 1; i <= q; i++)
	{
		int opt, x, y;
		scanf("%d%d%d", &opt, &x, &y);
		if(opt == 1)
		{
			int pos = get_lower(1, 1, n + 1, y);
			if(pos <= x)
				update(1, 1, n + 1, pos, x, y);
		} 
		else
		 	printf("%d\n", query(1, 1, n + 1, x, n, &y));
	}
	return 0;
}
selia1078
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
CF1439B Graph Subset Problem
lahlah的博客
12-04 118
https://www.luogu.com.cn/problem/CF1439B kkk显然≤n\le \sqrt{n}≤n​ 首先度数<k−1< k-1<k−1的点及其相连的边是没用用的 所以可以先把这些点扔掉，剩下的点度数一定是≥k−1\ge k-1≥k−1的 如果不存在度数为k−1k-1k−1的点，那么吧其中一个联通块拿出来就是第一类的答案 否则枚举k−1k-1k−1度点，然后k2k^2k2枚举它的所有邻居，用map判断是否有连边,用unordered_map可以去掉log 因为这样
CF1439E Cheat and Win
Deep_Thinking的博客
11-18 445
Description 你有一个坐标范围在[0,1e9][0,1e9][0,1e9]的网格图，设所有的满足x&y=0x\&y=0x&y=0的点(x,y)(x,y)(x,y)为好的点，易证好点形成了一棵树，我们以(0,0)(0,0)(0,0)为根，给出mmm个好点点对(u,v)(u,v)(u,v)并把它们之间的路径上的点染为黑色。 现在A和B在玩游戏，A先手，每一次可以选择一个黑点以及它的祖先链的一个可空子集，将它们反色，最后不能操作的输。 B现在想通过修改若干次使得自己必胜，每一次
寻找大小为k的完全子图
lcl1234567890lcl的博客
07-21 821
.CF1439B Graph Subset Problem 题意如下： 您将获得一个具有 nn 个顶点和 mm 个边的无向图。 此外，您将获得一个整数 kk 。 找到一个大小为 kk 的团或一个非空的顶点子集，使得该子集的每个顶点在该子集中至少有 kk 个邻居。 如果没有这样的集团和子集报告它。 如果顶点的子集的大小为 kk 并且在该子集的每两个顶点之间存在一条边，则该顶点子集称为大小为 kk 的团。 如果一个顶点之间存在边，则称为另一个顶点的邻居。 思路： 其实题意已经提示的已经很清楚了，就是从度数小于k
codeforces1439B Graph Subset Problem
binarycopycode
11-18 377
https://codeforces.com/contest/1439/problem/B unordered_map,set都过不了，学习了jiangly的代码写了binary_search(e[x].begin(),e[x].end(),y)就过了，离谱 首先要有解那么就必须k*(k-1)<=2m，否则度数凑不出来大小为k的团，更凑不出每个点都>=k的子集 然后不停得把那些du<k的删去，如果要删掉一个du为k-1的，那么直接把他连向的点全拿出来看是不是一个团，用二分去找两两之间
codeforces1439A2. Binary Table (Hard Version)
binarycopycode
11-18 1548
https://codeforces.com/contest/1439/problem/A2 上来两构造题，直接痛苦面具，还好过的不是很慢。。。 从上往下搞，从左向右搞，只要当前为1，不管右边和下面是什么，直接把他变成0 然后考虑最下面两行，从左到右枚举列，不管右边是什么，当前是1，就选当前和右边两个 然后对于右下角的2*2格子，有4个，就先选3个，再搞剩下一个，由A1知道，对于任意一个1，我们可以用3次操作，实现不改变其他格子，把他变0了， 有3个，就直接选了，有2个，就选2个再选1个0，再把多
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include #include #include #include #include #include #...
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
传送门 题意： 一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到...
Codeforces Round #630 (Div. 2) D. Walk on Matrix（构造）
01-03
上面代码跑出来的dp[n][m]是0，然后从（1，1）（1，2）（2，2）（2，3）这样的相与值是k (看懂ans+k是啥应该就懂了) 代码： int main() { std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0); int ans=(1&...
Codeforces Round #629 (Div. 3) B. K-th Beautiful String
01-03
第一个bbb在倒数第二位有1个字符串，在倒数第三位有2个字符串…在倒数第nnn位时有n−1n-1n−1个字符串 可以根据第一个bbb的位置对字符串进行分组，然后找到第kkk个字符串在第几组里即可，然后再推出第二个bbb的位置...
Codeforces Round #684 题解（A~C2）（待更新）
Qiuker_jl的博客
11-18 214
文章目录A. Buy the StringB. Sum of MediansC. Binary Table (Easy Version and Hard Version) A. Buy the String 题目链接：A题 题目大意： 有一个01串，每个0的价格为c0，每个1的价格为c1，还可以花h元令串中某一个1变为0或0变为1，问买下这个01串最少要多少钱 分析： 签到题： 如果c0大于c1+h，就将所有的0变为1 如果c1大于c0+h，就将所有的1变为0 否则，不进行改变 代码： #include &
Codeforces Round #684 (Div. 2)
Fighting_Peter的博客
11-18 1006
A - Buy the String 要么全变成1要么全变成0要么一个都不改变，三种情况取最小。 #define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0) #pragma GCC optimize(2) #include<set> #include<map> #include<cmath> #include<stack> #include<queue> #include<rand
CF #684 div.2
qq_45787905的博客
11-19 103
CF #684 div.2 目前 ABCA. Buy the StringB. Sum of MediansC1. Binary Table (Easy Version)结尾 A. Buy the String 题目：A. Buy the String 题意：给定一个二进制串（01），其中，消除字符0需要C0花费，消除字符1需要C1花费，特别地，可以花费h对字符取反，问最少花费多少。 思路：入门题 ，很明显只要3种可能全变为1消费，全变为0消费，照原来消费（比较下单次操作价格即可，如 c0+h<c1，
CF1439C Greedy Shopping（二分+线段树）
lcl1234567890lcl的博客
07-22 81
CF1439C Greedy Shopping CF出好题！！！！ 修改： 这道题的区间修改有些复杂 但是题目中有一句话：给定一个大小为 n 的非升序列 a。 因此要修改某个区间，一定是从区间某个位置之后到区间结束为止，在这个新区间进行修改。 这时就可以进行二分了，查询某个单点，是否大于y，然后就可以修改了 查询： 第一眼看过去这个查询好坑啊 关键是它还可以跳过某个节点 这里可以简化一下问题，查询之前，可以加上[1,x]的值，使得查询区间变成[1,n]简化了问题 除了维护区间和之外，还要维护区间最小值，
Codeforces Round #684 (Div. 2) 个人总结
ckdfadeaway的博客
11-18 280
在刚刚这场codeforces之前，我的大号经历了两个月的折磨掉了近200分到了1512，小号也被我故意掉分掉成了1250。结果今天凌晨打出了人生巅峰，大小号同时进入全球前400名，一个250行的模拟直接一次性过。凌晨的时候显示大号能+120回1630，小号能+220回1450。由于两个号交的代码差不多，于是干脆用大模拟C2把小号hack了，但是凌晨的时候非常担心会不会小号先hack掉大号呢。结果竟然大小号都没被hack？？？ ...
PHP之MIME
jiet07的博客
11-18 1018
MIME的定义 MIME(Multipurpose Internet Mail Extensions)多用途互联网邮件拓展类型。 MIME设计的最初目的 MIME意为多功能Internet邮件扩展，它设计的最初目的是为了在发送电子邮件时附加多媒体数据，让邮件客户程序能根据其类型进行处理。然而当它被HTTP协议支持之后，它的意义就更为显著了。它使得HTTP传输的不仅是普通的文本，而变得丰富多彩。 MIME的文件格式 每个MIME类型由两部分组成，大类别+种类。 比如: 超文本标记语言文本 .html te
codeforces round #684 div2 （div2第四场）
qq_46264636的博客
11-18 169
第三题 22的方格中，你可以选三个然后变换一下，0-》1，1-》0； 问能否在nm中变换成全部是0的 #include<iostream> #include<algorithm> #include<cstdio> #include<cstring> using namespace std ; int t , n , m ; char s[110][110] ; int main(){ cin >> t ; while(t--){ sca
Codeforces Round #684 (Div. 2) 题解
张小生的先生的博客
11-20 229
题目链接：Codeforces Round #684 (Div. 2) A. Buy the String 贪心 int main() { int t; cin >> t; while(t--) { int n,c0,c1,h; cin >> n >> c0 >> c1 >> h; string s; cin >> s; int ans=0; if(c0>c1) { if(h+c1<
Codeforces Round #684 (Div. 1)
jisuanji2606414的博客
08-07 104
之前出过类似的题目，这类题除了针对一个一个进行填补或归位没有任何好方法，突破点就在限制的次数上，3*n*m 就意味着一个点构成的2*2方阵，要想单独改变一个而不去改变其余三个，需要进行三次操作。演草可以退出四个位置的1的改变方法，然后放在图上进行分类讨论即可。...
codeforces round #828 (div. 3)
最新发布
06-06
好的，以下是关于Codeforces Round #828 (Div. 3)的一些信息： Codeforces Round #828 (Div. 3)是Codeforces网站上的一场编程竞赛，属于Div. 3级别的比赛。该比赛于2022年3月1日 15:35 (UTC)开始，比赛时长为2个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值