The Preliminary Contest for ICPC Asia Nanjing 2019ICPC南京网络赛

B.super_log （欧拉降幂）

•题意

定一个一个运算log*,迭代表达式为

给定一个a,b计算直到迭代结果>=b时，最小的x,输出对m取余后的值

•思路

$log*_{a}(1)=1+log*_{a}(0)=1-1=0$ 　　　　　　　 　

$log*_{a}(a)=1+log*_{a}(log_{a}(a))=1+log*_{a}(1)=1$

$log*_{a}(a^{a})=1+log*_{a}(a)=2$　　　　　　　　　    　　  　　　　　　

....

以此类推得$log*_{a}(a^{a^{a^{a^{a^{...}}}}})=b$    (共b个a)

接下来接转化为$a^{a^{a^{a^{a^{...}}}}}$  (共b个a)  对m取模得结果

ps.如果对欧拉降幂不熟悉的话可以先看一下这个题(戳我~)

利用欧拉降幂

$a^{b}=\begin{cases}a^{b\%\varphi(p)}  \ \ \ \ \ \ \ \ \ \  gcd(a,p)=1 \\ a^{b} \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \   gcd(a,p)\neq 1,b \leqslant \varphi(p)\\a^{b\%\varphi(p)+\varphi(p)}  \ \ gcd(a,p)\neq1,b\geqslant \varphi(p)  \\ \end{cases}$

递归求解，至多走到2log层模数就会变成1，返回答案就行了。

但是在求$a^{a}\%\varphi(p)$时怎么计算$a$和$\varphi(p)$的大小呢

利用取模方法！

在取模时，如果大于$\varphi(p)$就取模 x=x%mod，否则不取模x=x，就可以当作a和p的互素处理

具体证明请看这里

•代码

 #include<bits/stdc++.h>
 using namespace std;
 #define ll long long
 ll qpow(ll a,ll b,ll mod)//快速幂
 {
     ll res=;
     while(b)
     {
         if(b&)
             res=res*a>mod?res*a%mod+mod:res*a;
         a=a*a>mod?a*a%mod+mod:a*a;
         b>>=;
     }
     return res;
 }

 ll phi(ll x)//求x的欧拉函数值
 {
     ll res=x;
     for(int i=;i*i<=x;i++)
     {
         if(x%i==)
         {
             while(x%i==)
                 x/=i;
             res=res-res/i;
         }
     }
     if(x>)
         res=res-res/x;
     return res;
 }

 ll solve(ll a,ll b,ll m)
 {
     if(m == )
         return ;
     if(b==||a==)
         return 1ll;

     ll p=phi(m);
     return qpow(a,solve(a,b-,p),m);
 }

 int main()
 {
     int t;
     cin>>t;
     while(t--)
     {
         ll a,b,m;
         cin>>a>>b>>m;
         cout<<solve(a,b,m)%m<<endl;
     }
 }

H. Holy Grail（最短路floyd）

•题意

给一个加权有向图，然后让你给你六个顶点，添六条边，

但是添边是有限制的。每次添边的权值要最小，并且不能构成负环，

•思路

可以先根据已知边跑floyd,获得此时两点u->v的最短路，然后v->u的权值等于u->v的最短路取反

然后再根据此时已知边继续跑floyd，再加边

进行6次floyd，加6条边

dij不能处理负权pass!

(在比赛时一直在想加上u->v这条边也不能构成环的情况然后就不知道该怎么做了...

然而看出题人题解貌似没有这个意思....？？题意描述不清喵喵喵？)

•代码

 #include<bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define inf 0x3f3f3f3f3f3f3f3f
 int n,m;
 ll d[][];

 void Init()
 {
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
             d[i][j]=inf;
 }

 void floyd()
 {
     for(int k=;k<=n;k++)
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++)
                 d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
 }
 int main()
 {
 //    freopen("C:\\Users\\14685\\Desktop\\C++workspace\\in&out\\contest","r",stdin);
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d",&n,&m);
         Init();
         int u,v;
         ll k;
         for(int i=;i<=m;++i)
         {
             scanf("%d%d%lld",&u,&v,&k);
             d[u+][v+]=k;
         }
         for(int i=;i<=;++i)
         {
             floyd();
             scanf("%d%d",&u,&v);
             printf("%lld\n",-1ll*d[v+][u+]);
             d[u+][v+]=-1ll*d[v+][u+];
         }
     }
 }

F.Greedy Sequence（思维+滑动窗口）

•题意

　　给你一个包含 n 个数的序列 a，其中 a 中存的数为 1~n 的排列；

　　定义一个二维数组 s；

　　s 中一共有 n 行，每行有 n 个数；

　　定义 s 数组：

　　　　① $s_{i}[1]=i$

　　　　②$\forall\  i \in[1,n],j \in [2,n],s_{i,j} \le s_{i,j-1}$，即 $s_i$是个非增序列；

　　　　③对于 $s_i$ 中的第 j( j > 1 ) 个数，$s_{i,j}$ 在 a 中的位置与 $s_{i,j-1}$ 在 a 中的位置之差的绝对值不能超过 k；

　　　　④ $s_i$ 中的第 j( j > 1) 个数，要尽可能的大；

　　　　⑤如果 $s_{i,j}$ 后，在 a 中找不到满足条件 ②③ 的数，并且 $s_i$ 不足 n 个数，用 0 填充剩余的数；

　　输出 |s₁|,|s₂|,...,|s_n|，|s_i|表示 s 中第 i 行包含的数的个数；

•思路

在set为空时插入0,是为了upper_bound()容易找，

利用upper_bound()需要-1，如果upper_bound()=begin()的话需要判断

插入0后就不需要判断了，方便操作

•代码

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=1e5+;
 int a[maxn];
 int R[maxn],L[maxn];
 int s[maxn];
 set<int> f;
 int n,k;

 void Solve()
 {
     f.clear();
     f.insert();
     int index=;///index代表下标
     for(;index<=min(k+,n);index++)
         f.insert(a[index]);

     for(int i=;i<=n;i++)
     {
         auto it=f.upper_bound(a[i]);
         it--;
         R[a[i]]=*it;
         f.erase(f.find(a[i+]));
         if(index<=n)
             f.insert(a[index++]);
     }
     f.clear();
     f.insert();
     index=n-;
     for(;index>=max(,n-k);index--)
         f.insert(a[index]);

     for(int i=n;i>=;i--)
     {
         auto it=f.upper_bound(a[i]);
         it--;
         L[a[i]]=*it;
         f.erase(f.find(a[i-]));
         if(index>=)
             f.insert(a[index--]);
     }
 //    for(int i=1;i<=n;i++)
 //        printf("%d R:%d L:%d\n",a[i],R[a[i]],L[a[i]]);

     s[]==;
     for(int i=;i<=n;i++)
     {
         s[i]=s[max(R[i],L[i])]+;
         printf("%d%c",s[i],i==n?'\n':' ');
     }

 }
 int main()
 {
     int t;
     cin>>t;
     while(t--)
     {
         cin>>n>>k;
         for(int i=;i<=n;i++)
             cin>>a[i];
         Solve();
     }
 }

I.Washing clothes（贪心）

•题意

有n个人分别在$t_{i}$时刻进入洗衣房要洗衣服，可以机洗可以手洗,

但是只有一台洗衣机，每次机洗花费的时间是$x$，同时也可以手洗花费时间是$m$，

可以多人同时手洗，而不能同时机洗

求当$x\epsilon [1,y]$,所有人所要花费的最少时间。

•思路

如何判断从哪个人开始使用洗衣机呢？

我们可以使手洗时间尽可能的与机洗时间相同，找到这个点，即为最小值

为什么这个点是最小值呢？

因为$f(i)$是单调递增函数，$g(i)$是单调递减函数

设两者相等时机洗$cnt$个,手洗$n-cnt$个

①现在让手洗多一个，机洗少一个，

　　因为$f(i)$单调递增，$f(n-cnt+1)>f(n-cnt)$,所以$max(f(i),g(i))$增大，花费时间增加

②现在让手洗少一个，机洗多一个，

　　手洗花费时间减少$f(i)<g(i)$，已经不影响最大值,而机洗时间可能增大，花费时间可能增加

如何来计算这一点

可以利用手洗和机洗的时间关系，计算手洗一件可以机洗cnt件，

那后$cnt$件可以机洗，前$n-cnt$件用手洗(手洗早结束也早，所以是在cnt件机洗结束时结束)

这里解释一下题解中机洗答案为什么是$max_{j=i}^{N}t_{j}+(n-j+1)*x$

用洗衣机洗有两种情况：

①洗衣机无空闲时间。排队等着前一个人用完洗衣机后一个人接着用

　　其中$t_{j}+(n-j+1)*x$其实是相当于把后面的衣服都在$j$洗完以后接着洗的，

　　也就是人来了在等洗衣机洗完，洗完接着又开始洗下一个人的衣服，计算无空闲时间情况

②洗衣机有空闲时间。前一个人用完洗衣机，后一个人还没到，隔一段时间才到然后用洗衣机

　　从i到n取最大值，其实是假设第$j$个人洗完，而第$j+1$个人还没来

　　那第$j$个人肯定不会影响最大值了，第$j$个人的时间肯定在$t[j+1]$之内了，计算有空闲时间情况

•代码

 #include<bits/stdc++.h>
 using namespace std;
 #define ll long long
 const int maxn=1e6+;
 ll a[maxn];

 int main()
 {
     int n,m;
     while(~scanf("%d%d",&n,&m))
     {
         for(int i=;i<=n;i++)
             scanf("%lld",a+i);

         sort(a+,a++n);

         for(int i=;i<=m;i++)
         {
             int cnt=min(n,m/i);///手洗一个能机洗的cnt个
             ///令手洗与机洗结束时间相同
             ///后cnt个机洗，前n-cnt个手洗
             ll ans=;
             if(cnt<n)
                 ans=a[n-cnt]+m;///手洗所用时间
             for(int j=n-cnt+;j<=n;j++)///机洗
                 ans=max(ans,a[j]+1ll*(n-j+)*i);

             printf("%lld%c",ans,i==m?'\n':' ');
         }
     }
 }