noip考前模板大整理

//归并排序求逆序对
#include<bits/stdc++.h>
#define ll long long
using namespace std;
];
ll ans;
];
void merge_sort(int l,int r) {
    if(l==r)return;
    ;
    ,cnt=l;
    merge_sort(l,mid);
    merge_sort(mid+,r);
    while(i<=mid&&j<=r) {
        if(a[i]<=a[j])b[cnt++]=a[i++];
        else {
            b[cnt++]=a[j++];
            ans+=(mid-i+);
        }
    }
    while(i<=mid)b[cnt++]=a[i++];
    while(j<=r)b[cnt++]=a[j++];
    for(register int s=l; s<=r; ++s)a[s]=b[s];
}
int main() {
    scanf("%d",&n);
    ; i<=n; ++i) {
        scanf("%d",&a[i]);
    }
    merge_sort(,n);
    printf("%lld",ans);
    ;
}

//SPFA模板pre为记录路径，同dij
#include<bits/stdc++.h>
using namespace std;
int n,m;
];
];
int a,b,v,siz;
],lu[];
];
struct node {
    int v,dis,next;
} e[];
void add(int u,int v,int dis) {
    ++cnt;
    e[cnt].v=v;
    e[cnt].dis=dis;
    e[cnt].next=head[u];
    head[u]=cnt;
}
void print(int nn) {
    )return;
    else {
        lu[++siz]=pre[nn];
        print(pre[nn]);
    }
}
void SPFA() {
    memset(book,false,sizeof(book));
    memset(dist,0x3f,sizeof(dist));
    queue<int>q;
    q.push();
    book[]=;
    //pre[1]=0;
    dist[]=;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        book[u]=;
        for(register int i=head[u]; i; i=e[i].next) {
            int v=e[i].v;
            if(dist[v]>dist[u]+e[i].dis) {
                dist[v]=dist[u]+e[i].dis;
                pre[v]=u;
                if(!book[v]) {
                    q.push(v);
                    book[v]=;
                }
            }
        }
    }
}
int main() {
    scanf("%d%d",&n,&m);
    ; i<=m; ++i) {
        scanf("%d%d%d",&a,&b,&v);
        add(a,b,v);
    }
    SPFA();
    printf("%d\n",dist[n]);
    print(n);
    ; --i)
        printf("%d->",lu[i]);
    cout<<n;
    ;
}

//SPFA判负环
int tim[maxn];
bool spfa(int s) {
    d[s]=;
    q.push(s);
    used[s]=;
    while(!q.empty()) {
        int x=q.front();
        q.pop();
        used[x]=;
        for(int i=first[x]; i; i=next[i]) {
            int u=hh[i].t;
            if(d[u]>d[x]+hh[i].c) {
                d[u]=d[x]+hh[i].c;
                if(!used[u]) {
                    if(++tim[u]>n)
                        return false;
                    q.push(u);
                    used[u]=;
                }
            }
        }
    }
    return true;
}

//DIJ模板
#include<iostream>
#include<cstdio>
#include<cstring>
#define maxn 10009
#define inf 2147483647
using namespace std;
int n,m,s,sumedge;
int dis[maxn],vis[maxn],head[maxn];
struct Edge { //邻接表储存
    int x,y,z,nxt;
    Edge(,,,):
        x(x),y(y),z(z),nxt(nxt) {}
} edge[maxn*];
void add(int x,int y,int z) {
    edge[++sumedge]=Edge(x,y,z,head[x]);
    head[x]=sumedge;
}
void di() {
    ; i<=n; i++)dis[i]=inf;
    dis[s]=;
    ; i<=n; i++) {
        int k,mn=inf;
        ; j<=n; j++) {
            if(!vis[j]&&dis[j]<mn) {
                mn=dis[j];
                k=j;
            }
        }
        if(mn==inf)break;
        vis[k]=true;
        for(int j=head[k]; j; j=edge[j].nxt) {
            int v=edge[j].y;
            if(!vis[v]&&dis[v]>dis[k]+edge[j].z)
                dis[v]=dis[k]+edge[j].z;
        }
    }
}
int main() {
    scanf("%d%d%d",&n,&m,&s);
    ; i<=m; i++) {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
    }
    di();
    ; i<=n; i++)printf("%d ",dis[i]);
    ;
}

//floyd
memset(dis,0x3f,sizeof(dis));
; i<=n; i++)dis[i][i]=;
; k<=n; k++)
    ; i<=n; i++)
        ; j<=n; j++)
            dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);

//最小生成树kruskal
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 5020
#define M 200008
using namespace std;
int n,m,ans;
int tot;
int fa[N];
struct E {
    int x,y,z;
} e[M];
bool cmp(E a,E b) {
    return a.z<b.z;
}
int f(int x) {
    return fa[x]==x?x:fa[x]=f(fa[x]);
}
int main() {
    scanf("%d%d",&n,&m);
    ; i<=m; i++)scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].z);
    ; i<=n; i++)fa[i]=i;
    sort(e+,e+m+,cmp);
    ; i<=m; i++) {
        int x=e[i].x,y=e[i].y;
        int fx=f(x),fy=f(y);
        if(fx!=fy) {
            fa[fx]=fy;
            ans+=e[i].z;
            )break;
        }
    }
    )cout<<"orz\n";
    else printf("%d\n",ans);
    ;
}

//欧拉筛法
void prime() {
    check[]=;
    ; i<=n; i++) {
        if(!check[i])prim[++cnt]=i;//这个if语句后面没有大括号！！
        ; j<=cnt&&prim[j]*i<=n; j++) {
            check[i*prim[j]]=true;
            )break;
        }
    }
}

//素数判断
bool check(int x) {
    )return false;
    ; i*i<=x; i++)
        )return false;
    return true;
}

//gcd
int gcd(int x,int y) {
    ?x:gcd(y,x%y);
}

//多组gcd预处理
#include<iostream>
#include<cstdio>
using namespace std;
][];
int main() {
    scanf("%d",&n);
    ; i<=n; i++) {
        g[i][i]=i;
        g[i][]=g[][i]=i;
        ; j<i; j++) {
            g[j][i]=g[i][j]=g[j][i%j];
        }
    }
    ;
}

//最长回文串
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
;
],str[maxn*];
],len;

void getstr() {
    ;
    str[k++]='$';
    ; i<len; i++)
        str[k++]='#',
                 str[k++]=s[i];
    str[k++]='#';
    len=k;
}
void Manacher() {
    getstr();
    ,id;
    ; i<len; i++) {
        *id-i],mx-i);
        ;
        while(str[i+Len[i]]==str[i-Len[i]])
            Len[i]++;
        if(Len[i]+i>mx)
            mx=Len[i]+i,id=i;
    }
}
int main() {
    scanf("%s",&s);
    len=strlen(s);
    Manacher();
    ;
    ; i<len; i++) ans=max(ans,Len[i]);
    printf();
    ;
}

//分解质因素
#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
int main() {
    long long n;
    scanf("%lld",&n);
    ; i<=n; i++) {
        while(n!=i) {
            ) {
                printf("%lld*",i);
                n=n/i;
            } else break;
        }
    }
    printf("%lld",n);
    ;
}

//求树上两点距离，无向图根节点随意，有向的根入度为0
#include<bits/stdc++.h>
using namespace std;
int n;
];
];
];
],cnt;
];
struct node {
int v,w,next;
} e[];
inline void add(int u,int v,int w) {
e[++cnt].next=head[u];
e[cnt].v=v;
e[cnt].w=w;
head[u]=cnt;
}
inline void Deep_pre(int x,int dep) {//求深度
deep[x]=dep;
for(register int i=head[x]; i; i=e[i].next) {
if(e[i].v==fa[x]) continue;
fa[e[i].v]=x;
dist[e[i].v]=dist[x]+e[i].w;
Deep_pre(e[i].v,dep+);
}
}
inline int lca(int x,int y) {//暴力lca
if(deep[x]>deep[y])swap(x,y);
while(deep[x]!=deep[y]) {
y=fa[y];
}
while(x!=y) {
x=fa[x];
y=fa[y];
}
return x;
}
int main() {
scanf("%d",&n);
,u,v,w; i<n; ++i) {
scanf("%d%d%d",&u,&v,&w);
add(u,v,w);
add(v,u,w);
}
;
fa[root]=;
Deep_pre(root,);
int m,ui,vi;
scanf("%d",&m);
; i<=m; ++i) {
scanf("%d%d",&ui,&vi);
int LCA=lca(ui,vi);
// printf("%d\n",deep[ui]+deep[vi]-2*deep[LCA]);//两点距离
printf(*dist[LCA]);//两点距离
}
;
} 

//Tarjan lca
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,m,s;
],hd[];
int x,y,u,v,cnt,cnt1;
];
],ans[];
struct node {
    int v,next;
} e[<<];
struct edge {
    int v,next,num;
} ee[<<];
inline int find(int x) {
    return x==fa[x]?x:fa[x]=find(fa[x]);
}
inline void Union(int x,int too) {
    int r1=find(x),r2=find(too);
    if(r1!=r2)fa[r2]=r1;
}
inline void add(int u,int v) {
    e[++cnt].next=head[u];
    e[cnt].v=v;
    head[u]=cnt;
}
inline void ask(int u,int v,int num) {
    ee[++cnt1].next=hd[u];
    ee[cnt1].num=num;
    ee[cnt1].v=v;
    hd[u]=cnt1;
}
inline void dfs(int x) {
    vis[x]=true;
    for(register int i=hd[x]; i; i=ee[i].next) {
        if(vis[ee[i].v])ans[ee[i].num]=find(ee[i].v);
    }
    for(register int i=head[x]; i; i=e[i].next) {
        if(!vis[e[i].v]) {
            dfs(e[i].v);
            Union(x,e[i].v);
        }
    }
}
int main() {
    memset(vis,false,sizeof(vis));
    scanf("%d%d%d",&n,&m,&s);
    ; i<=n; ++i)fa[i]=i;
    ; i<n; ++i) {
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }
    ; i<=m; ++i) {
        scanf("%d%d",&u,&v);
        ask(u,v,i);
        ask(v,u,i);
    }
    dfs(s);
    ; i<=m; ++i)printf("%d\n",ans[i]);
    ;
}

//快速米
ll qpow(ll x,ll y,ll p) { // x^y mod p
    ll ret=;
    while(y) {
        )ret = ret * x % p;
        x=x*x%p;
        y>>=;
    }
    return ret;
}

//图上dfs
]={};
;
];
struct edge
{
    int to;
    ;
}bian[];
void add(int a,int b)
{
    cnt++;
    bian[cnt].to=b;
    bian[cnt].nxt=head[a];
    head[a]=cnt;
}
void dfs(int x)
{
    printf("%d\n",x);
    vis[x]=;
    ;i=bian[i].nxt)
    {
        if(!vis[bian[i].to]) dfs(bian[i].to);
    }
}
dfs();

//最小环
#include<bits/stdc++.h>
#define v (ti[x])
#define ll long long
using namespace std;
<<);;
];
],DEP[];
inline void dfs(int x,int steps) {
    ) {
        printf("%d\n",ans);
        exit();
    }
    ass++;
    DEP[x]=steps;
    vis[x]=;
    );//有环了
    );
    DEP[x]=;
}
int main() {
    scanf("%d",&n);
    ; i<=n; ++i) {
        scanf("%d",&ti[i]);
    }
    ; i<=n; ++i) {
        );
    }
    printf("%d\n",ans);
    ;
}

//堆优化dij
#include<cstdio>
#include<queue>
#include<cstring>
#define inf (0x3f3f3f3f)
struct node {
    int cur,x;
    bool operator<(const node& b) const  {
        return this->x>b.x;
    }
};
struct edge {
    int v,w,pre;
} e[];
std::priority_queue<node> Q;
];
],cnt;
];
void adde(int u,int v,int w) {
    e[++cnt]=(edge) {v,w,head[u]},head[u]=cnt;
    e[++cnt]=(edge) {u,w,head[v]},head[v]=cnt;
}
int dij(int s,int t) {
    memset(dis,0x3f,sizeof dis);
    dis[s]=;
    inQ[s]=;
    Q.push((node) {s,});
    while(!Q.empty()) {
        node me=Q.top();
        Q.pop();
        inQ[me.cur]=;
        if(me.x==inf) continue;
        for(int i=head[me.cur]; i; i=e[i].pre) {
            int v=e[i].v;
            if(dis[v]>dis[me.cur]+e[i].w) {
                dis[v]=dis[me.cur]+e[i].w;
                if(!inQ[v]) {
                    inQ[v]=;
                    Q.push((node) {
                        v,dis[v]
                    });
                }
            }
        }
    }
    :dis[t];
}

int main() {
    int num,u,v,w,s,t;
    scanf("%d",&num);
    while(num--) {
        scanf("%d%d%d",&u,&v,&w);
        adde(u,v,w);
    }
    scanf("%d%d",&s,&t);
    printf("%d\n",dij(s,t));
    ;
}