蓝桥杯 2014-10 矩阵翻硬币

小明先把硬币摆成了一个 n 行 m 列的矩阵。
随后，小明对每一个硬币分别进行一次 Q 操作。
对第x行第y列的硬币进行 Q 操作的定义：将所有第 ix 行，第 jy 列的硬币进行翻转。
其中i和j为任意使操作可行的正整数，行号和列号都是从1开始。
当小明对所有硬币都进行了一次 Q 操作后，他发现了一个奇迹——所有硬币均为正面朝上。
小明想知道最开始有多少枚硬币是反面朝上的。于是，他向他的好朋友小M寻求帮助。
聪明的小M告诉小明，只需要对所有硬币再进行一次Q操作，即可恢复到最开始的状态。然而小明很懒，不愿意照做。于是小明希望你给出他更好的方法。帮他计算出答案。
输入
输入数据包含一行，两个正整数 n m，含义见题目描述。
数据规模和约定
对于100%的数据，n、m < = 10^1000（10的1000次方）。
输出
输出一个正整数，表示最开始有多少枚硬币是反面朝上的。
样例输入
2 3
样例输出
1

这个数据规模一看就不能用模拟，可是也一时想不起其它方法。
对所有硬币都进行一次Q操作，对于一个硬币如果经过这次所有操作后从正面变成了反面，那么一定是奇数次翻面，那么我们就要看看经过所有操作后一个硬币翻了多少次面。一个硬币会翻面的条件是什么呢？要看懂这一句话“对第x行第y列的硬币进行 Q 操作的定义：将所有第 ix 行，第 jy 列的硬币进行翻转。”也就是与当前硬币的行数和列数呈倍数关系的位置会翻面，行和列的倍数不必相同。
假设硬币（x，y），它会翻几次面？（取决于它是几个数的倍数，可以转化为求有几个因数）取决与它的行和列的因子个数，假设行有因子3个，列有因子3个，那么它会被翻33=9次。（倍数关系转成因子关系）
假设硬币（9，9），它的因子有1，3，9；（1，1）（1，3）（1，9）（3，1）（3，3）（3，9）（9，1）（9，3）（9，9）。当以上硬币进行Q操作时，都会使（9，9）翻面。
所以理一下，我们要求有多少个硬币是反面，就是求有多少个硬币进行了奇数次Q操作，也就是求有多少个位置行列因子数乘积是奇数。
接下来的问题就是求一个数的因子数，其实我们只是想知道因子数是奇数还是偶数，不用知道具体值，而一个数的因子一般是xy=z的形式，一般是成对出现的，当出现奇数时，说明x=y，也就是一个数的因子个数是奇数个，那么这个数是一个平方数，那么现在我只需要求行和列有多少是平方数。
但是呢，这个题的数据范围超级大，我们就算枚举也需要至少O（n）的时间，但是肯定会超时，接下来就是放大招了。
从1-n的平方数的个数=n开平方向下取整
记住记住！！！！！！！！！！！！！
接下来的问题就是求大数的开方，又是一个难点，记住即可。
一个数的开方数的位数：
如果这个数的长度（l）是奇数：l / 2 + 1
如果这个数的长度（l）是偶数：l / 2
然后枚举求开方数
从最高位开始枚举，假设求256的开方数，256的l是3，3/2+1=2，所以长度是2位，
一开始所有位数都是0，第一位从1开始，1010<256，所以接着用2试探，2020>256.所以第一位写1，接着下一位再开始试探，1111<256,1212<256,1313<256,1414<256,1515=256,1616>256，所以第二位写5，最终得到开方数是15.

具体细节就是数据太大，我们要用到java特有的大数类型
所以核心代码：

BigInteger res = sqrt2(n).multiply(sqrt2(m));

在求大数的平方时可以直接用java自带的函数

BigInteger res = new BigInteger(String.valueOf(arr)).pow(2);

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class okt10矩阵翻硬币 {
	// 对第x行第y列的硬币进行 Q 操作的定义：将所有第 i*x 行，第 j*y 列的硬币进行翻转。
	// 我们如果要求最终有几个0,便是求有几个位置可以进行奇数次翻转。
	// 一个(n,m)矩阵在对每一个元素都进行Q操作后,0的个为根号下n乘以根号下m

//	  假设位数为len的整数，开方取整后为一个lenSqrt位数。
//      当len为偶数，lenSqrt = len / 2 .
//      当len为奇数，lenSqrt = (len / 2) + 1 .
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
//		BigInteger n = scanner.nextBigInteger();
//		BigInteger m = scanner.nextBigInteger();
//		BigInteger res = sqrt1(n).multiply(sqrt1(m));
		String n = scanner.next();
		String m = scanner.next();
		BigInteger res = sqrt2(n).multiply(sqrt2(m));
		System.out.println(res);

	}

	// 大数开根号，字符串查找(解析)
	private static BigInteger sqrt2(String s) {
		int len = 0;
		if (s.length() % 2 == 0) {
			len = s.length() / 2;
		} else {
			len = s.length() / 2 + 1;
		}
		char[] arr = new char[len];
		Arrays.fill(arr, '0');
		BigInteger sBigInteger = new BigInteger(s);
		for (int pos = 0; pos < len; pos++) {
			for (char i = '1'; i <= '9'; i++) {
				arr[pos] = i;
				BigInteger res = new BigInteger(String.valueOf(arr)).pow(2);
				if (res.compareTo(sBigInteger) == 1) {
					// arr[pos] = (char) (arr[pos] - 1);
					arr[pos] -= 1;
					break;
				}
			}
		}
		return new BigInteger(String.valueOf(arr));

	}

	// 大数开根号，折半查找法(自己写的)
	private static BigInteger sqrt1(BigInteger n) {
		// TODO Auto-generated method stub
		BigInteger l = BigInteger.ONE;
		BigInteger r = n;
		BigInteger mid = BigInteger.ZERO;
		while (l.compareTo(r) != 1) {
			mid = (l.add(r)).divide(BigInteger.valueOf(2));
			// System.out.println(mid);
			if (mid.multiply(mid).compareTo(n) == 0) {
				break;
			}
			if (mid.multiply(mid).compareTo(n) == 1) {
				r = mid.subtract(BigInteger.ONE);
			} else {
				l = mid.add(BigInteger.ONE);
			}
		}
		if (mid.multiply(mid) != n && l.multiply(l).compareTo(n) == 1) {
			l = l.subtract(BigInteger.ONE);
		}
		mid = l;
		return mid;
	}

//大数开根号，折半查找法（解析写的）
	private static BigInteger sqrt(BigInteger n) {
		// TODO Auto-generated method stub
		BigInteger l = BigInteger.ONE;
		BigInteger r = n;
		BigInteger temp = BigInteger.ZERO;
		while (!l.equals(r)) {
			BigInteger mid = (l.add(r)).divide(BigInteger.valueOf(2));
			// System.out.println(mid);
			if (temp.compareTo(BigInteger.ZERO) != 0 && temp.compareTo(mid) == 0) {
				break;
			} else {
				temp = mid;
			}
			if (mid.multiply(mid).compareTo(n) == 1) {
				r = mid;
			} else {
				l = mid;
			}
		}
		if (l.multiply(l).compareTo(n) == 1) {
			l = l.subtract(BigInteger.ONE);
		}

		return l;
	}

}

是不是很神奇，本来数据量这么大的题，竟然在很小的时间复杂度下就实现了。