[jzoj]3760.【BJOI2014】Euler

Link

　　https://jzoj.net/senior/#main/show/3760

Description

　　欧拉函数  φ(n)  定义为不超过正整数 n 并且与 n 互素的整数的数目。
　　可以证明 φ(n) =  n ∗ ∏ (1 − 1 / p_i). 其中 p_i(1 <= i <= k)是 n 的全部素因子。
　　已知 y，求最小的自然数 x 使得 φ(x) = y.
　　多组询问。

Solution

30分：

　　可以枚举每一个x，判断所得出来的φ(x)是否等于y。可证x≤7y

60分：

　　可能是某些神奇的算法，或者是给没有int64的人一点分

100分：

　　这里有三种解题思路

　　三种都可以用搜索来做，也可以使用动态规划来做。

　　动态规划公式：F[i,j]表示前i个可能的质因子，分解后得到状态S的最小x’

（1）欧拉函数定义

　　根据欧拉函数的定义，很显然可以得到如下两条性质：

　　①φ(x)=x-1......................当x是素数时

　　②φ(xy)=φ(x)*φ(y)..........对任何情况都是成立的

　　于是，分别得出如下结论：

　　　　根据①：x的质因数可能是y的约数加一，

　　　　根据②：x的质因数可能是y的质因数。

　　可能有点难理解，但的确如此。

（2）分解欧拉函数公式

　　我们可以尝试一下分解每个式子。

　　x=p₁^q1*p₂^q2*...p_n^qk（p数组为x质因子，q数组为每个质因子的个数）

　　显然如下

　　φ(x)=x*(p₁-1/p₁)(p₂-1/p₂).....(p_k-1/p_k)..................................公式

　　φ(x)=p₁^q1*p₂^q2*...p_n^^qn*(p₁-1/p₁)(p₂-1/p₂).....(p_k-1/p_k).......将x带入

　　当q₁=q₂=....=q_k=1时，剩下的，就只有(p₁-1)*(p₂-1)*...(p_k-1)

　　当有某些q数组的元素大于一时，就是上面那些式子，再多乘那些消掉以后多出来的p_x^qx，即(p₁-1)*(p₂-1)*...(p_k-1)*p_x^qx，注意，这里x只是某一个举例子的

　　所以可以发现，x的质因数可能是y的约数加一，x的质因数可能是y的质因数。

（3）分解欧拉函数公式

　　同样是拆分式子，跟（2）差不多的，

　　φ(x)=∏p_i^qi * ∏(1-1/p_i)

　　φ(x)=∏[ p_i^qi (1-1/p_i) ]............合并连乘的

　　φ(x)=∏[ p_i^qi-1 (1-1/p_i)*p_i ]...拆一个pi出来与后面的式子相乘

　　φ(x)=∏[ p_i^qi-1 (p_i-1) .............约分得到的

　　同样可以得到上面的结论（x的质因数可能是y的约数加一，x的质因数可能是y的质因数），递归或者动态规划做就行了

剪枝

　　可以加快排，大小值，记忆化来剪枝。

Code（2）

uses math;
var
        x,min:int64;
        n,t,i,j,k:longint;
        prime,bz:array[..] of int64;
procedure dg(k,x,now:int64);
var
        s,ss:qword;
        i:longint;
begin
        if now>min then
                exit;

        if x= then
        begin
                min:=now;

                exit;
        end;

        if k>prime[] then
                exit;

        s:=;
        for i:= to  do
        begin
                if s>x then
                        break;

                if s>x/prime[k] then
                        break;

                if x mod (s*prime[k])<> then
                        break;

                bz[k]:=i;
                dg(k+,x div (s*prime[k]),now*s*(prime[k]+));
                bz[k]:=-;

                s:=s*(prime[k]+);
        end;

        dg(k+,x,now);
end;
function pd(x:int64):boolean;
var
        i:longint;
begin
        for i:= to trunc(sqrt(x)) do
                if x mod i= then
                        exit(false);

        exit(true);
end;

procedure q(l,r:longint);
var
        t,mid:int64;
        i,j:longint;
begin
        i:=l;
        j:=r;
        mid:=prime[(l+r) shr ];

        while i<j do
        begin
                while prime[i]>mid do inc(i);
                while prime[j]<mid do dec(j);

                if i<=j then
                begin
                        t:=prime[i]; prime[i]:=prime[j]; prime[j]:=t;

                        inc(i); dec(j);
                end;
        end;

        if i<r then q(i,r);
        if l<j then q(l,j);
end;
begin
        readln(n);
        for j:= to n do
        begin
                readln(x);

                fillchar(prime,sizeof(prime),);
                for i:= to trunc(sqrt(x)) do
                        if x mod i= then
                        begin
                                if pd(i+) then
                                begin
                                        inc(prime[]);

                                        prime[prime[]]:=i;
                                end;

                                if x div i<>i then
                                begin
                                        if pd(x div i+) then
                                        begin
                                                inc(prime[]);

                                                prime[prime[]]:=x div i;
                                        end;
                                end;
                        end;

                q(,prime[]);

                fillchar(bz,sizeof(bz),);

                min:=;
                dg(,x,);
                writeln(min);
        end;
end.

uses math;
const maxn=;
var
        pr,flag:array[..] of int64;
        z,have:array[..] of int64;
        bz:array[..] of boolean;
        n,nn,tot,ans:int64;
        i,j,p:longint;
procedure dfs(k,sum,max:int64; flag2:boolean);
begin
        if max*sum>=ans then exit;
        if sum= then
        begin
                ans:=min(ans,max);
                exit;
        end;
        if k>have[]+pr[] then exit;

        if k<=have[] then
        begin
                if (have[k]<=) or (sum mod have[k]<>) then dfs(k+,sum,max,flag2) else
                begin
                        dfs(k+,sum div have[k],max*(have[k]+),true);
                        dfs(k+,sum,max,flag2);
                end;
        end
        else
        begin
                if flag2 then exit;

                inc(flag[have[k]]);
                if flag[have[k]]= then begin if sum mod (have[k]-)= then dfs(k+,sum div (have[k]-),max*have[k],flag2); end
                        else
                if sum mod have[k]= then dfs(k+,sum div have[k],max*have[k],flag2);
                dec(flag[have[k]]);

                dfs(k+,sum,max,flag2);
        end;
end;
function pd(x:int64):boolean;
begin
        for j:= to z[] do
        begin
                if sqr(z[j])>x then exit(true);
                if x mod z[j]= then exit(false);
        end;
end;
begin
        for i:= to maxn do
        begin
                if not bz[i] then
                begin
                        inc(z[]);
                        z[z[]]:=i;
                end;
                for j:= to z[] do
                begin
                        if z[j]*i>maxn then break;
                        bz[z[j]*i]:=true;
                        if i mod z[j]= then break;
                end;
        end;

        readln(tot);
        for p:= to tot do
        begin
                have[]:=;
                pr[]:=;
                readln(n);
                for i:=trunc(sqrt(n)) downto  do
                        if n mod i= then
                        begin
                                if pd(i+) then begin inc(have[]); have[have[]]:=i; end;
                                if i=n div i then continue;
                                if pd(n div i+) then begin inc(have[]); have[have[]]:=n div i; end;
                        end;
                nn:=n;
                for i:= to z[] do
                begin
                        if sqr(z[i])>nn then break;
                        if nn mod z[i]= then begin inc(pr[]); have[pr[]+have[]]:=z[i]; end;
                        while nn mod z[i]= do
                        begin
                                inc(pr[]);
                                have[pr[]+have[]]:=z[i];
                                nn:=nn div z[i];
                        end;
                end;

                ans:=maxlongint*maxlongint;
                dfs(,n,,false);
                writeln(ans);
        end;
end.