第一题：
刚开始的时候一下子傻了眼，居然不是白痴题？！
然后就去写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+bd<ad+bc，则a(c-d)<b(c-d),则a<b，与a>b矛盾，所以若a>b,c>d，则ac+bd>ad+bc
将此式子进行推广：
当a1<a2<a3<…<an ,b1<b2<…<bn的情况下 sigma(ai*bi)最大，即sigma(ai-bi)^2最小。
明显，我们同时移动2个序列中的数与移动一个序列中的数是等效的，所以，我们可以保持一个序列不变，只移动另外一个序列，这样，我们就可以在排序后重定义另外一个序列的数的优先级，然后求逆序对个数，就是最小交换个数
第三题：
Kruskal求最大生成树。然后求树上路径最值，接着就什么都可以搞啦，树上倍增，lct或者树链剖分随便上就可以a了。
代码（在smart oj的非官方数据上过了，应该没问题吧）：
T1（快速幂）:
#include <cstdio>
#include <cstring>
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<cstdio>
#include<algorithm>
#include<cstring>
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<y.v;
}
int n,r[MAXN],ans=0;
int t[MAXN];
void Add(int x){for(int i=x;i<=n;i+=lowbit(i)) t[i]++;}
int Sum(int x){
int rec=0;
for(;x;x-=lowbit(x)) rec+=t[x];
return rec;
}
int main(){
scanf("%d",&n);
for(int i=0;i++<n;) scanf("%d",&a[i].v),a[i].t=i;
for(int i=0;i++<n;) scanf("%d",&b[i].v),b[i].t=i;
sort(a+1,a+n+1,cmp),sort(b+1,b+n+1,cmp);
for(int i=0;i++<n;) r[a[i].t]=b[i].t;
for(int i=n;i;i--) ans+=Sum(r[i]),Add(r[i]),ans%=MAX;
printf("%d\n",ans);
return 0;
}
T3（Kruskal+树上倍增）:
#include <cstdio>
#include <algorithm>
#include <cstring>
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<m;i++) scanf("%d%d%d",&e[i].s,&e[i].t,&e[i].d);
sort(e,e+m,cmp);
for (int i=0;i<m;i++) if (Find(e[i].s)!=Find(e[i].t)) {
father[Find(e[i].s)]=Find(e[i].t);
AddEdge(e[i].s,e[i].t,e[i].d);
}
memset(f,true,sizeof(f));
for (int i=0;i++<n;) if (f[i]) h[i]=0,BuildTree(i),Min[i][0]=inf,up[i][0]=i;
for (int i=0;i++<MAXD-1;) {
for (int j=0;j++<n;) {
up[j][i]=up[up[j][i-1]][i-1];
Min[j][i]=min(Min[j][i-1],Min[up[j][i-1]][i-1]);
}
}
scanf("%d",&q);
while (q--) {
int u,v;
scanf("%d%d",&u,&v);
printf("%d\n",Query(u,v));
}
return 0;
}
