NOIP 2013 day1

tags:

• 模拟
• 快速幂
• 逆序对
• 树状数组
• 归并排序
• 最小生成树
• lca
• 倍增
  categories:
• 信息学竞赛
• 总结

tex live 2017.iso
转圈游戏
火柴排队
货车运输

转圈游戏

solution

　　就是要求让一个人在一个圈上走一定步数, 问最后在哪里.例如走\(10^k\)次, 一次走\(\text{m}\)步, 初始时在\(\text{x}\), 圈长\(\text{n}\), 那么它最后的位置就是:

\[x+m10^k\mod n \]

那么直接用快速幂暴力求出这个式子的值.

code

#include<cstdio>
int n,m,k,x;

long long pow(int a,int b){
    long long ans=1ll,bas=a;
    while(b){
        if(b&1)ans*=bas;
        ans%=n;
        if(!bas)return ans;
        bas*=bas;bas%=n;
        if(!bas)return false;
        b>>=1;
    }
    return ans;
}

int main(){
    scanf("%d%d%d%d",&n,&m,&k,&x);
    long long ans=x,mm=pow(10,k);
    ans+=m*mm%n;
    ans%=n;
    printf("%lld\n",ans);
    return 0;
}

火柴排队

solution

　　其实就是将其中一个通过交换两个相邻的元素使得变化后的序列与另一个序列最相近, 问操作次数.
　　其实就是使得两个序列中最大的元素位置相同, 第二大的元素位置也相同, 第三大的元素位置相同......那么元素的具体大小其实根本无所谓, 只需要知道元素之间的大小关系, 所以可以先将两个序列离散化, 然后找到其中一个的元素在另一个中的位置, 记为序列\(\text{c}\), 经离散后的序列记为\(\text{a,b}\), 那么我们进行的交换操作, 实际上就是将\(\text{c}\)变为序列\(1,2,\cdots ,n\), 这样其实就是将\(\text{b}\)变成\(\text{a}\).

Code

#include<algorithm>
#include<cstdio>
#define N 100005
#define mod 99999997

int ans;
int n,u[N];
int a[N],b[N];
int e[N],f[N],g[N];


void mergesort(int l,int r){ 
    if(l==r)return;
    int mid,i,j,k;  
    mid=(l+r)>>1;   
    mergesort(l,mid); 
    mergesort(mid+1,r); 
    i=l,j=mid+1,k=l;  
    while(i<=mid&j<=r)
        if(g[i]>=g[j])u[k++]=g[j++],ans+=(mid-i+1)%mod,ans%=mod;
        else u[k++]=g[i++];
    while(i<=mid)u[k++]=g[i++];
    while(j<=r)u[k++]=g[j++];
    for(i=l;i<=r;i++)g[i]=u[i];
}

struct Node{
    int val,pos;
    bool operator<(const Node& s)const{
        return val<s.val;
    }
}c[N],d[N];


int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;++i)scanf("%d",&a[i]);
    for(int i=1;i<=n;++i)scanf("%d",&b[i]);
    for(int i=1;i<=n;++i)c[i]=(Node){a[i],i};
    for(int i=1;i<=n;++i)d[i]=(Node){b[i],i};
    std::sort(c+1,c+n+1);std::sort(d+1,d+n+1);
    for(int i=1;i<=n;++i)e[c[i].pos]=i;
    for(int i=1;i<=n;++i)f[d[i].pos]=i;
    for(int i=1;i<=n;++i)g[i]=c[f[i]].pos;
    mergesort(1,n);
    printf("%d",ans);
    return 0;
}

货车运输

　　这个经典的题目不知道做了多少遍了, 这次做还是发现了一些问题.

Solution

　　需要使得图上两点之间经过路径上边的最小值最大, 首先将原图变成最大生成树, 因为两点之间经过的最小边权最大的路径必然存在在最大生成树上. 记两点之间的路径的转折点为\(\text{lca}\)(最近公共祖先),在最大生成树上两点\(\text{u,v}\)之间路径上边的最小值就是\(\text{u}\)到\(\text{lca}\)路径上边的最小值或者是\(\text{u}\)到\(\text{lca}\)路径上边的最小值.

• 需要用倍增来加速\(\text{lca}\)的求解, 也可以用树链剖分, 用\(f(u,i)\)表示从\(\text{u}\)向上第\(2^i\)个点是哪个点.递推公式为:

\[f(u,i)=f(f(u,i-1),i-1) \]

• 求\(树上两点之间路径的最小值\)可以使用\(\text{RMQ}\)算法, 用\(d(u,i)\)表示从$\text{u}以上\(2^i\)个点路径的最小值, 那么递推公式为:

\[d(u,i)=\max{d(u,i-1),d(f(u,i-1),i-1)} \]

　　\(f(u,0)\)和\(d(u,0)\)可以在dfs中直接得到, \(f(u,i)\)和\(d(u,i)\)需要递推来获得.

Code

#include<algorithm>
#include<cstdio>
#define N 500005
#define inf 0x3f3f3f3f
int n,m,q;
int fa[N];
int dep[N];
int f[N][20];
int d[N][20];
 
int min(int i,int j){
    return i>j?j:i;
}
 
int find(int s){
    if(fa[s]!=s)fa[s]=find(fa[s]);
    return fa[s];
}
struct E{
    int u,v,cost;
    void Init(){
        scanf("%d%d%d",&u,&v,&cost);
    }
    bool operator<(const E&s)const{
        return cost>s.cost;
    }
    void print(){
        printf("%d %d %d\n",u,v,cost);
    }
}edge[N];
 
int head[N],tot;
struct Edge{
    int v,c,nxt;
}e[N];
 
void AddEdge(int u,int v,int c){
    e[++tot]=(Edge){v,c,head[u]};head[u]=tot;
    e[++tot]=(Edge){u,c,head[v]};head[v]=tot;
}
 
void dfs(int x,int fath){
    f[x][0]=fath;dep[x]=dep[fath]+1;
    for(int i=head[x];i;i=e[i].nxt){
        if(e[i].v==fath)continue;
        d[e[i].v][0]=e[i].c;dfs(e[i].v,x);
    }
}
 
int Lca(int u,int v){
    int cha;
    if(dep[u]<dep[v])std::swap(u,v);
    for(int i=19;i>-1;--i)
        if(dep[f[u][i]]>=dep[v])
            u=f[u][i];
    for(int i=19;i>-1;--i)
        if(f[u][i]!=f[v][i])
            u=f[u][i],v=f[v][i];
    if(u!=v)return f[u][0];
    return u;
}
 
int Ans(int u,int v){
    if(u==v)return inf;
    int ans=inf;
    for(int i=19;i>-1;--i)
        if(dep[f[u][i]]>=dep[v])
            ans=min(d[u][i],ans),u=f[u][i];
    return ans;
}
 
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;++i)edge[i].Init();
    for(int i=1;i<=n;++i)fa[i]=i;
    std::sort(edge+1,edge+m+1);int f1,f2,flag=0;
    for(int pos=1,f1,f2,i=1;i<n;++i){
        for(f1=find(edge[pos].u),f2=find(edge[pos].v);f1==f2;++pos,f1=find(edge[pos].u),f2=find(edge[pos].v))
                if(pos>m){flag=1;break;}
        if(flag)break;
        fa[f1]=f2;
        AddEdge(edge[pos].u,edge[pos].v,edge[pos].cost);
        //edge[pos].print();
    }
    dfs(1,0);
    for(int i=1;i<20;++i)
        for(int j=1;j<=n;++j)
            f[j][i]=f[f[j][i-1]][i-1];
    for(int i=1;i<20;++i)
        for(int j=1;j<=n;++j)
            d[j][i]=min(d[j][i-1],d[f[j][i-1]][i-1]);
    scanf("%d",&q);
    int u,v,lca;
    while(q--){
        scanf("%d%d",&u,&v);
        lca=Lca(u,v);
        if(find(u)!=find(v))printf("-1\n");
        else printf("%d\n",min(Ans(u,lca),Ans(v,lca)));
    }
    return 0;
}