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=1;
    while(b)
    {
        if(b&1)
            res=res*a>mod?res*a%mod+mod:res*a;
        a=a*a>mod?a*a%mod+mod:a*a;
        b>>=1;
    }
    return res;
}

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

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

    ll p=phi(m);
    return qpow(a,solve(a,b-1,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[305][305];

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

void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;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=1;i<=m;++i)
        {
            scanf("%d%d%lld",&u,&v,&k);
            d[u+1][v+1]=k;
        }
        for(int i=1;i<=6;++i)
        {
            floyd();
            scanf("%d%d",&u,&v);
            printf("%lld\n",-1ll*d[v+1][u+1]);
            d[u+1][v+1]=-1ll*d[v+1][u+1];
        }
    }
}

 

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+5;
int a[maxn];
int R[maxn],L[maxn];
int s[maxn];
set<int> f;
int n,k;

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

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

    for(int i=n;i>=1;i--)
    {
        auto it=f.upper_bound(a[i]);
        it--;
        L[a[i]]=*it;
        f.erase(f.find(a[i-1]));
        if(index>=1)
            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[0]==0;
    for(int i=1;i<=n;i++)
    {
        s[i]=s[max(R[i],L[i])]+1;
        printf("%d%c",s[i],i==n?'\n':' ');
    }

}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n>>k;
        for(int i=1;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+5;
ll a[maxn];

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

        sort(a+1,a+1+n);

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

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