1010 Radix 测试点坑点及注意问题详解 附顺序查找和二分查找两种解法

目录

题目

测试样例

输入样例1（题目自带）

输出样例1

输入样例2（题目自带）

输出样例2

输入样例3（自编，特殊情况——N1、N2均为0）

输出样例3

输入样例4（自编，普通情况）

输出样例4

输入样例5（自编，普通情况）

输出样例5

测试点坑点及注意问题总结

顺序查找法提交结果截图

二分法提交结果截图

两种种解法解题思路及源代码

1.普通解法——顺序查找（24分，测试点7通过不了）

2.高效解法——二分查找（已经AC）

---

题目

题目链接：1010 Radix （PAT (Advanced Level) Practice）

测试样例

输入样例1（题目自带）

6 110 1 10

输出样例1

2

输入样例2（题目自带）

1 ab 1 2

输出样例2

Impossible

输入样例3（自编，特殊情况——N1、N2均为0）

0 0 1 4

输出样例3

2

输入样例4（自编，普通情况）

15 1111 1 10

输出样例4

2

输入样例5（自编，普通情况）

120000 3b 1 10 

输出样例5

Impossible

测试点坑点及注意问题总结

1.int型最多存储10位的数字，而题目中的数据如果转化为十进制，很可能超过10位，所以要用long long 来存储。

2.要确定搜索的下界——因为数的进制肯定是比该数的任意一位要大的。

3.要确定搜索的上界：

（1）如果是顺序查找，则上界定为1000就够了，因为定太大也没用，会超时。

（2）如果是二分查找，则上界应该取已知的数的十进制值与下界二者中的最大值+1。

        原因是：

        a. 假设已知的数十进制值为999，而待求进制的数为1，则待求的进制为999，而如果待求进制的数大于1，则待求进制肯定小于999，故上界至少应该定为已知的数的十进制值。

        b. 假设已知数的十进制值为1或0，则上界就会小于下界，这种情况应该避免。

        c. +1是因为mid =  (right + left)/2 = (right - left)/2 + left，可能会有四舍五入，故+1。（其实不加1问题也不大）。

4.要注意所求的进制值可能会大于35，如果没注意到这点，得分会很低。

5.很不容易发现的一个坑点：就算你用了long long来存储十进制值，仍可能会溢出。所以要判断溢出情况（计算得到的十进制值小于0时）。

6.只采用顺序查找法，测试点7是过不了的，会超时（截图中的答案错误是因为我没有把上界调大，如果上界调得很大，就是提示超时了）

顺序查找法提交结果截图

二分法提交结果截图

两种种解法解题思路及源代码

1.普通解法——顺序查找（24分，测试点7通过不了）

/***************************************************************************
* 解题思路：
* 1.样例分析：
* (1)样例1：
* Input:   6 110 1 10
* Output:  2
* 说明6是10进制，而当110是2进制时，才满足6 = 110
* (2)样例2：
* Input:   1 ab 1 2
* Output:  Impossible
* 说明1是2进制，而不论ab是几进制，都不能满足1 = ab
* 2.根据样例，可以得知，所求的进制肯定是比该数的最大一位要大的，比如，
* “45564”至少是7进制，“1a3”至少是11进制。
* 3.计算方法：
* 例：（110）2进制 = （1*2 + 1）*2 + 0 = （6）10进制
* ->若将输入的两个数存入char Num[2][11]中,
* 两个数的值用Num[2]保存,长度为len[2]
* 假设待求数为Num[1]，已知数为Num[0],其长度为len[0]
* 则先求Num[0]的值:
* Num[0] = (...(Num[0][0]*radix + Num[0][1])*radix...) + Num[0][len[0]-1]
* 同理根据遍历的猜测的结果进制求得Num[1]
* 比较Num[0]和Num[1]
* 若是相等，则结束
* 若是Num[0] < Num[1],则没必要继续遍历搜索，直接结束。
* 若是Num[0] > Num[1],则还有相等的可能。
***************************************************************************/

#include <string.h>
#include <iostream>
using namespace std;
#define con_tag (tag == 1? 2:1)

int tag;//1或2
int radix;
char Num[3][11];
int len[3];
long long value[3];
int MaxDigit = -1;

//字符转换成数字
int get_true_num(char str)
{
	if('0' <= str && str<= '9')
		return str - 48;
	else if('a' <= str && str <= 'z')
		return (str - 'a' + 10);
	else 
		cout<<"输入异常！"<<endl;
	return -1;
}

int main()
{
	cin>>Num[1]>>Num[2]>>tag>>radix;
	for(int i = 1; i < 3; i++)
		len[i] = strlen(Num[i]);
	value[tag] = get_true_num(Num[tag][0]);
	for(int i = 1; i < len[tag]; i++)
		value[tag] = value[tag]*radix + get_true_num(Num[tag][i]);
	for(int i = 0; i < len[con_tag]; i++)
		if(MaxDigit < get_true_num(Num[con_tag][i]))
			MaxDigit = get_true_num(Num[con_tag][i]);
	for(long long i = MaxDigit + 1; i < 1000; i++)
	{
		value[con_tag] = get_true_num(Num[con_tag][0]);
		for(int j = 1; j < len[con_tag]; j++)
			value[con_tag] = value[con_tag]*i + get_true_num(Num[con_tag][j]);
		if(value[tag] == value[con_tag])
		{
			cout<<i;
			return 0;
		}
		else if(value[tag] < value[con_tag])
		{
			cout<<"Impossible";
			return 0;
		}
	}
	cout<<"Impossible";
	return 0;
}

/*
120000 3b 1 10 
6 110 1 10
*/

2.高效解法——二分查找（已经AC）

思路其实比较简单，就是改成了二分查找，没看懂可以留言问我。

#include <string.h>
#include <algorithm>
#include <iostream>
using namespace std;
#define con_tag (tag == 1? 2:1)
typedef long long int ll;

int tag;//1或2
int radix;
char Num[3][11];//Num[0]不用
int len[3];//len[0]不用
ll value[3];//value[0]不用
int MaxDigit = -1;
ll res = 0;

//字符转换成数字
int get_true_num(char str)
{
	if('0' <= str && str<= '9')
		return str - 48;
	else if('a' <= str && str <= 'z')
		return (str - 'a' + 10);
}

//计算十进制值
ll get_value(int cur_tag, int length, ll radix)
{
	ll sum = 0;
	for(int i = 0; i < length;  i++)
	{
		sum *= radix;
		sum += get_true_num(Num[cur_tag][i]);
		if(sum < 0)
			return -1;
	}
	return sum;
}

ll solve()
{
    if(MaxDigit == 0)
        MaxDigit++;
	ll left = MaxDigit+1, right = max(left, value[tag])+1, mid;
	while(left <= right)
	{
        mid = (right-left)/2+left;
		value[con_tag] = get_value(con_tag, len[con_tag], mid);
		if(value[tag] == value[con_tag])
        {
            res = mid;
            break;
        }
		else if((value[tag] < value[con_tag]) || (value[con_tag] == -1))
            //value[con_tag] = -1是超过了long long 表示的范围了
			right = mid - 1;
		else
			left = mid + 1;
	}
    return res;
}

int main()
{
	cin>>Num[1]>>Num[2]>>tag>>radix;
	for(int i = 1; i < 3; i++)
		len[i] = strlen(Num[i]);
	value[tag] = get_value(tag, len[tag], radix);
	for(int i = 0; i < len[con_tag]; i++)
		if(MaxDigit < get_true_num(Num[con_tag][i]))
			MaxDigit = get_true_num(Num[con_tag][i]);
	if(!solve())
		cout<<"Impossible";
	else
		cout<<res;
	return 0;
}