NOIp 2013 Day1 解题报告

NOIp 2013 Day1 解题报告

1. 1.   转圈游戏

不难看出答案就是(x+m*10^k) mod n

用快速幂算法，复杂度O(log₂k)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

//variable//
int n,m,x,k;

//solve//
int main(){
    scanf("%d%d%d%d",&n,&m,&k,&x);
    int a=10,ans=1;
    while (k){
        if (k&1){
            ans=(ans*a)%n;
        }
        k>>=1;
        a=(a*a)%n;
    }
    ans=(ans*m+x)%n;
    printf("%d\n",ans);
    return 0;
}

 

1. 2.   火柴排队

整理题设算式，我们发现，当(A₁B₁+A₂B₂+…+A_nB_n)最大时题设最小。

依据排序不等式，当且仅当A₁<A₂<…<A_n且B₁<B₂<…<B_n时上式最大。

可以看出，对于A_k和B_k，同时交换两者和仅交换其中一个是等价的，因为无论如何交换，除了A_k和B_k以外，其他A和B彼此的相对位置不变。所以，我们默认固定A，交换B中的数，使他满足上文提到的对应关系。

令A中第i个数的num[i]=i，设A中第i个数排第k，则令B中排第k的数的num[j]=i

B的num的逆序对数就是答案。

利用树状数组求逆序对，复杂度O(NlogN)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

//variable//
int mod=99999997,a[110000],b[110000],st[110000],n,loc[110000],bit[110000];

//function prototype//
int sumbit(int);
void addbit(int,int);

//solve//
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){
        st[i]=a[i];
    }
    sort(st+1,st+n+1);
    for (int i=1;i<=n;++i){
        a[i]=lower_bound(st+1,st+n+1,a[i])-st;
    }
    for (int i=1;i<=n;++i){
        st[i]=b[i];
    }
    sort(st+1,st+n+1);
    for (int i=1;i<=n;++i){
        b[i]=lower_bound(st+1,st+n+1,b[i])-st;
    }
    for (int i=1;i<=n;++i){
        st[a[i]]=i;
    }
    for (int i=1;i<=n;++i){
        loc[i]=st[b[i]];
    }
    int ans=0;
    for (int i=n;i;--i){
        ans=(ans+sumbit(loc[i]))%mod;
        addbit(loc[i],1);
    }
    printf("%d\n",ans);
    return 0;
}

void addbit(int x,int delta){
    for (;x<=n;x+=x&-x){
        bit[x]+=delta;
    }
}

int sumbit(int x){
    int ret=0;
    for (;x;x-=x&-x){
        ret+=bit[x];
    }
    return ret;
}

 

1. 3.   火车运输

定理：无向带权图上，任意两点间，满足在所有路径中，路径上边权最小（大）值最大（小）的路径一定在最大（小）生成树上。

证明：依据最大（小）生成树的定义，利用反证法可以显然得证。

因此，由上可得，本题所求就是两点间路径上最小边的最大值。求出最大生成树，再在最大生成树上倍增得到每个询问的答案。

复杂度O(MlogM+NlogN+QlogN)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

//type//
struct mingraph{
    int from,dest,cost,use;
};

//variable//
mingraph g[100000];
int tot=1,last[100100],prel[100100],dest[100100],cost[100100];
int Q,n,m,ance[11000][20],mins[11000][20],fa[11000],vis[11000],q[11000],dep[11000];

//function prototype//
void kruskal(void);
void addline(int,int,int);
void bfs(int);
void calc_ance(void);
bool comp(mingraph,mingraph);
int getfa(int);
int calc_ans(int,int);

//solve//
int main(){
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;++i){
        scanf("%d%d%d",&g[i].from,&g[i].dest,&g[i].cost);
        g[i].use=0;
    }
    kruskal();
    for (int i=1;i<=m;++i){
        if (g[i].use){
            addline(g[i].from,g[i].dest,g[i].cost);
            addline(g[i].dest,g[i].from,g[i].cost);
        }
    }
    memset(vis,0,sizeof vis);
    memset(mins,0x7f,sizeof mins);
    for (int i=1;i<=n;++i){
        if (!vis[i]){
            bfs(i);
        }
    }
    calc_ance();
    for (scanf("%d",&Q);Q;--Q){
        int x,y;
        scanf("%d%d",&x,&y);
        if (getfa(x)!=getfa(y)){
            puts("-1");
        }else{
            printf("%d\n",calc_ans(x,y));
        }
    }
    return 0;
}

int calc_ans(int u,int v){
    int ans=2147000000;
    if (dep[u]<dep[v]){
        swap(u,v);
    }
    for (int j=19;j>=0;--j){
        if ((1<<j)&(dep[u]-dep[v])){
            ans=min(ans,mins[u][j]);
            u=ance[u][j];
        }
    }
    if (u==v){
        return ans;
    }
    for (int j=19;j>=0;--j){
        if (ance[u][j]!=ance[v][j]){
            ans=min(ans,min(mins[u][j],mins[v][j]));
            u=ance[u][j];
            v=ance[v][j];
        }
    }
    return min(ans,min(mins[u][0],mins[v][0]));
}

void calc_ance(){
    for (int j=1;j<20;++j){
        for (int i=1;i<=n;++i){
            ance[i][j]=ance[ance[i][j-1]][j-1];
            mins[i][j]=min(mins[ance[i][j-1]][j-1],mins[i][j-1]);
        }
    }
}

void bfs(int x){
    int he=1,ta=1;
    memset(q,0,sizeof q);
    q[1]=x;vis[x]=1;dep[x]=1;
    while (he<=ta){
        int u=q[he++];
        for (int k=last[u];k;k=prel[k]){
            if (!vis[dest[k]]){
                vis[dest[k]]=1;
                q[++ta]=dest[k];
                dep[dest[k]]=dep[u]+1;
                ance[dest[k]][0]=u;
                mins[dest[k]][0]=cost[k];
            }
        }
    }
}

void addline(int u,int v,int w){
    dest[++tot]=v;
    prel[tot]=last[u];
    last[u]=tot;
    cost[tot]=w;
}

bool comp(mingraph a,mingraph b){
    return a.cost>b.cost;
}

void kruskal(){
    sort(g+1,g+m+1,comp);
    for (int i=1;i<=n;++i){
        fa[i]=i;
    }
    int tot=0;
    for (int i=1;i<=m;++i){
        if (getfa(g[i].from)!=getfa(g[i].dest)){
            g[i].use=1;
            fa[getfa(g[i].from)]=getfa(g[i].dest);
            ++tot;
            if (tot==n-1){
                break;
            }
        }
    }
}

int getfa(int x){
    return fa[x]==x? x:fa[x]=getfa(fa[x]);
}