堆（优先级队列）

priority_queue<int,vector<int>>//大根堆
priority_queue<int,vector<int>,greater<int>>//小根堆

用来维护最值

 

 

 

ST表用来静态查找区间的值（可以是最大值，最小值，以及满足区间分两半求值不影响结果的值）

 

dp[i][j]表示从区间i开始长度为2^j的数组值

 1 int dp[N][35];
 2 int main(){
 3     int n;
 4     cin>>n;
 5     for(int i=0;i<n;++i){
 6         cin>>dp[i][0];
 7     }
 8     for(int j=1;j<=log2(n);++j){
 9         for(int i=0;i+(1<<j)<=n;++i){
10             dp[i][j]=max(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
11         }
12     }
13     int l,r;
14     cin>>l>>r;
15     int j=log2(r-l+1);
16     cout<<max(ma[l][j],ma[r-(1<<j)+1][j]);
17     return 0;
18 }//ST表 ，静态求区间值

二维ST表 f[i][j][ii][jj]表示从i，j点开始长度为2^ii,2^jj的区间值

 1 int f[N][N][40][40];
 2 int main(){
 3     int n,m;
 4     cin>>n>>m;
 5     for(int i=1;i<=n;++i){
 6         for(int j=1;j<=m;++j){
 7             cin>>f[i][j][0][0];
 8         }
 9     }
10     for(int l=0;l<=log2(m);++l){
11         for(int k=0;k<=log2(n);++k){
12             if(l+k==0)
13             continue;
14             for(int i=1;i+(1<<k)<=n;++i){
15                 for(int j=1;j+(1<<l)<=m;++j){
16                     if(l!=0)
17                         f[i][j][l][k]=max(f[i][j][l-1][k],f[i+(1<<(l-1))][j][l-1][k]);
18                     else
19                         f[i][j][l][k]=max(f[i][j][l][k-1],f[i][j+(1<<(k-1))][l][k-1]);
20                 }
21             }
22         }
23     }
24     int x1,x2,y1,y2;
25     cin>>x1>>y1>>x2>>y2;
26     int j=log2(x2-x1+1);
27     int k=log2(y2-y1+1);
28     int ans=max(f[x1][y1][j][k],f[x1][y2-(1<<k)+1][j][k]);
29     ans=max(ans,f[x2-(1<<j)+1][y1][j][k]);
30     ans=max(ans,f[x2-(1<<j)+1][y2-(1<<k)+1][j][k]);
31     cout<<ans<<endl;
32     return 0;
33 }//二维ST表

bellman求最短路（一般可以判断图是否有负环，循环超过n-1次就有负环）

 1 int first[N];
 2 struct Edge{
 3     int to;
 4     int next;
 5     int w;
 6 }edge[N];
 7 int cnt=0;
 8 void add(int u,int v,int w){
 9     edge[++cnt].to=v;
10     edge[cnt].w=w;
11     edge[cnt].next=first[u];
12     first[u]=cnt;
13 }
14 int dis[N];
15 int main(){
16     ioscin;
17     int n,m,s;
18     cin>>n>>m>>s;
19     memset(dis,127,sizeof(dis));
20     dis[s]=0;
21     while(m--){
22         int u,v,w;
23         cin>>u>>v>>w;
24         add(u,v,w);
25     }
26     while(1){
27         int num=0;
28         for(int i=1;i<=n;++i){
29             if(dis[i]<(1<<30)){
30                 for(int j=first[i];j!=0;j=edge[j].next){
31                         if(dis[edge[j].to]>dis[i]+edge[j].w){
32                             num++;
33                             dis[edge[j].to]=dis[i]+edge[j].w;
34                         }
35                 }
36             }
37         }
38         if(num==0){
39             break;
40         }
41     }
42     for(int i=1;i<=n;++i){
43         cout<<dis[i]<<' ';
44     }
45     return 0;
46 }//bellman求最短路

drjkstra求最短路，一般用优化后的版本，没优化很慢

 1 int first[N];
 2 struct Edge{
 3     int to;
 4     int next;
 5     int w;
 6 }edge[N];
 7 int cnt=0;
 8 void add(int u,int v,int w){
 9     edge[++cnt].to=v;
10     edge[cnt].w=w;
11     edge[cnt].next=first[u];
12     first[u]=cnt;
13 }
14 int dis[N];
15 int n,m,s;
16 set<pii>q;//set替代堆
17 void dijkstra(int s){
18     memset(dis,127,sizeof(dis));20     dis[s]=0;
21     for(int i=1;i<=n;++i){
22         q.insert(mp(dis[i],i));
23     }
24     while(!q.empty()){
25         int x=q.begin()->second;
26         if(dis[x]>(1<<30)){
27             break;
28         }
29         q.erase(q.begin());
30         for(int i=first[x];i!=0;i=edge[i].next){
31             if(dis[edge[i].to]>dis[x]+edge[i].w){
32                 q.erase(mp(dis[edge[i].to],edge[i].to));
33                 dis[edge[i].to]=dis[x]+edge[i].w;
34                 q.insert(mp(dis[edge[i].to],edge[i].to));
35             }
36         }
37     }
38 }
39 int main(){
40     cin>>n>>m>>s;
41     while(m--){
42         int u,v,w;
43         cin>>u>>v>>w;
44         add(u,v,w);
45     }
46     dijkstra(s);
47     for(int i=1;i<=n;++i){
48         cout<<dis[i]<<' ';
49     }
50     return 0;
51 }//dijkstra堆优化