小明系列故事——未知剩余系

最新推荐文章于 2020-01-27 21:20:32 发布

luyehao1

最新推荐文章于 2020-01-27 21:20:32 发布

阅读量540

点赞数 2

分类专栏： ACM-数论文章标签：小明系列故事未知剩余系 hdu 1004 数论残阳止水

本文链接：https://blog.csdn.net/luyehao1/article/details/75012709

版权

ACM-数论专栏收录该内容

9 篇文章 1 订阅

订阅专栏

小明系列故事——未知剩余系

Problem Description

　　“今有物不知其数，三三数之有二，五五数之有三，七七数之有二，问物几何？”

　　这个简单的谜题就是中国剩余定理的来历。

　　在艰难地弄懂了这个定理之后，小明开始设计一些复杂的同余方程组X mod ai = bi 来调戏别人，结果是必然的，都失败了。

　　可是在这个过程中，小明发现有时并不一定要把ai和bi告诉你。他只需要告诉你，ai在区间 [1, X] 范围内每个值取一次时，有K个ai使bi等于0，或有K个ai使bi不等于0，最小的X就可以求出来了。

　　你来试试看吧！

Input

输入第一行为T，表示有T组测试数据。每组数据包含两个整数Type和K，表示小明给出的条件。Type为0表示“有K个ai使bi等于0”，为1表示“有K个ai使bi不等于0”。 [b][Technical Specification][/b] 1. 1 <= T <= 477 2. 1 <= K <= 47777, Type = 0 | 1

Output

对每组数据，先输出为第几组数据，如果没有这样的数，输出“Illegal”，否则输出满足条件的最小的X，如果答案大于2^62, 则输出“INF”。

Sample Input

Sample Output

  
  
   
   Case 1: 4
Case 2: 5
Case 3: 48

//题意：有2种情况：

1.告诉你x有多少个因数，然后让你求这个最小的x

2.告诉你在[1,x]中有几个数不能被x整除，求最小的x

//思路：

情况1（type=0）：首先要清楚几个简单的概念：1)一个数必然等于几个质数的乘积 x=(p1^a1)*(p2^a2)*...(pn^an)

2)x的因子个数为(1+a1)*(1+a2)*...(1+an)

所以，我们可以先求出1-100000里所有的素数，然后用dfs，求出有n个因子的最小数，n属于1-47777

情况2（type=1）：根据题目意思，这种情况下k表示在[1,x]中有k个数不能被x整除，若x有n个因子（即有n个数能被x整除），那么x==k+n 且一个数最少有2个因子（1和它本身），所以，我们可以让k从2开始，若k==（k+n）的因子数，那么k+n即为最小的x

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;

const int MAXN = 100000;

//求1-100000的所有素数
//prime[]中下标为素数的(假设为i)存放第i个素数的值
//下标不为素数的话，prime[]值为1
//自己找几个例子带进去手动试一下就清楚了
int prime[MAXN + 1];
void getprime()
{
	memset(prime, 0, sizeof(prime));
	for (int i = 2; i <= MAXN; i++)
	{
		//prime[0]是当前质数的个数
		if (!prime[i])
			prime[++prime[0]] = i;
		for (int j = 1; j <= prime[0] && prime[j] <= MAXN / i; j++)
		{
			//一个数的倍数必然是合数，设为1
			prime[prime[j] * i] = 1;
			if (i%prime[j] == 0)
				break;
		}
	}
}

//合数分解
//factor[][0]存放能被x整除的质数
//factor[][1]存放x能整除该质数几次
//例子：8：factor[0][0]=2 , factor[0][1]=3;
//     12：factor[0][0]=2 , factor[0][1]=2;
//         factor[1][0]=3 , factor[1][1]=1;
long long factor[100][2];
int fatcnt;
int getfactors(long long x)
{
	fatcnt = 0;
	long long tmp = x;
	for (int i = 1; prime[i] <= tmp / prime[i]; i++)
	{
		factor[fatcnt][1] = 0;
		if (tmp%prime[i] == 0)
		{
			factor[fatcnt][0] = prime[i];
			while (tmp%prime[i] == 0)
			{
				factor[fatcnt][1]++;
				tmp /= prime[i];
			}
			fatcnt++;
		}
	}
	if (tmp != 1)
	{
		factor[fatcnt][0] = tmp;
		factor[fatcnt++][1] = 1;
	}
	return fatcnt;
}

//用const long long
//用define宏定义的话会超限
const long long INF = (1LL << 62) + 1;
int N;
long long ans;
long long a[47787];
//dfs后a[i]的值表示有i个因数的最小数
void dfs(int i, long long x, int n)
{
	if (n >= 47777)
		return;
	if (x < INF && (a[n] == 0 || a[n] > x))
		a[n] = x;
	for (int j = 1; j <= 62; j++)
	{
		if (INF / prime[i] < x)
			break;
		x *= prime[i];
		if (x >= INF)
			break;
		dfs(i + 1, x, n*(j + 1));
	}
}

//求x的因数个数
int get(int x)
{
	getfactors(x);
	int ans = 1;
	for (int i = 0; i < fatcnt; i++)
	{
		ans *= (factor[i][1] + 1);
	}
	return ans;
}

void init()
{
	memset(a, 0, sizeof(a));
	dfs(1, 1, 1);
}

void solve()
{
	//x表示所求数因数的个数
	int x = 2;
	//x必然<=2*sqrt(x+N)
	while (x*x <= 4 * (N + x))
	{
		//N表示的是不能被整除的个数
		//所以x+N就是所求数
		//所以get(x+N)是所求数因数的个数
		//因此，若get(x+N)==x，x+N就是我们要求的数！
		if (x == get(N + x))
		{
			printf("%d\n", N + x);
			return;
		}
		x++;
	}
	printf("Illegal\n");
}

int main()
{
	int	T;
	getprime();
	int cas = 1;
	scanf("%d", &T);
	int type;
	init();
	while (T--)
	{
		scanf("%d%d", &type, &N);
		printf("Case %d: ", cas++);
		if (type == 0)
		{
			if (a[N] != 0)
				printf("%I64d\n", a[N]);
			else
				printf("INF\n");
		}
		else
			solve();
	}
	return 0;
}