codeforces#231_div2_B Very Beautiful Number 高精度枚举

题目地址：cf/394/B

题目大意：给定p ，x   求U一个p位数 ，使得把最后一位移到最前面以后，这个数恰好变为原来的x倍。

先想了一种解决方案，列一个不定方程。  设最后一位为b 这个数是a  那么就有方程  (a-b)/10+b*10^p=x*a;     这样只需要枚举最后一位就可以了~

解出来a后再返回去带进去是不是对的~~ （因为有可能不整除近似计算了）  

用JAVA写的   在第18个案例上tle了 

import java.io.*;
import java.util.*;
import java.math.*;


public class Main {
    
    public static boolean  checkbit(BigInteger n,int p)
    {
     BigInteger check_l=BigInteger.valueOf(10);
     check_l=check_l.pow(p-1);
     check_l=check_l.subtract(BigInteger.valueOf(1));
     
     
     BigInteger check_r=BigInteger.valueOf(10);
     check_r=check_r.pow(p);
     
    if(n.compareTo(check_r)==-1&&n.compareTo(check_l)==1)
    return true;
    
    else 
        return false;
    }
    public static void main(String[] args) {
         
          Scanner cin=new Scanner(System.in);
            int p=cin.nextInt();
            int xx=cin.nextInt();
            int flag=0;
    
            for(int i=1;i<10;i++)
            {
                BigInteger b=BigInteger.valueOf(i);
               
                BigInteger ans=BigInteger.valueOf(10);
                ans=ans.pow(p);
   
               
                
                ans=ans.subtract(BigInteger.valueOf(1));   // ans=10^p-1
                
              
                
               int  x=10*xx-1;       
               
               
                BigInteger left=ans;    //left=10^p-1;
                
                
                BigInteger check_r=ans.divide(BigInteger.valueOf(10));
                
                ans=ans.multiply(b);    //ans=(10^p-1)*b;
                
               
           
                ans=ans.divide(BigInteger.valueOf(x));
           
                
                 // check
                BigInteger right=ans;
                
                right=right.multiply(BigInteger.valueOf(x));
                
              
                
                left=left.multiply(ans.mod(BigInteger.valueOf(10)));
                
                
                
                if(left.compareTo(right)==0&&checkbit(ans,p))
                {
                    
                    flag=1;
                    System.out.println(ans);
                    break;

                }
                
              
            }
            
            if(flag==0) 
            {
                System.out.println("Impossible");
                
            }
            
            
    }

}

然后是c++写了一种方法，其实给出最后一位，就可以求出倒数第二位，再就可以求出倒数第三位，这样推到最高位，如果最高位算出来倍数的刚好对应着最后一位，那就对了

代码：

#include<iostream>

using namespace std;

int ans[1000005];


int main()

{
    
    int p,x;
    cin>>p>>x;
    
    int flag=0;
    for(int last=1;last<10;last++)
    {
        
        ans[0]=last;
        int forward=0;
        
        for(int i=1;i<p;i++)
        {
             ans[i]=(ans[i-1]*x+forward)%10;
             forward=(ans[i-1]*x+forward)/10;
        }
        
       
        
        if(ans[p-1]*x+forward==last&&ans[p-1]!=0)
        {
            flag=1;
            
            for(int i=p-1;i>=0;i--)
                cout<<ans[i];
            cout<<endl;
          
            break;
        }
        
        
    }
    
    if(flag==0)
    {
        
        cout<<"Impossible"<<endl;
    }
    
}

要注意的是

ans[p-1]*x+forward==last&&ans[p-1]!=0    而不是把上面的循环条件改成<=p 直接比较a[p]==last? （比如2 7 这个案例 就会出现79 这个错误输出）  还有就是不可以有前导零

转载于:https://www.cnblogs.com/jingqi814/p/3581538.html