Noip 2013day 1 被虐报告

第一题：
刚开始的时候一下子傻了眼，居然不是白痴题？！
然后就去写T3了。后来才写了个O(n)的求循环节算法,后来才发现可以快速幂水过
Ans=(x+10^k m)%n=(x+10^k%n)%n
然后10^k%n 可以快速幂过

第二题：
看都没看据说是Greedy+bit

首先，将两个序列各自排序，然后大对大，小对小，这个贪心可以保证(ai-bi)^2最小，证明：

sigma(ai-bi)^2=sigma ai^2 + sigma bi^2 - 2sigma aibi

这时，只要sigma aibi最大就可以了，那么证明在该贪心下这个多项式最大：

若存在a>b,c>d,且ac+bdb矛盾，所以若a>b,c>d，则ac+bd>ad+bc

将此式子进行推广：

当a1

明显，我们同时移动2个序列中的数与移动一个序列中的数是等效的，所以，我们可以保持一个序列不变，只移动另外一个序列，这样，我们就可以在排序后重定义另外一个序列的数的优先级，然后求逆序对个数，就是最小交换个数

第三题：
Kruskal求最大生成树。然后求树上路径最值，接着就什么都可以搞啦，树上倍增，lct或者树链剖分随便上就可以a了。

代码（在smart oj的非官方数据上过了，应该没问题吧）：

T1（快速幂）:

#include 

#include 



using namespace std;

 

int k;

long long ans;

int n,m,x;

 

long long Exp(int y){

    if(!y)return 1;

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

    long long X=Exp(y>>1);

    if(y&1){

        return((X*X%n)*10)%n;

    }else return(X*X)%n;

}

 

int main(){

    scanf("%d%d%d%d",&n,&m,&k,&x);

    ans=Exp(k);

    ans*=m;

    ans%=n;

    ans+=x;

    ans%=n;

    printf("%I64d",ans);

    fclose(stdin),fclose(stdout);

    return 0;

}

T2（整理两个数组成一个，然后求逆序对）:

#include
#include
#include
 
using namespace std;
 
#define MAXN 100010
#define lowbit(x)(((~(x))+1)&x)
#define MAX 99999997
 
struct saver{
    int v,t;
};
saver a[MAXN],b[MAXN];
 
bool cmp(saver x,saver y){
    return x.v

T3（Kruskal+树上倍增）:

#include 
#include 
#include 
 
using namespace std;
 
#define MAXN 10010
#define MAXM 50010
#define MAXQ 30010
#define MAXD 20
#define clear(x) memset(x,0,sizeof(x))
#define AddEdge(s,t,d) Add(s,t,d),Add(t,s,d)
#define inf 0x7fffffff
 
struct saver {
    int s,t,d;
} e[MAXM];
 
bool cmp(saver x,saver y) {
    return x.d>y.d;
}
 
int father[MAXN],n,m,q,Q[MAXQ][2];
 
int Find(int x) {
    int i,j=x;
    for (i=x;father[i];i=father[i]) ;
    while (father[j]) {
        int k=father[j];
        father[j]=i;
        j=k;
    }
    return i;
}
 
int up[MAXN][MAXD],Min[MAXN][MAXD],h[MAXN];
bool f[MAXN];
 
struct edge {
    edge *next;
    int t,d;
    edge () {
        next=NULL;
    }
} *head[MAXN];
 
void Add(int s,int t,int d) {
    edge *p=new(edge);
    p->t=t,p->d=d,p->next=head[s];
    head[s]=p;
}
 
void BuildTree(int v) {
    f[v]=false;
    for (edge *p=head[v];p;p=p->next) if (f[p->t]) {
        up[p->t][0]=v,Min[p->t][0]=p->d,h[p->t]=h[v]+1;
        BuildTree(p->t);
    }
}
 
int Move(int &v,int H) {
    int rec=inf;
    for (int i=MAXD-1;i>=0;i--) {
        if (h[up[v][i]]>=H) {
            rec=min(rec,Min[v][i]);
            v=up[v][i];
        }
    }
    return rec;
}
 
int Query(int u,int v) {
    if (Find(u)!=Find(v)) return -1;
    int rec=inf;
    if (h[u]!=h[v]) rec=h[u]>h[v]?Move(u,h[v]):Move(v,h[u]);
//    printf("%d\n",rec);
    if (u==v) return rec;
    for (int i=MAXD-1;i>=0;i--) {
        if (up[u][i]!=up[v][i]) {
            rec=min(rec,min(Min[u][i],Min[v][i]));
            u=up[u][i],v=up[v][i];
        }
    }
    rec=min(rec,min(Min[u][0],Min[v][0]));
    return rec;
}
 
int main() {
    clear(father),clear(head),clear(up);
    scanf("%d%d",&n,&m);
    for (int i=0;i