Binary Table (Hard Version)(Easy Version)

最新推荐文章于 2021-01-18 12:13:56 发布
最新推荐文章于 2021-01-18 12:13:56 发布
阅读量206 收藏 2
点赞数 2
分类专栏： cf # 逻辑思维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43504141/article/details/110008545
版权

https://codeforces.com/contest/1440/problem/C2

题意：
给出n,m,给出nm的矩阵，由0和1组成，每次你可以执行一个操作，选出22正方形中的三个数，将这三个数反转。问在有限的步骤之内将矩阵变为全为0的矩阵的操作数以及操作。简单和困难问题的差别就是，操作数上限的不同。

思路：
构造。从左上到右下开始遍历，遇到1就将它变为0，再将右侧的数和下面的数转变。因为右侧和下面相邻的数都将再之后的遍历中操作到，如果是1的话会将其变为零，所以无论怎样转换都没有影响。
执行此操作一直到倒数第三行。从倒数第二行开始，按照列进行扫描。如果是1的话，就将右侧一列的两个数转换。同理，这两个数在之后的操作中都会遍历到，无论怎样转换对结果的正确性没有影响。
执行此操作直到最后的22矩阵。最后的这个22矩阵最多可以用四步转换为全0矩阵，而在之前我们是逐个遍历的，所以之前执行的操作数最多是nm-4，综上所述操作数最多为nm,满足题意，可以按此方法进行构造。

代码；

#include <cstdio>
#include <cstring>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <algorithm>
#include<bits/stdc++.h>
using namespace std;
const double N = 1e6+10;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
const inline int read(){
    int k = 0, f = 1; char c = getchar();
    for(;!isdigit(c); c = getchar())
        if(c == '-') f = -1;
    for(;isdigit(c); c = getchar())
        k = k * 10 + c - '0';
    return k * f;
}
#define ll long long
#define CL(a,b) memset(a,b,sizeof(a))
#define MAXN 205010
int a[110][110];
int x[MAXN];
int y[MAXN];
char c[110][110];
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    int t;
    cin >> t;
    while(t--)
    {
    	ll n , m;
    	cin >> n >> m;
    	for(int i = 1 ; i <= n ; i++)
    	{
    		for(int j = 1 ; j <= m ; j++)
    		{
    			cin >> c[i][j];
    			if(c[i][j] == '1')
    				a[i][j] = 1;
    			else
    				a[i][j] = 0;
			}
		}
		int num = 0;
		int l = 0;
		for(int i = 1 ; i <= n-2 ; i++)
		{
			for(int j = 1 ; j <= m ; j++)
			{
				if(a[i][j] == 1)
				{
					num++;
					a[i][j] = 0;
					if(j!=m)
					{
						if(a[i][j+1]==1)
							a[i][j+1] = 0;
						else
							a[i][j+1] = 1;
						if(a[i+1][j]==1)
							a[i+1][j] = 0;
						else
							a[i+1][j] = 1;
						x[l] = i;
						y[l] = j;
						l++;
						x[l] = i;
						y[l] = j+1;
						l++;
						x[l] = i+1;
						y[l] = j;
						l++;
					}
					else
					{
						if(a[i+1][j]==1)
							a[i+1][j] = 0;
						else
							a[i+1][j] = 1;
						if(a[i+1][j-1]==1)
							a[i+1][j-1] = 0;
						else
							a[i+1][j-1] = 1;
						x[l] = i;
						y[l] = j;
						l++;
						x[l] = i+1;
						y[l] = j;
						l++;
						x[l] = i+1;
						y[l] = j-1;
						l++;
					}
				}
			}
		}
		for(int i = 1 ; i <= m-2 ; i++)
		{
			for(int j = n-1 ; j <= n ; j++)
			{
				if(a[j][i] == 1)
				{
					num++;
					a[j][i] = 0;
					if(j==n-1)
					{
						if(a[j][i+1]==1)
							a[j][i+1] = 0;
						else
							a[j][i+1] = 1;
						if(a[j+1][i+1]==1)
							a[j+1][i+1] = 0;
						else
							a[j+1][i+1] = 1;
						x[l] = j;
						y[l] = i;
						l++;
						x[l] = j;
						y[l] = i+1;
						l++;
						x[l] = j+1;
						y[l] = i+1;
						l++;
					}
					else
					{
						if(a[j][i+1]==1)
							a[j][i+1] = 0;
						else
							a[j][i+1] = 1;
						if(a[j-1][i+1]==1)
							a[j-1][i+1] = 0;
						else
							a[j-1][i+1] = 1;
						x[l] = j;
						y[l] = i;
						l++;
						x[l] = j;
						y[l] = i+1;
						l++;
						x[l] = j-1;
						y[l] = i+1;
						l++;
					}
				}
			}
		}
//		cout << "****" << endl;
//		for(int i = 1; i <= n ; i++)
//		{
//			for(int j = 1 ; j <= m ; j++)
//			{
//				cout << a[i][j] << " ";
//			}
//			cout << endl;
//		}
//		cout << "****" << endl;
		if(a[n-1][m-1]==0&&a[n-1][m]==0&&a[n][m-1]==0&&a[n][m]==1)
		{
			num = num + 3;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==0&&a[n-1][m]==0&&a[n][m-1]==1&&a[n][m]==0)
		{
			num = num + 3;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==0&&a[n-1][m]==0&&a[n][m-1]==1&&a[n][m]==1)
		{
			num = num + 2;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==0&&a[n-1][m]==1&&a[n][m-1]==0&&a[n][m]==0)
		{
			num = num + 3;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==0&&a[n-1][m]==1&&a[n][m-1]==0&&a[n][m]==1)
		{
			num = num + 2;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==0&&a[n-1][m]==1&&a[n][m-1]==1&&a[n][m]==0)
		{
			num = num + 2;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==0&&a[n-1][m]==1&&a[n][m-1]==1&&a[n][m]==1)
		{
			num = num + 1;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
		}
		else if(a[n-1][m-1]==1&&a[n-1][m]==0&&a[n][m-1]==0&&a[n][m]==0)
		{
			num = num + 3;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==1&&a[n-1][m]==0&&a[n][m-1]==0&&a[n][m]==1)
		{
			num = num + 2;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==1&&a[n-1][m]==0&&a[n][m-1]==1&&a[n][m]==0)
		{
			num = num + 2;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==1&&a[n-1][m]==0&&a[n][m-1]==1&&a[n][m]==1)
		{
			num = num + 1;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
		}
		else if(a[n-1][m-1]==1&&a[n-1][m]==1&&a[n][m-1]==0&&a[n][m]==0)
		{
			num = num + 2;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==1&&a[n-1][m]==1&&a[n][m-1]==0&&a[n][m]==1)
		{
			num = num + 1;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
		}
		else if(a[n-1][m-1]==1&&a[n-1][m]==1&&a[n][m-1]==1&&a[n][m]==0)
		{
			num = num + 1;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		else if(a[n-1][m-1]==1&&a[n-1][m]==1&&a[n][m-1]==1&&a[n][m]==1)
		{
			num = num + 4;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
			x[l] = n;
			y[l] = m;
			l++;
			x[l] = n-1;
			y[l] = m-1;
			l++;
			x[l] = n-1;
			y[l] = m;
			l++;
			x[l] = n;
			y[l] = m-1;
			l++;
		}
		cout << num << endl;
		for(int i = 0 ; i < l ; i=i+3)
		{
			cout << x[i] << " " << y[i] << " ";
			cout << x[i+1] << " " << y[i+1] << " ";
			cout << x[i+2] << " " << y[i+2] << endl;
		}
	}
    return 0; 
}
小飞猪Jay
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bin-version-cli:以semver格式获取二进制文件的版本
05-13
$ bin-version <binary> [arguments] The arguments default to `--version` Exits with code 2 if no version could be found Examples $ curl --version curl 7.30.0 (x86_64-apple-darwin13.0) $ bin-...
Java binarysearch方法原理详解
08-25
Java中的binarySearch方法是Java.util.Arrays类提供的一个静态方法，用于在数组中搜索指定的元素。该方法有两个用法，分别是搜索整个数组和搜索指定范围内的元素。 binarySearch(Object[], Object key)方法 该方法...
Binary Table (Easy Version)-（思维）
Cosmic_Tree的博客
11-18 658
题目描述：点击进入 题意 给你一个大小为n×m的二进制表，这个表由符号 0 和符号 1 组成。 你可以进行这样的操作： 选择属于一个 2 × 2 正方形的 3 个不同的单元格，并更改这些单元格中的符号（将 0 更改为1， 1 更改为 0 ）。 你的任务是使表中的所有符号都等于0。您最多可以进行 3nm次 操作。 你不需要最小化操作的数量。 思路1 通过找找规律，我们可以知道一个 2*2 的矩阵 不包含0的可以通过一次操作变为包含3个0的， 包含3个0的通过一次操作可以变为包含2个0的， 包含2个0的通过一次
<Excel> 数据分析之用Power Query实现数据转换和清洗（功能操作篇）
热门推荐
su_2018的博客
10-27 3万+
一个案例快速了解Power Query 凭借 Power Query，可以搜索数据源，创建连接，然后按照可满足你需求的方式调整数据（例如删除列、更改数据类型或合并表格）以创建报表。 例：将门店一&门店二两个工作簿的数据整合到一张工作表，并统计出各销售代表每个月的业绩 数据的行列管理及删除重复项 如下例所示： 数据格式的转换及删除错误 如下例所示，更改表格中标注黄色的异常单...
Binary Table (Hard Version)-（思维）
Cosmic_Tree的博客
11-18 1677
题目描述：点击进入 题意 给你一个大小为n×m的二进制表，这个表由符号 0 和符号 1 组成。 你可以进行这样的操作： 选择属于一个 2 × 2 正方形的 3 个不同的单元格，并更改这些单元格中的符号（将 0 更改为1， 1 更改为 0 ）。 你的任务是使表中的所有符号都等于0。您最多可以进行 nm次 操作。 你不需要最小化操作的数量。 思路 这是上一题的加强版，操作次数变为 nm 了，我上一次的代码过不去，无奈只能优化，但也只是对边界处理优化了一下，却神奇过了（神奇神奇，用xy哥的话来说那就是可蒸馏啊）
Codeforces Round #684 (Div. 2)
qq_43461168的博客
01-18 158
A. Buy the String 题意：01串，买一个0代价c0，买一个1代价c1。可以改变01的值，代价为h。求最小代价。 思路：贪心。如果0变成1再买更便宜就先变成1再买。 1同理。 AC代码： #include <bits/stdc++.h> #define int long long using namespace std; const int N = 4e5 + 10; const int mod = 1e9+7; const int inf = 1e18; int t,n,m,k;
CodeForces 663E - Binary Table
lambda QAQ
11-18 1391
给出一个n(n≤20)n(n \le 20)行m(m≤105)m(m\le 10^5)列的0101矩阵。每次操作可以将某一行取反或者将某一列取反。要求操作后的矩阵中的11的个数最少，求最小个数。因为行比较少，我们考虑状压。状压每一列的状态，stasta第ii位为11表示第ii行为11，为00表示第ii行为11用一个函数F(sta)F(sta)表示状态为stasta的列的数量考虑状压我们操作了哪些行，
Ordered-binary-search-table.zip_Table
09-24
用c/c++写的有序表的折半查找，有兴趣的朋友可以看一下
windows-platform-binary-table.zip_windows_wpbt
09-24
windows platform binary table (WPBT)
Binary Bat Algorithm
01-16
Binary Bat Algorithm based on MATLAB Citation: S. Mirjalili, S. M. Mirjalili, X. Yang. Binary Bat Algorithm. Neural Computing and Application, in press, DOI: 10.1007/s00521-013-1525-5.
解题报告：CodeForces - 662C:Binary Table FWT(快速沃尔什变换)
Hee的博客~
08-03 777
题目链接 题意： 给定一个至多20*100000的01矩阵，可以选择任意行或列，选择行或列的01值改变，问经过操作能到最少的含1的数量。 思路： 因为行最大为20，考虑将每一列压缩成一个20位的整数，选择的行也最多只有20，同样压缩到一个20位的整数。 改变行上的01值，对应的操作为异或，那么就能写出对应的卷积式： 根据异或运算的性质，可以交换j,k的位置，得到： C[k
CodeForces 663E - Binary Table FWT
I good vegetable a!
01-10 795
【题目链接】见这里 【题意】 给出一个n(n≤20)行m(m≤105)列的01矩阵。每次操作可以将某一行取反给出一个n(n≤20)行m(m≤105)列的01矩阵。每次操作可以将某一行取反或者将某一列取反。要求操作后的矩阵中的1的个数最少，求最小个数。或者将某一列取反。要求操作后的矩阵中的1的个数最少，求最小个数。 【解题思路】 由于行比较少，我们考虑状压。状压每一列的状态，sta第i位为1
fwt_xor Codeforces663E Binary Table
qwb的博客
09-20 1149
传送门：点击打开链接 题意：操作任意的行和列，把01调换，使得最后的1的个数最少。 因为n 用F函数来记录所有的mask出现的次数。用G函数来记录某个状态翻转这一列或者不翻转这一列，最少的1的个数。 之后对F函数和G函数，求异或卷积，就得到了行的方案了，每个位置即是这种方案1的个数。 这个方法实在是太无敌了QAQ #include #include #include #inclu
【CodeForces 662C】Binary Table
LYD729
03-04 318
Description 给定一个n*m的01矩阵，可以任意对整行、整列进行异或操作。可以操作任意次。问最后矩阵中最少有多少个1 n&amp;lt;=20,m&amp;lt;=10^5 Analysis 发现n很小，小到我们可以枚举出行的全部操作状态，且可以将一列看成一个整数。那么只需要快速求出在次状态下列的贡献和。 设cscsc_s为状态为sss时的答案，那么如果令axaxa_x为初始矩阵中列的值为...
【CodeForces662C】Binary Table
cz_xuyixuan的博客
03-07 434
【题目链接】点击打开链接【思路要点】行的取反情况与每一列的初始元素可以看做若干个小于\(2^{N}\)的二进制数。注意到行很小，我们考虑先枚举每一行是否取反，令行的取反情况为\(Mask\)。那么，每列的二进制数\(x_i\)应当变成\(x_i\ xor\ Mask\)。令\(bits_i\)代表\(i\)的二进制表示1的个数，\(Mask\)的最小答案应当为\(\sum_{i=1}^{M}min...
[CF662C]Binary Table
七代目鸽影
09-14 182
桶排的思想发挥了重要作用吗？似乎也不对。那么这是怎么想到的呢？
C2. Binary Table (Hard Version)(构造+大模拟)
代码笔记本
11-19 397
https://codeforces.com/contest/1440/problem/C2 C1的法子不够优秀，C2要求是nm的。猜测是每个点来一次，最后进行一个特判。 构造发现： 首先每次将(1，1）~(n-2,m)全部变成0。一个个遍历。然后处理最后两行至m-2列。最后处理最后两列。 一个个遍历，对于第一个case，进行当前位是1，就变相邻右和下面，如果到了边界就改成下面和左下。 第二个case，对于处于n-1行的，变本身，右1，右2，对于处于n行的，变右1,右2，每次这样能使当前两行的列.
Codeforces 684 Div. 2 A. Buy the String B. Sum of Medians C2. Binary Table (Hard Version)
萧瑟的博客
11-18 509
A. Buy the String https://codeforces.com/contest/1440/problem/A You are given four integers n, c0, c1 and h and a binary string s of length n. A binary string is a string consisting of characters 0 and 1. You can change any character of the string s (the s
codeforces1439A2. Binary Table (Hard Version)
binarycopycode
11-18 1551
https://codeforces.com/contest/1439/problem/A2 上来两构造题，直接痛苦面具，还好过的不是很慢。。。 从上往下搞，从左向右搞，只要当前为1，不管右边和下面是什么，直接把他变成0 然后考虑最下面两行，从左到右枚举列，不管右边是什么，当前是1，就选当前和右边两个 然后对于右下角的2*2格子，有4个，就先选3个，再搞剩下一个，由A1知道，对于任意一个1，我们可以用3次操作，实现不改变其他格子，把他变0了， 有3个，就直接选了，有2个，就选2个再选1个0，再把多
the binary version of its metadata is 1.8.0, expected version is 1.6.0.
最新发布
09-19
该元数据的二进制版本是1.8.0，预期版本是1.6.0。 这个问题表明元数据（即数据的描述信息）的二进制版本与预期的版本不匹配。二进制版本被用来标识数据结构的特定格式和规范。在这种情况下，元数据的二进制版本是1.8.0，而预期版本是1.6.0。 相比预期版本，二进制版本的更新可能导致一些问题。更新的版本通常会引入新功能、更改或优化现有功能，这可能会导致与旧版本的不兼容性。 解决这个问题的一种方法是将元数据的二进制版本降级到预期版本。这可能需要使用相应的工具或软件来进行转换或兼容处理。另外，还可以检查数据源或提供者，确保提供的元数据与所需的版本一致。 如果不能修改或转换二进制版本，那么需要考虑更新使用该元数据的应用程序或工具，以使其兼容当前的二进制版本。 总结而言，对于元数据的二进制版本与预期版本不匹配的问题，我们可以通过将二进制版本降级、转换或更新应用程序等方式来解决。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值