Something

1 int GCD(int a,int b)
2 {
3     return !b?a:GCD(b,a%b);
4 }

void exgcd(int a,int b,int &x,int &y)
{
    if(b==0)
    {
        x=1,y=0;return;
    }
    exgcd(b,a%b,x,y);
    int t=x;x=y;y=t-a/b*y;
}

1 int GCD(int a,int b)
2 {
3     return !b?a:GCD(b,a%b);
4 }
5 int lcm(int a,int b)
6 {
7     return a*b/GCD(a,b);
8 }

 1 int FastPower(int Tp,int Up,int mod)
 2 {
 3     int r=1,base=Tp;
 4     while(b)
 5     {
 6         if(b&1)
 7             r*=base;
 8         base*=base;
 9         b>>1;
10     }
11     return r;
12 }

 1 int prime[1100000],primesize,phi[11000000];
 2 bool isprime[11000000];
 3 void getlist(int listsize)
 4 {
 5     memset(isprime,1,sizeof(isprime));
 6     isprime[1]=false;
 7     for(int i=2;i<=listsize;i++)
 8     {
 9         if(isprime[i])prime[++primesize]=i;
10          for(int j=1;j<=primesize&&i*prime[j]<=listsize;j++)
11          {
12             isprime[i*prime[j]]=false;
13             if(i%prime[j]==0)break;
14         }
15     }
16 }

 1 int getphi(int x){
 2     int ret=1;
 3     for(int i=1;prime[i]*prime[i]<=x;i++){
 4         if(x%prime[i]==0){
 5             ret*=prime[i]-1;x/=prime[i];
 6             while(x%prime[i]==0) x/=prime[i],ret*=prime[i];
 7         }
 8     }
 9     if(x>1) ret*=x-1;
10     return ret;
11 }

 1 #define N 1000000
 2 struct SPFA
 3 {
 4     queue<int> q;
 5     bool vis[N];
 6     int dis[N];
 7     SPFA()
 8     {
 9         memset(vis,0,sizeof(vis));
10         memset(dis,0,sizeof(dis));
11     }
12     void spfa(int p)
13     {
14         q.push(p);
15         vis[p]=true;
16         while(!q.empty())
17         {
18             int t=q.front();
19             q.pop();
20             vis[t]=false;
21             for(int i=1; i<=n; i++)
22             {
23                 if(dis[i]>dis[t]+map[t][i])
24                 {
25                     dis[i]=dis[t]+map[t][i];
26                     if(!vis[i])
27                         q.push(i);
28                 }
29             }
30         }
31         printf("%d",dis[ep]);
32     }
33 };

 1 struct BIT{
 2     long long c[N];
 3     int n;
 4     BIT()
 5     {
 6         memset(c,0,sizeof(c));
 7         n=0;
 8     }
 9 
10     int lowbit(int x)
11     {
12         return x&(-x);
13     }
14     void modify(int x,long long y)
15     {
16         for(;x<=n;x+=lowbit(x))
17             c[x]+=y;
18     }
19     long long query(int x)
20     {
21         long long ret=0;
22         for(;x;x-=lowbit(x))
23             ret+=c[x];
24         return ret;
25     }
26     long long query(int l,int r)
27     {
28         return query(r)-query(l-1);
29     }
30 };

 1 #define Maxn 1000000
 2 #define Maxm 1000
 3 struct KMP{
 4     int pre[Maxn];
 5     int len1,len2;
 6     int p;
 7 
 8     KMP()
 9     {
10         for(int i=0;i<Maxn;i++)
11             pre[i]=0;
12     }
13 
14     inline void preprocess(char*pattern)
15     {
16         len2=strlen(pattern),p=-1;
17         pre[0]=-1;
18         for(int i=1;i<len2;i++)
19         {
20             while(p!=-1&&pattern[p+1]!=pattern[i])
21                 p=pre[p];
22             p+=(pattern[p+1]==pattern[i]);
23             pre[i]=p;
24         }
25     }
26 
27     inline void kmp(char*original,char*pattern)
28     {
29         len1=strlen(original);
30         p=-1;
31         for(int i=0;i<len1;i++)
32         {
33             while(p!=-1&&original[i]!=pattern[p+1])
34                 p=pre[p];
35             p+=(pattern[p+1]==original[i]);
36             if(p+1==len2)
37                 printf("%d\n",i-len2+2),p=pre[p];
38         }
39         for(int i=0;i<len2;i++)
40             printf("%d ",pre[i]+1);
41     }
42 };

 1 struct SegmentTreeTypeAdd
 2 {
 3     struct node
 4     {
 5         int l,r,w,f;//left,right,weight,flag;
 6         node()
 7         {
 8             l=r=w=f=0;
 9         }
10     } tree[400001];
11     inline void build(int k,int ll,int rr)//建树
12     {
13         //用法：build(节点编号,左孩子,右孩子);
14         //初始化：build(1,1,节点个数);
15         tree[k].l=ll,tree[k].r=rr;
16         if(tree[k].l==tree[k].r)
17         {
18             scanf("%d",&tree[k].w);
19             return;
20         }
21         int m=(ll+rr)/2;
22         build(k*2,ll,m);
23         build(k*2+1,m+1,rr);
24         tree[k].w=tree[k*2].w+tree[k*2+1].w;
25     }
26     inline void down(int k)//标记下传
27     {
28         //用法：down(需要下传标记的根节点);
29         tree[k*2].f+=tree[k].f;
30         tree[k*2+1].f+=tree[k].f;
31         tree[k*2].w+=tree[k].f*(tree[k*2].r-tree[k*2].l+1);
32         tree[k*2+1].w+=tree[k].f*(tree[k*2+1].r-tree[k*2+1].l+1);
33         tree[k].f=0;
34     }
35     inline void ask_point(int k)//单点查询
36     {
37         //用法：ask_point(需要查询的点的编号);
38         if(tree[k].l==tree[k].r)
39         {
40             ans=tree[k].w;
41             return ;
42         }
43         if(tree[k].f) down(k);
44         int m=(tree[k].l+tree[k].r)/2;
45         if(x<=m) ask_point(k*2);
46         else ask_point(k*2+1);
47     }
48     inline void change_point(int k)//单点修改
49     {
50         //用法：change_point(需要修改的点的编号);
51         if(tree[k].l==tree[k].r)
52         {
53             tree[k].w+=y;
54             return;
55         }
56         int m=(tree[k].l+tree[k].r)/2;
57         if(x<=m) change_point(k*2);
58         else change_point(k*2+1);
59         tree[k].w=tree[k*2].w+tree[k*2+1].w;
60     }
61     inline void ask_interval(int k)//区间查询
62     {
63         //用法：ask_iterval(查询起点);
64         if(tree[k].l>=a&&tree[k].r<=b)//a与b为需要查询的区间
65         {
66             ans+=tree[k].w;
67             return;
68         }
69         if(tree[k].f) down(k);
70         int m=(tree[k].l+tree[k].r)/2;
71         if(a<=m) ask_interval(k*2);
72         if(b>m) ask_interval(k*2+1);
73     }
74     inline void change_interval(int k)//区间修改
75     {
76         //用法：change_interval(修改起点);
77         if(tree[k].l>=a&&tree[k].r<=b)//a与b为需要修改的区间
78         {
79             tree[k].w+=(tree[k].r-tree[k].l+1)*y;
80             tree[k].f+=y;
81             return;
82         }
83         if(tree[k].f) down(k);//若有孩子节点，下传标记
84         int m=(tree[k].l+tree[k].r)/2;//二分处理
85         if(a<=m) change_interval(k*2);
86         if(b>m) change_interval(k*2+1);
87         tree[k].w=tree[k*2].w+tree[k*2+1].w;
88     }
89 };

 1 #define N 1000000
 2 struct Graph
 3 {
 4     struct node
 5     {
 6         int next,to,dis;
 7     } edge[N];
 8     int head[N];
 9     void add(int u,int v,int w)
10     {
11         edge[++cnt].next=head[u];
12         edge[cnt].to=v;
13         edge[cnt].dis=w;
14         head[u]=cnt;
15     }
16 };
17 Graph g;
18 struct Dijkstra
19 {
20     struct NODE
21     {
22         int x,y;
23         bool operator < (NODE a)const
24         {
25             return x>a.x;
26         }
27     };
28     priority_queue<NODE>q;
29     int cnt,n,m,s,t,dis[N/2];
30     bool visit[N/2];
31     void dijkstra()
32     {
33         memset(dis,1,sizeof(dis));
34         dis[s]=0;
35         NODE a;
36         a.x=dis[s];
37         a.y=s;
38         q.push(a);
39         while(!q.empty())
40         {
41             NODE a=q.top();
42             q.pop();
43             if(visit[a.x]) continue;
44             int v=a.y;
45             visit[v]=1;
46             for(int i=g.head[v]; i; i=g.edge[i].next)
47             {
48                 if(dis[g.edge[i].to]>g.edge[i].dis+dis[v])
49                 {
50                     dis[g.edge[i].to]=g.edge[i].dis+dis[v];
51                     NODE a;
52                     a.x=dis[g.edge[i].to];
53                     a.y=g.edge[i].to;
54                     q.push(a);
55                 }
56             }
57         }
58         printf("%d",dis[t]);
59     }
60 };

 1 #define N 1000000
 2 struct Graph
 3 {
 4     struct node
 5     {
 6         int next,to,dis;
 7     } edge[N<<1];
 8     int head[N/2];
 9     void add(int u,int v,int w)
10     {
11         edge[++cnt].next=head[u];
12         edge[cnt].to=v;
13         edge[cnt].dis=w;
14         head[u]=cnt;
15     }
16 };

 1 #define maxn 10005
 2 struct UnionFindSet
 3 {
 4     int x,y,v;
 5     int fat[maxn];
 6     UnionFindSet()
 7     {
 8         for(int i=0; i<maxn; i++)
 9             fat[i]=i;
10     }
11     inline int father(int x)
12     {
13         if(fat[x]!=x)
14             fat[x]=father(fat[x]);
15         return fat[x];
16     }
17     inline void unionn(int x,int y)
18     {
19         int fa=father(x);
20         int fb=father(y);
21         if(fa!=fb)
22             fat[fa]=fb;
23     }
24 };
25 struct Edge
26 {
27     int pre,to,w;
28     bool operator < (const Edge &b) const
29     {
30         return this->w < b.w;
31     }
32 };
33 struct Graph
34 {
35     Edge edge[maxn];
36     int cnt=0;
37     inline void AddEdge(int u,int v,int w)
38     {
39         edge[++cnt].pre=u;
40         edge[cnt].to=v;
41         edge[cnt].w=w;
42     }
43 };
44 Graph g;
45 UnionFindSet s;
46 int Kruskal(int EdgeNumber)
47 {
48     sort(g.edge+1,g.edge+1+EdgeNumber);
49     int n=1,ans=0;
50     while(n<EdgeNumber-1)
51     {
52         if(s.father(g.edge[n].pre)!=s.father(g.edge[n].to))
53         {
54             s.unionn(g.edge[n].pre,g.edge[n].to);
55             ans+=g.edge[n].w;
56         }
57         n++;
58     }
59     return ans;
60 }

 1 #define maxn 10005
 2 struct UnionFindSet
 3 {
 4     int x,y,v;
 5     int fat[maxn];
 6     UnionFindSet()
 7     {
 8         for(int i=0; i<maxn; i++)
 9             fat[i]=i;
10     }
11     inline int father(int x)
12     {
13         if(fat[x]!=x)
14             fat[x]=father(fat[x]);
15         return fat[x];
16     }
17     inline void unionn(int x,int y)
18     {
19         int fa=father(x);
20         int fb=father(y);
21         if(fa!=fb)
22             fat[fa]=fb;
23     }
24 };