Avito Cool Challenge 2018(div1+2)

A. Definite Game：

题意：输入N，输出最小的结果N-x，其中x不少N的因子。

思路：N=2时，输出2；其他情况输出1；因为N>2时，N-1不会是N的因子。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
int a[maxn];
int main()
{
    int N; cin>>N;
    if(N==) puts("");
    else puts("");
    return ;
}

B. Farewell Party

题意：有N个人，有N中帽子，N个数，表示多少人与他的帽子不同。

思路：把问题转维有多少个人帽子和他相同，然后数字相同的分到同一组，而且人数是数字的倍数，因为同一组的还要均分。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
int a[maxn],ans[maxn],vis[maxn],cnt,num[maxn];
int main()
{
    int N; cin>>N; bool F=true;
    rep(i,,N) scanf("%d",&a[i]),a[i]=N-a[i];
    rep(i,,N) num[a[i]]++;
    rep(i,,N) if(num[i]%i!=) {F=false; break;}
    rep(i,,N){
        if(num[a[i]]%a[i]==) vis[a[i]]=++cnt;
        ans[i]=vis[a[i]];
        num[a[i]]--;
    }
    if(!F) puts("Impossible");
    else {
        puts("Possible");
        rep(i,,N) printf("%d ",ans[i]);
    }
    return ;
}

C. Colorful Bricks

题意：有N个地板，有M种颜色，有K个地板与左边的不相同。

思路：数据量不难写出二维DP，方程为，dp[i][j]=dp[i-1][j]+dp[i-1][j-1]*(M-1)；（也可以用组合数来做，不过这个数据没必要想太多

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
const int Mod=;
int dp[maxn][maxn];
int main()
{
    int N,M,K;
    scanf("%d%d%d",&N,&M,&K);
    dp[][]=M;
    rep(i,,N) {
        rep(j,,i-){
            if(j==) dp[i][j]=dp[i-][j];
            else dp[i][j]=(dp[i-][j]+1LL*dp[i-][j-]*(M-)%Mod)%Mod;
        }
    }
    printf("%d\n",dp[N][K]);
    return ;
}

D. Maximum Distance

题意：题意很搅，这里的距离表示最小的路径最大值，就是让你求一个最小生成树（满足路径最大值最小），在生成树上有K个关键点，你的任务是对于每个关键点，找离他最远的关键点，输出距离。

思路：K个点的虚树，是所有两两路径经过的边集并，我们求这个边集并的最大值就是结果，因为我们可以保证他过这条边。其他写法容易挂，具体为什么暂时不知道。（虚树可以换成并查集？）

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
int a[maxn],Laxt[maxn],Next[maxn],To[maxn],Len[maxn],cnt,ans;
struct in{
    int u,v,len;
    friend bool operator <(in a,in b){ return a.len<b.len; }
}s[maxn];
int in[maxn],fa[maxn][],dep[maxn],vis[maxn],times,fcy[maxn];
bool cmp(int x,int y) { return in[x]<in[y]; }
void add(int u,int v,int c) { Next[++cnt]=Laxt[u]; Laxt[u]=cnt; To[cnt]=v;Len[cnt]=c;}
void dfs(int u,int f)
{
    in[u]=++times; fa[u][]=f; dep[u]=dep[f]+;
    for(int i=Laxt[u];i;i=Next[i]){
        if(To[i]!=f) fcy[To[i]]=Len[i],dfs(To[i],u);
    }
}
int LCA(int u,int v)
{
    if(dep[u]<dep[v]) swap(u,v);
    for(int i=;i>=;i--) if(dep[fa[u][i]]>=dep[v]) u=fa[u][i];
    if(u==v) return u;
    for(int i=;i>=;i--) if(fa[u][i]!=fa[v][i]) u=fa[u][i],v=fa[v][i];
    return fa[u][];
}
int ac[maxn];
int find(int x){
    if(ac[x]!=x) return ac[x]=find(ac[x]); return x;
}
int main()
{
    int N,M,K;
    scanf("%d%d%d",&N,&M,&K);
    rep(i,,K) scanf("%d",&a[i]);
    rep(i,,M){
        scanf("%d%d%d",&s[i].u,&s[i].v,&s[i].len);
    }
    sort(s+,s+M+);
    rep(i,,N) ac[i]=i;
    rep(i,,M){
        int fau=find(s[i].u);
        int fav=find(s[i].v);
        if(fau!=fav) {
            ac[fau]=fav;
            add(s[i].u,s[i].v,s[i].len);
            add(s[i].v,s[i].u,s[i].len);
        }
    }
    dfs(,);
    sort(a+,a+K+,cmp);
    int tot=K;
    rep(i,,K) a[++tot]=LCA(a[i-],a[i]);
    sort(a+,a+tot+,cmp);
    tot=unique(a+,a+tot+)-(a+);
    rep(i,,tot) vis[a[i]]=; //得到关键点
    rep(i,,tot){   //关键点之间连边得到新树
        int u=a[i];
        while(true){
            if(u==a[]) break;
            ans=max(fcy[u],ans); u=fa[u][];
            if(vis[u]||u==) break;
        }
    }
    rep(i,,K) printf("%d ",ans);
    return ;
}

E. Missing Numbers

题意：一个偶数N的序列，我们给出了偶数位置的数，让你填补奇数位置的数，满足所有前缀和的完全平方数。

思路：因为都是完全平方数，注意到完全平方数的相邻差值递增，我们可以利用这个单调性来搜索，或者单调队列什么的。我是二分写的，好像有点丑。 过了就行。。。

#include<bits/stdc++.h>
#define ll long long
#define rep(i,a,b) for(ll i=a;i<=b;i++)
using namespace std;
const int maxn=;
const ll inf=1e13;
ll p[maxn],a[maxn],b[maxn],ans[maxn],cnt,N; //
int main()
{
    for(ll i=;;i++){
        if(i*i>inf) break;
        p[++cnt]=i*i;
    }
    bool F=true;
    scanf("%lld",&N);
    rep(i,,N/){
        scanf("%lld",&a[i]);
    }
    if(!F) return puts("No"),;
    ll BG=-1LL;
    rep(i,,cnt){
        ll pos=lower_bound(p+,p+cnt+,p[i]+a[])-p;
        if(pos>=&&p[pos]==p[i]+a[]){
            ans[]=p[pos]-a[];
            ll kk=lower_bound(p+,p+cnt+,ans[])-p;
            if(p[kk]==ans[]){ BG=pos; break;}
        }
    }
    if(BG==-1LL) return puts("No"),;
    ans[]=a[]; ll fcy=BG;
    for(ll i=;i<=N/&&fcy<=cnt;i++){
        while(fcy<=cnt){
            ll pos=lower_bound(p+,p+cnt+,p[fcy]+a[i])-p;
            if(pos>=BG+&&p[pos]==p[fcy]+a[i]){
                ll tmp=p[pos]-a[i];
                ll hhh=lower_bound(p+,p+cnt+,tmp)-p;
                if(p[hhh]==tmp) {ans[i*]=a[i]; ans[i*-]=p[pos]-p[BG]-a[i]; BG=pos; fcy=BG; break;}
                else fcy++;
            }
            else fcy++;
        }
    }
    rep(i,,N) if(ans[i]<1LL||ans[i]>inf) return puts("No"),;
    puts("Yes");
    rep(i,,N) printf("%lld ",ans[i]);
    return ;
}