数据结构&算法模板汇总

  1 #include <cstdio>
  2 #include <iostream>
  3 #include <algorithm>
  4 #include <queue>
  5 #include <cstring>
  6 #define lowbit(x) (x&(-x)) 
  7 using namespace std;
  8 typedef long long ll;
  9 typedef double db;
 10 const ll eps=1e-8,N=200010;
 11 ll n,m,x,y,z,a[N],sz=0,head[N],F=0,f[N],fa[N];
 12 char opt[6];
 13 ll read(){
 14     ll x=0,f=1;char ch=getchar();
 15     for (;ch<'0'||ch>'9';ch=getchar()) if (ch=='-') f=-1;
 16     for (;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
 17     return x*f;
 18 }
 19 bool dbcmp(db x){
 20     return x<-eps?-1:x>eps?1:0;
 21 }
 22 struct Mat{
 23     ll s[2][2];
 24     ll* operator [](ll x){
 25         return s[x];
 26     }
 27     friend Mat operator *(Mat a,Mat b){
 28         Mat s={0,0,0,0};
 29         for (ll i=0;i<2;i++)
 30             for (ll j=0;j<2;j++)
 31                 for (ll k=0;k<2;k++)
 32                     s[i][j]+=a[i][k]*b[k][j];
 33         return s;
 34     }
 35 };
 36 struct Graph{
 37     struct E{
 38         ll next,fa,to,w;
 39         friend bool operator <(E a,E b){
 40             return a.w<b.w;
 41         }
 42     }e[N];
 43     void insert(ll a,ll b,ll w){
 44         sz++;
 45         e[sz].next=head[a];
 46         head[a]=sz;
 47         e[sz].fa=a;
 48         e[sz].to=b;
 49         e[sz].w=w;
 50     }
 51     ll find(ll x){
 52         if (x==fa[x]) return x;
 53         return fa[x]=find(fa[x]);
 54     }
 55     void dijkstra(ll x){
 56         memset(f,0x7f,sizeof(f));
 57         typedef pair<ll,ll> P;
 58         priority_queue<P,vector<P>,greater<P> > que;
 59         que.push(P(0,x));f[x]=0;
 60         while(!que.empty()){
 61             ll x=que.top().second;que.pop();
 62             for (ll i=head[x];i;i=e[i].next){
 63                 if (f[e[i].to]>f[x]+e[i].w){
 64                     f[e[i].to]=f[x]+e[i].w;
 65                     que.push(P(f[e[i].to],e[i].to));
 66                 }
 67             }
 68         }
 69     }
 70     ll kruskal(){
 71         ll s=0;
 72         for (ll i=1;i<=n;i++) fa[i]=i;
 73         sort(e+1,e+sz+1);
 74         for (ll i=1;i<=sz;i++){
 75             ll a=find(e[i].fa),b=find(e[i].to);
 76             if (a!=b){
 77                 fa[a]=b;
 78                 s+=e[i].w;
 79             }
 80         }
 81         return s;
 82     }
 83 }; 
 84 struct FTree{
 85     ll t[N];
 86     void add(ll x,ll v){
 87         for (ll i=x;i<=n;i+=lowbit(i)) t[i]+=v;
 88     }
 89     ll query(ll x){
 90         ll s=0;
 91         for (ll i=x;i>=1;i-=lowbit(i)) s+=t[i]; 
 92         return s;
 93     }
 94 };
 95 struct SumSTree{
 96     struct P{
 97         ll l,r,v,tag;
 98     }t[4*N];
 99     ll build(ll x,ll l,ll r){
100         t[x].l=l,t[x].r=r,t[x].tag=0;
101         if (l==r) return t[x].v=a[l];
102         ll mid=(l+r)/2;
103         return t[x].v=build(x*2,l,mid)+build(x*2+1,mid+1,r);
104     }
105     void pushdown(ll x){
106         if (!t[x].tag) return;
107         t[x*2].v+=(t[x*2].r-t[x*2].l+1)*t[x].tag;
108         t[x*2+1].v+=(t[x*2+1].r-t[x*2+1].l+1)*t[x].tag;
109         t[x*2].tag+=t[x].tag;
110         t[x*2+1].tag+=t[x].tag;
111         t[x].tag=0;
112     }
113     void add(ll x,ll l,ll r,ll v){
114         t[x].v+=(r-l+1)*v;
115         if (l==t[x].l&&r==t[x].r){t[x].tag+=v;return;}
116         pushdown(x);
117         ll mid=(t[x].l+t[x].r)/2;
118         if (r<=mid) add(x*2,l,r,v);
119         else if (l>=mid+1) add(x*2+1,l,r,v);
120         else add(x*2,l,mid,v),add(x*2+1,mid+1,r,v);
121     }
122     ll query(ll x,ll l,ll r){
123         if (l==t[x].l&&r==t[x].r) return t[x].v;
124         pushdown(x);
125         ll mid=(t[x].l+t[x].r)/2;
126         if (r<=mid) return query(x*2,l,r);
127         else if (l>=mid+1) return query(x*2+1,l,r);
128         else return query(x*2,l,mid)+query(x*2+1,mid+1,r);
129     }
130 };
131 struct MaxSTree{
132     struct P{
133         ll l,r,v,tag;
134     }t[4*N];
135     ll build(ll x,ll l,ll r){
136         t[x].l=l,t[x].r=r,t[x].tag=0;
137         if (l==r) return t[x].v=a[l];
138         ll mid=(l+r)/2;
139         return t[x].v=max(build(x*2,l,mid),build(x*2+1,mid+1,r));
140     }
141     void pushdown(ll x){
142         if (!t[x].tag) return;
143         t[x*2].v+=t[x].tag;
144         t[x*2+1].v+=t[x].tag;
145         t[x*2].tag+=t[x].tag;
146         t[x*2+1].tag+=t[x].tag;
147         t[x].tag=0;
148     }
149     ll add(ll x,ll l,ll r,ll v){
150         if (l==t[x].l&&r==t[x].r){t[x].tag+=v;return t[x].v+=v;}
151         pushdown(x);
152         ll mid=(t[x].l+t[x].r)/2;
153         if (r<=mid) return t[x].v=max(t[x*2+1].v,add(x*2,l,r,v));
154         else if (l>=mid+1) return t[x].v=max(t[x*2].v,add(x*2+1,l,r,v));
155         else return t[x].v=max(add(x*2,l,mid,v),add(x*2+1,mid+1,r,v));
156     }
157     ll query(ll x,ll l,ll r){
158         if (l==t[x].l&&r==t[x].r) return t[x].v;
159         pushdown(x);
160         ll mid=(t[x].l+t[x].r)/2;
161         if (r<=mid) return query(x*2,l,r);
162         else if (l>=mid+1) return query(x*2+1,l,r);
163         else return max(query(x*2,l,mid),query(x*2+1,mid+1,r));
164     }
165 };
166 struct KDTree{
167     struct P{
168         ll d[2],mx[2],mn[2],v,l,r,sum;
169         ll& operator [](ll x){
170             return d[x];
171         }
172         friend bool operator <(P a,P b){
173             return a[F]<b[F]; 
174         } 
175     }t[N];
176     void update(ll x){
177         ll l=t[x].l,r=t[x].r;
178         for (ll i=0;i<2;i++){
179             t[x].mn[i]=t[x].mx[i]=t[x][i];
180             if (l) t[x].mn[i]=min(t[x].mn[i],t[l].mn[i]),t[x].mx[i]=max(t[x].mx[i],t[l].mx[i]);
181             if (r) t[x].mn[i]=min(t[x].mn[i],t[r].mn[i]),t[x].mx[i]=max(t[x].mx[i],t[r].mx[i]);
182         }
183         t[x].sum=t[x].v+t[l].sum+t[r].sum;
184     }
185     ll build(ll l,ll r){
186         ll mid=(l+r)/2;
187         nth_element(t+l,t+mid,t+r+1);
188         F=!F;
189         if (l<mid) t[mid].l=build(l,mid-1);
190         if (r>mid) t[mid].r=build(mid+1,r);
191         update(mid);
192         return mid;
193     }
194 };
195 int main(){
196 }

 计算几何

 1 #include <cstdio>
 2 #include <iostream>
 3 #include <algorithm>
 4 #include <cmath>
 5 using namespace std;
 6 typedef double db;
 7 const int N=10010;
 8 int n;
 9 struct P{
10     db x,y;
11 }p[N],sta[N];
12 db direct(P a,P b,P c){//cbbc aaaa xyxy l<0 r>0
13     return (c.x-a.x)*(b.y-a.y)-(b.x-a.x)*(c.y-a.y);
14 }
15 bool cmp(P a,P b){//a<b l:b
16     return direct(p[1],a,b)<0;
17 }
18 db graham(){
19     db s=0;int k=1,top=2;
20     for (int i=1;i<=n;i++) if ((p[i].y>p[k].y)||(p[i].y==p[k].y&&p[i].x<p[k].x)) k=i;
21     swap(p[1],p[k]);
22     sort(p+2,p+n+1,cmp);
23     sta[1]=p[1],sta[2]=p[2];
24     for (int i=3;i<=n;i++){
25         while(top>=2&&direct(sta[top-1],sta[top],p[i])>0) top--;
26         sta[++top]=p[i];
27     }
28     sta[++top]=p[1];
29     for (int i=1;i<top;i++) s+=hypot(sta[i].x-sta[i+1].x,sta[i].y-sta[i+1].y);
30     return s;
31 }
32 bool intersect(P a1,P a2,P b1,P b2){
33     return
34     min(a1.x,a2.x)<=max(b1.x,b2.x)&&
35     min(b1.x,b2.x)<=max(a1.x,a2.x)&&
36     min(a1.y,a2.y)<=max(b1.y,b2.y)&&
37     min(b1.y,b2.y)<=max(a1.y,a2.y)&&
38     direct(a1,a2,b1)*direct(a1,a2,b2)<=0&&
39     direct(b1,b2,a1)*direct(b1,b2,a2)<=0;
40 }
41 int main(){
42     scanf("%d",&n);
43     for (int i=1;i<=n;i++) scanf("%lf %lf",&p[i].x,&p[i].y);
44     printf("%.2lf",graham()); 
45 }

 

转载于:https://www.cnblogs.com/algonote/p/7802077.html