题目：

0~9共十个数字，组成两个五位数，求最小差的组成。

 

思路：

从第一位，即万位思考，肯定是越接近越好，但是这里不要填1和2，因为第一位越接近越好，最近是差1，那么第一位是1，2还是2，3还是3，4都可以，因此先看后面。后四位的差要最接近，假设第一个数字大，第二个小，则要使第一个数字后四位最小，第二个数字后四位最大。因此定下后四位分别是0123和9876，剩下4和5，一大二小，因此为50123和49876，差值最小为247。要点在于不要被第一位早早困住，应当考虑全局。

编撰：茂喵喵
审核：猫头鹰
1、两位数乘两位数的积：可能是三位数，也可能是四位数。比如，最小的两位数乘最小的两位数，即10×10=100，是一个三位数；最大的两位数乘最大的两位数，即99×99=9801，是一个四位数，而所有的两位数乘两位数的积都在100—9801之间，因此，它们相乘的积就有可能是三位数和四位数；
2、口算：两位数乘两位整十数，先将两位数与两位整十数的十位数字相乘，再在结果后面添上1个0即可，如：24×30，先算24×3=72，然后在72后面添上1个0，即24×30=720。两位整十数乘两位整十数，先将两位整十数的十位数字相乘，然后再在结果后面添上2个0，如：50×30，先算5×3=15，然后再在15后面添上2个0，即1500，因此50×30=1500。
3、竖式计算：用竖式计算两位数乘两位数时，相同数位上下对齐，先从低位算起，即先用下方的数字的个位分别与上方的数字的个位与十位数字相乘，然后分别把相乘的结果写在对应的数位的下面，如果在相乘中有大于十的数字，要向上进位，并且将要进位的数字写在上一位的右下角，再计算上一位时，所乘的结果加上进位的数字，写在对应数位上；然后用下方的数字的十位数字分别与上方数字的个位与十位数字分别相乘，然后把结果分别写在对应的数位上，也就是把下方数字的十位与上方数字的个位相乘的结果的个位数字写在十位上，把下方数字十位上的数字与上方数字的十位上的数字相乘的结果写在百位上，最后两次相乘的结果上下对应数位相加，记得进位数字，所得结果即为最终结果。
4、估算问题：通常生活中，有一些问题并不需要精确的结果，只需要一个大概的数字作为参考，此时就要用到估算。两位数乘两位数的估算中，我们需要做的就是将两位数分别估算为最接近他们的整十数，然后相乘。如：估算36×42，我们就可以分别把36与42估计为40与40，因此36×42≈40×40=1600.
5、乘法运算公式：因数×因数=积，验算方法，使用除法，即用积除以其中一个因数，结果要是另一个因数，答案就是正确的，否则不对。
6、乘法计算规律：一个乘数扩大某一倍数，另一个乘数不变时，所得的结果也扩大相同的倍数；如果两个乘数分别扩大某一倍数，所得的结果就扩大为两个倍数的乘积倍。即：56×23，分别将56扩大2倍，23扩大3倍，所得的结果就扩大2×3=6倍。
7、问够不够或者能不能的题目，一般需要三个步骤：计算，比较，答题。

2482 小b学进制

2 秒
	
 
	
262,144 KB
	
 
	
20 分
	
 
	
3 级题
小b最近在学习进制转化。

对于一个10进制整数n和一个数k，她能快速求出k进制下的n。

如果k进制下的n所有数位都是1，即形如11111111，那么小b就会觉得开心。

现在给定n，请你求出最小的k使得k进制下的n能让小b开心。

 收起

输入

输入一个十进制整数，表示n（没有前导0），其中3≤n≤10^18

输出

输出一个整数，表示最小的k

输入样例

4681

输出样例

8

题解：1> 暴力到1e6次，存在输出，不存在输出 n-1

           2> n 可达到1e18次，最多是 2 的 64次，1的个数最多为64个，然后就是正常的二分了。

                注：要用long double ，unsigned long long 也不行，存不了一些中间变化值，影响二分的方向。

方法一：

#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<bitset>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#define eps (1e-8)
#define MAX 0x3f3f3f3f
#define u_max 1844674407370955161
#define l_max 9223372036854775807
#define i_max 2147483647
#define re register
#define pushup() tree[rt]=max(tree[rt<<1],tree[rt<<1|1])
#define nth(k,n) nth_element(a,a+k,a+n);  // 将 第K大的放在k位
#define ko() for(int i=2;i<=n;i++) s=(s+k)%i // 约瑟夫
#define ok() v.erase(unique(v.begin(),v.end()),v.end()) // 排序,离散化
using namespace std;

inline int read(){
    char c = getchar(); int x = 0, f = 1;
    while(c < '0' || c > '9') {if(c == '-') f = -1; c = getchar();}
    while(c >= '0' & c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}

typedef long long ll;
const double pi = atan(1.)*4.;
const int M=1e3+5;
const int N=5e6+5;
int main(){
    ll n;
    scanf("%lld",&n);
    int leap=0;
    for(int i=2;i<=N;i++){
        ll m=n; int flag=0;
        while(m){
            if(m%i==1){
                m/=i;
            }
            else{
                flag=1;
                break;
            }
        }
        if(!flag){
            printf("%d\n",i);
            leap=1;
            break;
        }
    }
    if(!leap){
        printf("%lld\n",n-1);
    }
    return 0;
}


方法二：

​
#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<bitset>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#define eps (1e-8)
#define MAX 0x3f3f3f3f
#define u_max 1844674407370955161
#define l_max 9223372036854775807
#define i_max 2147483647
#define re register
#define pushup() tree[rt]=max(tree[rt<<1],tree[rt<<1|1])
#define nth(k,n) nth_element(a,a+k,a+n);  // 将 第K大的放在k位
#define ko() for(int i=2;i<=n;i++) s=(s+k)%i // 约瑟夫
#define ok() v.erase(unique(v.begin(),v.end()),v.end()) // 排序,离散化
using namespace std;

inline int read(){
    char c = getchar(); int x = 0, f = 1;
    while(c < '0' || c > '9') {if(c == '-') f = -1; c = getchar();}
    while(c >= '0' & c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}

typedef long double ll;          // 用 unsigned long long 不行
const double pi = atan(1.)*4.;   // long double 比 unsigned long long 大
const int M=1e3+5;
const int N=5e6+5;

ll fun(long long mid,int len){     // 构造
    ll ans=0,cut=1;
    for(int i=0;i<len;i++){
        ans+=cut;
        cut*=mid;
    }
    return ans;
}
int main(){
    long long n;
    scanf("%lld",&n);
    long long cut=n;
    for(int i=1;i<=64;i++){
        long long l=2,r=n-1;
        while(r>=l){
           // printf("l == %lld  r == %lld\n",l,r);
            long long mid=l+r>>1;
            ll d=fun(mid,i);
            if(d==n){
                cut=min(cut,mid);
                break;
            }
            else if(d>n) r=mid-1;
            else l=mid+1;
        }
    }
    printf("%lld\n",cut);
    return 0;
}

​

 

编撰：茂喵喵
审核：猫头鹰
1、两位数乘两位数的积：可能是三位数，也可能是四位数。比如，最小的两位数乘最小的两位数，即10×10=100，是一个三位数；最大的两位数乘最大的两位数，即99×99=9801，是一个四位数，而所有的两位数乘两位数的积都在100—9801之间，因此，它们相乘的积就有可能是三位数和四位数；
2、口算：两位数乘两位整十数，先将两位数与两位整十数的十位数字相乘，再在结果后面添上1个0即可，如：24×30，先算24×3=72，然后在72后面添上1个0，即24×30=720。两位整十数乘两位整十数，先将两位整十数的十位数字相乘，然后再在结果后面添上2个0，如：50×30，先算5×3=15，然后再在15后面添上2个0，即1500，因此50×30=1500。
3、竖式计算：用竖式计算两位数乘两位数时，相同数位上下对齐，先从低位算起，即先用下方的数字的个位分别与上方的数字的个位与十位数字相乘，然后分别把相乘的结果写在对应的数位的下面，如果在相乘中有大于十的数字，要向上进位，并且将要进位的数字写在上一位的右下角，再计算上一位时，所乘的结果加上进位的数字，写在对应数位上；然后用下方的数字的十位数字分别与上方数字的个位与十位数字分别相乘，然后把结果分别写在对应的数位上，也就是把下方数字的十位与上方数字的个位相乘的结果的个位数字写在十位上，把下方数字十位上的数字与上方数字的十位上的数字相乘的结果写在百位上，最后两次相乘的结果上下对应数位相加，记得进位数字，所得结果即为最终结果。
4、估算问题：通常生活中，有一些问题并不需要精确的结果，只需要一个大概的数字作为参考，此时就要用到估算。两位数乘两位数的估算中，我们需要做的就是将两位数分别估算为最接近他们的整十数，然后相乘。如：估算36×42，我们就可以分别把36与42估计为40与40，因此36×42≈40×40=1600.
5、乘法运算公式：因数×因数=积，验算方法，使用除法，即用积除以其中一个因数，结果要是另一个因数，答案就是正确的，否则不对。
6、乘法计算规律：一个乘数扩大某一倍数，另一个乘数不变时，所得的结果也扩大相同的倍数；如果两个乘数分别扩大某一倍数，所得的结果就扩大为两个倍数的乘积倍。即：56×23，分别将56扩大2倍，23扩大3倍，所得的结果就扩大2×3=6倍。
7、问够不够或者能不能的题目，一般需要三个步骤：计算，比较，答题。