タイトル説明

　　レレは巧妙かつ勤勉子です。彼は物事の法則を探求するのが好き。生成された関心の数のある日、彼は突然、正の整数べき乗。

　　我々はすべて知っているように、$ 2 $

　　そして、レレの質問が出てきた：それは最後のものは、このサイクルにそれを持っているだけではなく？整数$ N $のため

　　注意：

　　1。もし$ N $は

　　2。サイクルの長さはL $ $であれば

入力形式

　　ラインであって、$ 2 $ $\ leqslant N <10 ^ {100} $ および$ 1 \ leqslant K \ leqslant 100 $ 、$ N- $ と$ K $がスペースで区切られた間、示すことを要求された$ N- $ N最終的に$ K $整数パワーサイクル長ビット。$

出力フォーマット

　　サイクルの長さを表す整数。ループが存在しない場合、出力$ $ -1

私

サンプル入力

32 2

サンプル出力

問題の解決策

　　L_ {I |最後$ I $ビットの周期長は$ L_ {I} $、そして最終的に$ I + 1 $ビット周期長の$ L_ {I + 1} $、$ L_ {I}であれば容易に理解+ 1} $。

　　私たちは、^ {L_ {i}は}、$ I + 1 $最後のビットのため、その後は、$ A ^ {L_ {I}} $を掛けたびに繰り返す$ I $ $ $乗算する最後のビットを設定し、とき乗算$ $ CNTを2回繰り返したとき、$ L_ {I + 1} = L_ {I} \回CNT $。

　　同じ最後の$ A ^は、$ Iのビットを$場合{L_ {I} + 1} $ $の$ I $ $最後のビットが、それはまた、$ $ -1を出力することに留意されたいです。

#include <iostreamの> 
する#include <cstdioを> 
する#include <CStringの> の#define MAX_LEN（100 + 5）を使用して名前空間STD。int型のk; 構造体なBigNumber 
{ int型のビット[MAX_LEN + MAX_LEN]、LEN。
    なBigNumber（）
    { 
        memsetの（ビット、0、はsizeof ビット）。
        LEN = 1 。
        返します。
    } 
    なBigNumber 演算子 =（チャー *のS）
    { 
        memsetの（ビット、0



 




    
    
    、はsizeof ビット）。
        LEN = strlenを（S + 1 ）。
        ため（登録をint i = 1 ; iがLEN = <++ I）
        { 
            ビット[I] = sの[ - I + LENを1 ] - ' 0 ' 。
        } 
        を返す * これを。
    } 
    
    なBigNumberの演算子 =（INT NUM）
    { 
        memsetの（ビット、0、はsizeof ビット）。
        LEN = 0 ;
        実行
        { 
            ビット[ ++ LEN = NUM％10 。
            NUM / = 10 。
        } 
        一方（NUM）。
        返す * これを。
    } 
    
    インラインBOOL notZero（）
    { 
        戻り LEN> 1 || ビット[ 1 ]。
    } 
    
    友人なBigNumberのオペレータ + （なBigNumber、なBigNumber b）は
    { 
        場合（a.len <b.len）a.len = b.len。
        以下のために（登録int型 I = 1を; I <= a.len。++ I）
        { 
            a.bit [I] + = b.bit [I]。
        } 
        ため（登録をint i = 1 ; I <= a.len && iは= Kを<; ++ i）が
        { 
            場合（= a.bit [I]> 10 ）
            { 
                場合（I == a.len）++ a.len;
                ++ a.bit [I + 1 ]。
                a.bit [I] - = 10 。
            } 
        } 
        もし（a.len> K）a.bit [a.len--] = 0 ;
        返します。
    }
    
    友人なBigNumber 演算子 + =（＆なBigNumber 、なBigNumber b）は
    { 
        返す = A + B。
    } 
    
    友人なBigNumberの演算子 * （なBigNumber、なBigNumber b）は
    { 
        なBigNumberのC; 
        c.len = a.len + b.len - 1 。
        もし（c.len> K）c.len = K。
        ため（登録をint = I 1 ; iは<= a.len; ++ I）
        { 
            ため（登録INT J = 1 ; jは<= b.len && iがJ + - 1 <= kは、++J）
            { 
                c.bit [iが jで+ - 1 ] + = a.bit [I] * b.bit [J]。
            } 
        } 
        ため（登録をint i = 1 ; I <= c.len && iは= Kを<++ i）が
        { 
            場合（= c.bit [I]> 10 ）
            { 
                場合（I == c.len）+ + c.len; 
                c.bit [I + 1 ] + = c.bit [I] / 10 。
                c.bit [I]％= 10 。
            } 
        } 
        もし（c.len> K）c.bit [c.len--] =0 ;
        リターンC; 
    } 
    
    友人なBigNumber 演算子 * =（なBigNumber＆A、なBigNumber b）は
    { 
        返す = *のBと、
    } 
    
    ボイドライト（）
    { 
        ため（登録をint i = LEN; I; - I）
        { 
            のprintf（" ％dの" 、ビット[I]）。
        } 
        を返します。
    } 
}。

なBigNumber; 
INT [F 15 ]。
なBigNumber DP [MAX_LEN]。

INT メイン（）
{ 
    CHARS [MAX_LEN]。
    scanf関数（" ％sの％は、D "、S + 1、＆K）。=のS; 
    DP [ 0 ] = 1 ; 
    なBigNumber解像度、P、TMP; 
    TMP = A;
    ため（登録をint = I 1 ; iは= K <; ++ I）
    { 
        memsetの（F、0、はsizeof F）。
        P = TMP; 
        TMP = 1 。
        RES = ; 
        F [res.bit [I]]= 1 ;
        一方、（[res.bit [I] <F 2 ）
        { 
            TMP * = ; P 
            RES * = P;
            ++ F [res.bit [I]]。
            DP [I] + = DP [I - 1 ]。
        } 
        もし（res.bit [I] = a.bit [I]！）戻り COUT << - 1、0 。
    } 
    DP [K] .WRITE（）。
    リターン 0 ; 
}

リファレンスプログラム

[説明]サイクル