[蓝桥杯]算法训练 审美课

0x00 题目内容

问题描述

　　《审美的历程》课上有n位学生，帅老师展示了m幅画，其中有些是梵高的作品，另外的都出自五岁小朋友之手。老师请同学们分辨哪些画的作者是梵高，但是老师自己并没有答案，因为这些画看上去都像是小朋友画的……老师只想知道，有多少对同学给出的答案完全相反，这样他就可以用这个数据去揭穿披着皇帝新衣的抽象艺术了（支持帅老师^_^）。
　　答案完全相反是指对每一幅画的判断都相反。

输入格式

　　第一行两个数n和m，表示学生数和图画数；
　　接下来是一个n*m的01矩阵A：
　　如果aij=0，表示学生i觉得第j幅画是小朋友画的；
　　如果aij=1，表示学生i觉得第j幅画是梵高画的。

输出格式

　　输出一个数ans：表示有多少对同学的答案完全相反。

样例输入

3 2
1 0
0 1
1 0

样例输出

2

样例说明

　　同学1和同学2的答案完全相反；
　　同学2和同学3的答案完全相反；
　　所以答案是2。

数据规模和约定

　　对于50%的数据：n<=1000；
　　对于80%的数据：n<=10000；
　　对于100%的数据：n<=50000，m<=20。

0x01 问题抽象

• 解决本问题本文主要介绍两种算法:朴素算法和互补算法.

1.朴素算法

问题的实质就是遍历整个矩阵,然后从上到下两两进行某种对比操作,条件成立则计数,遍历完成后便输出计数值,完成.

2.互补算法

推论:对于数据宽度为nBit的数据,数a与(-1)-a互补.(0 ≤ a ≤ -1)

例如10进制数1和2,他们的二进制代码分别为01和10,我们发现01和10是互反的,对与数据宽度为2Bit的数据(就是用2个Bit来表示数据,最小可以表示0(00B),最大可以表示3(11B),共4个数),数1与(2²-1)-1(也就是2)互补,当然0也与3互补咯~

0x02 输入处理

• 通过问题可以看出,输入的数据全部都是1和0,整个矩阵全为1和0组成的布尔矩阵.

1.二维数组处理

最简单,最粗暴的方法就是声明二维数据,管他3721全部都存到数组里面去.后期利用朴素算法进行对比也好操作,但是时间与空间复杂度有些高呀~

2.位存储

从题目中可以看出,所有的输入都是1和0,若把一行的1和0按位存储到一个int型的变量中,这将大大提高空间的利用率,而且每一行都是可以最终转化为一个10进制数,思路如下.

0.假设要输入1 0 1 0

1.声明一个int型变量a,并赋值为0;(变量a内存位视图:0000)

2.对a左移1位;(变量a内存位视图:0000)

3.从输入缓冲区中接受一个值到变量b中,此时接受到了1;(变量b内存位视图:0001)

4.a与b按位或操作(0000 | 0001 = 0001)存入a

5.回到步骤2直到读完本行

• 算法执行过程如下(可跳过):

循环0

0000右移1位

0000

接收1

或操作

0000 | 0001 = 0001

循环1

0001右移1位

0010

接收0

或操作

0010 | 0000 = 0010

循环2

0010右移1位

0100

接收1

或操作

0100 | 0001 = 0101

循环3

0101右移1位

1010

接收0

或操作

1010 | 0000 = 1010

算法完成.

0x03 计数算法

对于利用二维数组存储并利用判断来匹配是否互补的算法,在这里就不阐述,我相信大家很轻易的就能够解决,这里主要解释位存储与互补算法的应用,下面给出一个程序,相信大家都能看懂.

# include <iostream>
# define N 50000 
# define M 20 
bool matrix[N][M];
using namespace std;

int main(void)
{
	int n, m;// 行 列
	int i, j, k;
	long long sum = 0;

	while (cin >> n >> m)
	{
		for (i = 0; i < n; i++)
			for (j = 0; j < m; ++j)
				cin >> matrix[i][j];

		for (i = 0; i < n; i++)
			for (j = i + 1; j < n; ++j)
				for (k = 0; k < m; ++k)
					if (matrix[i][k] + matrix[j][k] != 1)
						break;
					else
						if (k == m - 1)
							sum++;
		cout << sum << endl;
		sum = 0;
	}

	return 0;
}

1.朴素算法

利用位存储,很轻易的将每一行转化为了一个10进制数,将这些数放到数组m中;随后遍历整个矩阵,然后从上到下两两进行互补对比操作,条件成立则计数,遍历完成后便输出计数值,完成.

关于互补对比操作,若两个数据宽度为2Bit数字互补,则两个数进行异或操作后等于2²-1即3(01 ^ 10 = 11)(00 ^ 11 = 11),推广后的结论为:对于数据宽度为nBit数字互补,则两个数进行异或操作后等于-1.

下面给出程序.

# include <iostream>
# include <math.h>
using namespace std;

int main(void)
{
	int t, i, j;
	int h, n;

	while (cin >> h >> n)
	{
		int m[50001] = {0};

		for (i = 0; i < h; ++i)
		{
			//位操作
			int k = 0;
			for (j = 0; j < n; ++j)
			{
				cin >> t;
				k = k << 1;
				k = k | t;
			}
			m[i] = k;
		}

		//根据数据宽度算出最大值k
		int k = 2;
		k = pow(k, n) - 1;

		int all = 0;
		for (i = 0; i < h; ++i)
			for (j = i + 1; j < h; ++j)
				if ((m[i] ^ m[j]) == k)//互补对比操作
					all++;//计数

		cout << all << endl;
	}
	return 0;
}

2.乘积算法

1.算法介绍

假设输入系统的矩阵是一下的内容:

6 4

[1] 1 0 0 1

[2] 1 0 0 1

[3] 1 0 0 1

[4] 0 1 1 0

[5] 0 1 1 0

[6] 1 1 0 0

其中不难发现[1][2][3]分别与[5][6]互补,且他们转化为10进制数分别位9和6,而[6]并没有与它所互补的行,所以这个矩阵行行互补的个数为:6,刚好等于矩阵中为10进制数9的个数与6的个数的乘积.

根据这个思路,利用位存储进行输入,将每行的二进制数转化为1个十进制数,统计所有相同10进制数的个数,存入数组m(数组m所有元素初值设为0)中,简易代码如下.

	for (i = 0; i < h; ++i)
		{
			int k = 0;

			for (j = 0; j < n; ++j)//移位,让二进制输入到变量中
			{
				cin >> t;
				k = k << 1;
				k = k | t;
			}
			m[k]++;//相应的数字+1操作
		}

例如:对于数a,利用互补算法很容易得到与a互补的数字,例如上面的例子,m[9] = 3,m[-1-9] = a[6] = 2,则与9互补的数为m[9]*m[-1-9] = 3*2 = 6.

与数字a互补的个数为:m[a]*m[-1-a].

对于所有输入的数字,若每行输入n个二进制数,共有个数,数组下标范围为[0,-1],对其中一半的数进行利用乘积算法计数求和,最终可以得到所有两两行互补的个数,代码如下.

    p = pow(p, n) - 1;
		
	int all = 0;

	for (i = 0; i <= p / 2 + 1; ++i)
		all = all + (m[i] * m[p - i]);

	cout << all << endl;

 

算法的完整代码如下.

# include <iostream>
# include <math.h>
# include <vector>
using namespace std;

int main(void)
{
	int t, i, j;
	int h, n;

	while (cin >> h >> n)
	{
		vector <int> m;
		int p = 2;
		p = pow(p, n) - 1;
		m.resize(p + 1, 0);

		for (i = 0; i < h; ++i)
		{
			int k = 0;

			for (j = 0; j < n; ++j)
			{
				cin >> t;
				k = k << 1;
				k = k | t;
			}
			m[k]++;
		}

		int all = 0;
		for (i = 0; i <= p / 2 + 1; ++i)
			all = all + (m[i] * m[p - i]);

		cout << all << endl;
	}
	return 0;
}

 

0x04 后语

• 对于乘积算法解释不是很到位,但是原理不是很难,相信你一定可以掌握.
• No Pains,No Gains.