给定整数值n和k,找到可被n整除的第k小的波浪数r,用C或C++实现

最新推荐文章于 2024-02-23 15:29:29 发布

Tasdily

最新推荐文章于 2024-02-23 15:29:29 发布

阅读量1k

点赞数

分类专栏：算法难题

本文链接：https://blog.csdn.net/weixin_42096901/article/details/101371367

版权

算法难题专栏收录该内容

0 篇文章 0 订阅

订阅专栏

本文介绍了一种算法，用于寻找可被特定整数n整除的第k小的波浪数。波浪数是一种特殊的整数，其数字要么严格大于其相邻数字，要么严格小于其相邻数字。算法通过分治策略，先暴力枚举高低位数字，再利用哈希表快速匹配，最终在限定时间内返回结果。

摘要由CSDN通过智能技术生成

问题描述：

波浪数是一个十进制表示的正整数，对于每一个数字要么严格大于其相邻数字，要么严格小于其相邻数字。例如，数字35270,102,747,20和3是波浪数，而数字123,1000和2212不是波浪数。

任务是给定整数值n和k,找到可被n整除的第k小的波浪数r。

例如，当 n = 123, k = 4时，可被123整除的波浪数从小到大为492,615,738,1845，第4个波浪数为1845.

功能展现：

A、能输入多个测试数据n和k(1<=n,k<=10^14),当n，k同时为0时终止。

B、对于每组输入数据，输出一个整数r,如果r不存在，或者r超过10^14，则输出为-1.

示例：

输入：123 4

输出：1845

输入：100 1

输出：-1

输入：1 100000000000

输出：36375614295759

输入：0 0

（退出）

技术要求：

A、能在指定编译器上编译通过并能成功运行；

B、能够根据输入条件对于每组输入在3秒内得出正确的输出结果。

思路解析：

这也算是一种分治的搜索策略吧 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（因为种类不多！！）

代码示例：

#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;
}