NOIP2013

1.circle

ans=((10^k%n*m)%n+x)%n

int power(k){

　　if(k==0)return 1%n;

　　if(k==1)return 10%n;

　　int p=power(k>>1);

　　if(k%2==1)return ((p*p)%n*10)%n;

　　return (p*p)%n;

}

2.match

use mergesort to count inversion

int mergesort(int L,int R){
if(L==R)return 0;
int cnt=0;
int M=(L+R)>>1;
cnt=mergesort(L,M);
cnt+=mergesort(M+1,R);
cnt%=mask;
int i=L;int j=M+1;
int * p=new int[R-L+1];
for(int k=0;k<=R-L;k++){
if(i<=M&&j<=R){
if(f[i]<f[j]){
p[k]=f[i];
i++;
}
else{
p[k]=f[j];
cnt+=M-i+1;
cnt%=mask;
j++;
}
}
else{
if(j<=R){
p[k]=f[j];
j++;
}
else{
p[k]=f[i];
i++;
}
}
}
copy(p,p+R-L+1,f+L);
return cnt;
}

3.truck

kruskal,unionfindset score 60

kruskal,dfs score 60

kruskal,dfs score 60

正解参考我的随笔 http://www.cnblogs.com/JebediahKerman/p/5678625.html

/*truck*/
class edge{
public:
    edge(int vv1,int vv2,int ww){
        v1=vv1;v2=vv2;weight=ww;
    }    
    int v1;int v2;int weight;
    static bool compareTo(const edge * a,const edge * b){
        return a->weight > b->weight;
    }
};
class UnionFindSet{
    static const int N=;
    int f[N];
public:
    UnionFindSet(int n){
        for(int i=1;i<=n;i++)
            f[i]=i;
    }
    
    int find(int x){
        if(f[x]==x)return x;
        return f[x]=find(f[x]);
    }
    
    void Union(int a,int b){
        int fa=find(a);
        int fb=find(b);
        f[fb]=fa;
    }
};
class Kruskal{
public:
    static bool kruskal(int n,vector<edge *> & E,vector<edge *> &T){
        UnionFindSet U(n);
        sort(E.begin(),E.end(),edge().compare);
        int k=0;int e=0;
        while(k<n-1&&e<E.size()){
            edge * ee=E[e];
            int a=U.find(ee->v1);
            int b=U.find(ee->v2);
            if(a!=b){
                T.push_back(ee);
                U.Union(ee->v1,ee->v2);
                k++;
            }
        }
        return k==n-1;
    }
};
class SetRoot{
public:
    static void pretreat(vector<edge *> & T,vector<int> * G){
        for(int i=0;i<T.size();i++){
            edge & e=*T[i];
            G[e.v1].push_back(i);
        }
    }
    static void dfs(vector<edge *> & T,vector<int> * G,int * fa,int *cost,int *L,int u,int fthr){
        vector<int> & g=G[u];
        for(int i=0;i<g.size();i++){
            edge & e=*T[g[i]];
            if(e.v2!=fa){
                fa[e.v2]=u;
                L[e.v2]=L[u]+1;
                cost[e.v2]=e.weight;
                dfs(T,G,fa,cost,e.v2,u);
            }
        }
    }
};
class LCA{
public:
    static void prepocess(int (* anc)[LN],int (* mincost)[LN],int * fa,int * cost,int n){
        for(int i=1;i<=n;i++){
            anc[i][0]=fa[i];
            mincost[i][0]=cost[i];
            for(int j=1;(1<<j)<=n;j++)anc[i][j]=-1;
        }
        for(int j=1;(1<<j)<=n;j++)
            for(int i=1;i<=n;i++){
                if(anc[i][j-1]!=-1){
                    int a=anc[i][j-1];
                    anc[i][j]=anc[a][j-1];
                    mincost[i][j]=min(mincost[i][j-1],mincost[a][j-1]);
                }
            }
    }
    
    static query(int (* anc)[LN],int (* mincost)[LN]int p,int q){
        int tem;int log=0;int i;
        if(L[p]<L[q])swap(p,q);
        while((1<<(log+1))<=L[p])log++;
        
        int ans=1e9;
        for(int i=log;i>=0;i--)
            if(L[p]-(1<<i)>=L[q]){
                ans=min(ans,mincost[p][i]);
                p=anc[p][i];
            }
        if(p==q)return ans;//LCA(p,q)=p
        
        for(int i=log;i>=0;i--)
            if(anc[p][i]!=-1&&anc[p][i]!=anc[q][i]){
                ans=min(ans,mincost[p][i]);
                p=anc[p][i];
                ans=min(ans,mincost[q][i]);
                q=anc[q][i];
            }
        ans=min(ans,cost[p]);
        ans=min(ans,cost[q]);
        return ans;//LCA(p,q)=fa[p]=fa[q]
    }
};
class graph{
public:
    static void addedge(vector<edge *> & E,int v1,int v2,int ww){
        E.push_back(new edge(v1,v2,ww));
        E.push_back(new edge(v2,v1,ww));
    }
};

vector<edge *> E;
vector<edge *> T;
vector<int> G;
int n;int m;
int anc[N][LN];int L[N];
int cost[N];int mincost[N][LN];
int fa[N];
int main(){
    ifstream fin("truck.in");
    ofstream fout("truck.out");
    
    fin>>n>>m;
    
    for(int i=1;i<=n;i++){
        int v1;int v2;int ww;
        fin>>v1>>v2>>ww;
        graph().addedge(E,v1,v2,ww);
    }
    
    Kruskal().kruskal(n,E,T);
    SetRoot().pretreat(T,G);
    SetRoot().dfs(T,G,cost,fa,cost,L,1,0);
    LCA().preprocess(anc,mincost,fa,cost,n);
    
    for(int i=1;i<=m;i++){
        int v1;int v2;
        fin>>v1>>v2;
        fout<<LCA().query(anc,mincost,v1,v2)<<endl;
    }
    
    return 0;
}