CodeForces 478E Wavy numbers

题意:

如果一个数它的每一位(除了最高最低位)都大于或小于它两边的数字  则这个数字叫波浪数  输入n和k (10^14)  求%n==0的第k小的波浪数  如果没有或者大于10^14就输出-1

思路:

这也算是一种分治的搜索策略吧  meet-in-mid

由于数字最多14位  因此可以暴力高7位和低7位(均为80+w种)  然后枚举高位和低位去拼

这题对于代码书写要求较高!!  我的方法如下:

暴力高7位

暴力低7为  放进vector  同时记录对于一个number  它的首位  和  首位与第二位大小情况(为了拼接)  同时做一个hash  记录cnt[i][j][k]  其中i为number首位  j为0或1表示首位与第二位大小情况  k为number%n的余数的hash值(为了方便查找)cnt记录ijk情况的number个数

然后开始寻找答案

枚举高7位的number  表示只有不用拼接的情况

判断n是否大于等于10^7  如果是  那么只要i=n开始不断的+n就可以找数字了

如果不是  枚举高7位  再枚举低7位的首位  利用刚才记录的cnt不断的使k减小  直到确定了高7位后  暴力低7位拼答案

注意:hash不能用map  会TLE  在叉姐的提醒下我改成了离散再hash(因为种类不多!!)  现在是CF上跑的最快的代码哈哈哈哈哈哈哈~~~

代码:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<cstdlib>
#include<ctime>
#include<cmath>
using namespace std;
typedef long long LL;
#define N 850000
#define M 10000000

LL n, k;
int tothigh;
int anshigh[N];
vector<int> anslow[10][2];
int id, to[M], cnt[10][2][N];
int dig[10];

void get_high(int bit) {
	int num = 0, i = bit;
	while (i) {
		num = num * 10 + dig[i];
		i--;
	}
	anshigh[tothigh++] = num;
}

void find_high(int bit) {
	for (int i = 0; i <= 9; i++) {
		if (i != dig[bit - 1]) {
			if (bit <= 2
					|| (bit > 2
							&& ((i > dig[bit - 1] && dig[bit - 2] > dig[bit - 1])
									|| (i < dig[bit - 1]
											&& dig[bit - 2] < dig[bit - 1])))) {
				dig[bit] = i;
				if (i)
					get_high(bit);
				if (bit < 7)
					find_high(bit + 1);
			}
		}
	}
}

void get_low() {
	int num = 0, i = 7;
	while (i) {
		num = num * 10 + dig[i];
		i--;
	}
	if (dig[7] < dig[6]) {
		anslow[dig[7]][0].push_back(num);
		if (!to[num % n])
			to[num % n] = ++id;
		cnt[dig[7]][0][to[num % n]]++;
	} else {
		anslow[dig[7]][1].push_back(num);
		if (!to[num % n])
			to[num % n] = ++id;
		cnt[dig[7]][1][to[num % n]]++;
	}
}

void find_low(int bit) {
	for (int i = 0; i <= 9; i++) {
		if (i != dig[bit - 1]) {
			if (bit <= 2
					|| (bit > 2
							&& ((i > dig[bit - 1] && dig[bit - 2] > dig[bit - 1])
									|| (i < dig[bit - 1]
											&& dig[bit - 2] < dig[bit - 1])))) {
				dig[bit] = i;
				if (bit == 7)
					get_low();
				else
					find_low(bit + 1);
			}
		}
	}
}

bool check(LL x) {
	int a = x % 10;
	x /= 10;
	int b = x % 10;
	x /= 10;
	while (x) {
		int c = x % 10;
		x /= 10;
		if ((b > a && b > c) || (b < a && b < c))
			;
		else
			return false;
		a = b;
		b = c;
	}
	return true;
}

int main() {
	scanf("%lld%lld", &n, &k);
	dig[0] = -1;
	find_high(1);
	find_low(1);
	sort(anshigh, anshigh + tothigh);
	for (int i = 0; i < tothigh; i++) {
		if (anshigh[i] % n == 0) {
			k--;
			if (!k) {
				printf("%d\n", anshigh[i]);
				return 0;
			}
		}
	}
	if (n >= M) {
		for (LL i = n; i <= 100000000000000LL; i += n) {
			if (check(i)) {
				k--;
				if (!k) {
					printf("%lld\n", i);
					return 0;
				}
			}
		}
	} else
		for (int i = 0; i < tothigh; i++) {
			int r = to[(n - (LL) anshigh[i] * M % n) % n];
			if (!r)
				continue;
			if (anshigh[i] < 10) {
				for (int j = 0; j <= 9; j++) {
					if (j == anshigh[i])
						continue;
					if (j > anshigh[i]) {
						if (cnt[j][1][r]) {
							if (k > cnt[j][1][r])
								k -= cnt[j][1][r];
							else {
								sort(anslow[j][1].begin(), anslow[j][1].end());
								for (int it = 0; it < anslow[j][1].size();
										it++) {
									if (to[anslow[j][1][it] % n] == r) {
										k--;
										if (!k) {
											printf("%d%07d\n", anshigh[i],
													anslow[j][1][it]);
											return 0;
										}
									}
								}
							}
						}
					} else {
						if (cnt[j][0][r]) {
							if (k > cnt[j][0][r])
								k -= cnt[j][0][r];
							else {
								sort(anslow[j][0].begin(), anslow[j][0].end());
								for (int it = 0; it < anslow[j][0].size();
										it++) {
									if (to[anslow[j][0][it] % n] == r) {
										k--;
										if (!k) {
											printf("%d%07d\n", anshigh[i],
													anslow[j][0][it]);
											return 0;
										}
									}
								}
							}
						}
					}
				}
			} else {
				if (anshigh[i] % 10 > anshigh[i] / 10 % 10) {
					for (int j = 0; j < anshigh[i] % 10; j++) {
						if (cnt[j][0][r]) {
							if (k > cnt[j][0][r])
								k -= cnt[j][0][r];
							else {
								sort(anslow[j][0].begin(), anslow[j][0].end());
								for (int it = 0; it < anslow[j][0].size();
										it++) {
									if (to[anslow[j][0][it] % n] == r) {
										k--;
										if (!k) {
											printf("%d%07d\n", anshigh[i],
													anslow[j][0][it]);
											return 0;
										}
									}
								}
							}
						}
					}
				} else {
					for (int j = anshigh[i] % 10 + 1; j <= 9; j++) {
						if (cnt[j][1][r]) {
							if (k > cnt[j][1][r])
								k -= cnt[j][1][r];
							else {
								sort(anslow[j][1].begin(), anslow[j][1].end());
								for (int it = 0; it < anslow[j][1].size();
										it++) {
									if (to[anslow[j][1][it] % n] == r) {
										k--;
										if (!k) {
											printf("%d%07d\n", anshigh[i],
													anslow[j][1][it]);
											return 0;
										}
									}
								}
							}
						}
					}
				}
			}
		}
	printf("-1\n");
	return 0;
}
时间: 2024-10-26 15:00:27

CodeForces 478E Wavy numbers的相关文章

codeforces 165E - Compatible Numbers 【位运算】

题目:codeforces 165E - Compatible Numbers 题意:给出n个数,然后每个数对应输出一个当前数组中与 Ai 与运算为 0 的数,没有的话输出-1 分析:简单的位运算题目,技巧性题目 首先,我们知道与运算的性质,就是只有同时为 1的时候才是1,那么假如 x&y=0 ,就是至少 x 的为1的为 y 全为0,其他为自由,假设为 1 ,那么 y = x^((1<<22)-1).但是这样并不是全部的,这些位还可能是0,所以我们可以枚举这些位,然后处理. 具体看代码

codeforces 509D Restoring Numbers

codeforces 509D Restoring Numbers 题意: v[i][j]=(a[i]+b[j])%k 现在给出n*m矩阵v[][], 求a[],b[]和k, 任意一种情况都行. 限制: 1 <= n,m <= 100; 0 <= v[i][j] <= 100 思路: 对于数组a[], 无论怎么变, 数组之间的差始终不变, b[]也同理 利用这个求出k 再设a[0]=0,b[0]=0,求出剩下的东西.

CodeForces 55D Beautiful numbers 数位DP+数学

题意大概是,判断一个正整数区间内有多少个整数能被它自身的每一个非零的数字整除. 因为每一个位置上的整数集s = {0,1,2,3,4,5,6,7,8,9} lcm(s) = 2520 现在有一个整数t是由s中一个或者多个数字构成的,记为abcde,显然t = a*10^4+b*10^3+c*10^2+d*10^1+e 要使得t能被a,b,c,d,e整除,必然有t % lcm(a,b,c,d,e) = 0 因为a,b,c,d,e去重之后一定是s的一个子集,所以lcm(s)一定是lcm(a,b,c,

Codeforces 55D. Beautiful numbers(数位DP,离散化)

Codeforces 55D. Beautiful numbers 题意 求[L,R]区间内有多少个数满足:该数能被其每一位数字都整除(如12,24,15等). 思路 一开始以为是数位DP的水题,觉得只需要记录搜到当前位出现了哪些数字作为状态即可,明显是假算法...感觉这是一道数位DP好题.可以这样思考:一个数要想被其各位数字分别都整除,等价于它被那些数字的LCM整除.因此记录当前位,当前数对(1~9的LCM)取模的结果,当前出现的数字的LCM这三个值作为状态才合理,即dp[pos][sum][

CodeForces 151B Phone Numbers

Phone Numbers Time Limit:2000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u Submit Status Practice CodeForces 151B Description Winters are just damn freezing cold in Nvodsk! That's why a group of n friends prefers to take a taxi, orde

codeforces Gym 100338E Numbers

题目:http://codeforces.com/gym/100338/attachments 贪心,每次枚举10的i次幂,除k后取余数r在用k-r补在10的幂上作为候选答案. #include<bits/stdc++.h> using namespace std; typedef unsigned long long ull; const int maxbit = 19; ull base[maxbit], n, k; void preDeal() { base[0] = 1; for(in

CodeForces E. Binary Numbers AND Sum

http://codeforces.com/contest/1066/problem/E You are given two huge binary integer numbers aa and bb of lengths nn and mm respectively. You will repeat the following process: if b>0b>0, then add to the answer the value a & ba & b and divide 

CodeForces 55D Beautiful numbers(数位dp&amp;&amp;离散化)

题目链接:[kuangbin带你飞]专题十五 数位DP A - Beautiful numbers 题意 ps:第一道数位dp,题真好,虽然是参考大牛方法悟过才a,但仍收获不少. 求一个区间内的Beautiful numbers有多少个.Beautiful numbers指:一个数能整除所有组成它的非0数字. 例如15可以被1和5整除,所以15是Beautiful numbers. 思路 Beautiful numbers指:一个数能整除所有组成它的非0数字. 等同于 一个数能整除 所有组成它的

CodeForces 55D Beautiful numbers

Beautiful numbers 题目链接 Description Volodya is an odd boy and his taste is strange as well. It seems to him that a positive integer number is beautiful if and only if it is divisible by each of its nonzero digits. We will not argue with this and just