可持久化：支持查询历史版本和在历史版本上修改

可持久化数组

主席树做即可。

【模板】可持久化数组（可持久化线段树/平衡树）

可持久化并查集

可持久化并查集

主席树做即可。

要按秩合并。（路径压缩每次建logn条链，会卡爆空间MLE）

主席树节点，维护father（是一个真实下标），维护dep（集合的最大深度），

一个关键函数是query，找到代表实际位置为pos的节点的编号

对于一个版本，

合并：先找到这个两个位置的集合的根节点。

不在同一个集合里的话，就合并。

合并的时候，新建一条链，并且更新father，dep还是原来节点的dep

如果和连向的father的dep相同的话，那就把father的点的dep++，象征这个新连上的集合深度是最深深度。

（++deep的时候，可以不建立新节点。因为只是影响一些按秩合并效率，但是基本没有影响）

（upda：2019.3.5 不会影响的。因为是对新节点的deep++，和之前版本没有任何关系）

查询：直接查询即可。

【模板】可持久化并查集

  1. #include<bits/stdc++.h>
  2. #define reg register int
  3. #define il inline
  4. #define numb (ch^'0')
  5. #define mid ((l+r)>>1)
  6. using namespace std;
  7. typedef long long ll;
  8. il void rd(int &x){
  9.     char ch;x=;bool fl=false;
  10.     while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
  11.     for(x=numb;isdigit(ch=getchar());x=x*+numb);
  12.     (fl==true)&&(x=-x);
  13. }
  14. namespace Miracle{
  15. const int N=1e5+;
  16. struct node{
  17.     int ls,rs;
  18.     int fa,dep;
  19. }t[N*];
  20. int tot;
  21. int n,m;
  22. int las;
  23. int rt[*N];
  24. void build(int &x,int l,int r){
  25.     x=++tot;
  26.     if(l==r) {
  27.         t[x].fa=l,t[x].dep=;
  28.         return ;
  29.     }
  30.     build(t[x].ls,l,mid);
  31.     build(t[x].rs,mid+,r);
  32. }
  33. int query(int x,int l,int r,int to){
  34.     if(l==r) return x;
  35.     if(to<=mid) return query(t[x].ls,l,mid,to);
  36.     else return query(t[x].rs,mid+,r,to);
  37. }
  38. void merge(int &x,int y,int l,int r,int to,int ff){
  39.     x=++tot;
  40.     t[x].ls=t[y].ls;t[x].rs=t[y].rs;
  41.     if(l==r) {
  42.         t[x].fa=ff,t[x].dep=t[y].dep;return;
  43.     }
  44.     if(to<=mid) merge(t[x].ls,t[y].ls,l,mid,to,ff);
  45.     else merge(t[x].rs,t[y].rs,mid+,r,to,ff);
  46. }
  47. int find(int o,int to){
  48. //    cout<<" o "<<o<<" to "<<to<<endl;
  49.     int now=query(rt[o],,n,to);
  50.     if(t[now].fa==to) return now;
  51.     return find(o,t[now].fa);
  52. }
  53. int main(){
  54.     scanf("%d%d",&n,&m);
  55.     build(rt[],,n);
  56. //    cout<<" tot tot tot "<<tot<<endl;
  57. //        for(reg i=1;i<=tot;++i){
  58. //            cout<<i<<" : "<<t[i].fa<<" "<<t[i].dep<<endl;
  59. //        }
  60.     int op,k,x,y;las=;
  61.     int o=;
  62.     while(m--){
  63.         rd(op);
  64.         if(op==){
  65.             ++o;
  66.             rt[o]=rt[las];
  67.             rd(x);rd(y);
  68.             x=find(las,x);
  69.             y=find(las,y);
  70.             if(t[x].fa!=t[y].fa){
  71.                 if(t[x].dep>t[y].dep) swap(x,y);
  72.                 merge(rt[o],rt[las],,n,t[x].fa,t[y].fa);
  73.                 if(t[x].dep==t[y].dep) {
  74.                 //    cout<<" dep equal "<<t[y].fa<<endl;
  75.                     int lp=query(rt[o],,n,t[y].fa);
  76.                 //    cout<<" lplplp "<<lp<<endl;
  77.                     t[lp].dep++;
  78.                 }
  79.             }
  80.             las=o;
  81.         }else if(op==){
  82.             ++o;
  83.             rd(k);
  84.             rt[o]=rt[k];
  85.             las=k;
  86.         }else{
  87.             ++o;
  88.             //cout<<" las "<<las<<endl;
  89.             rt[o]=rt[las];
  90.             rd(x);rd(y);
  91.             //cout<<" x "<<" y "<<x<<" "<<y<<endl;
  92.             x=find(las,x);
  93.             y=find(las,y);
  94.             //cout<<" xx "<<" yy "<<x<<" "<<y<<endl;
  95.             if(t[x].fa==t[y].fa){
  96.                 puts("");
  97.             }else puts("");
  98.             las=o;
  99.         }
  100. //        cout<<" tot tot tot "<<tot<<endl;
  101. //        for(reg i=1;i<=tot;++i){
  102. //            cout<<i<<" : "<<t[i].fa<<" "<<t[i].dep<<endl;
  103. //        }
  104.     }
  105.     return ;
  106. }
  107.  
  108. }
  109. int main(){
  110.     Miracle::main();
  111.     return ;
  112. }
  113.  
  114. /*
  115.    Author: *Miracle*
  116.    Date: 2018/11/23 7:48:57
  117. */

可持久化并查集

不能在历史版本上更改的可持久化并查集。（也就是，历史版本形成的树是一条链）

（可持久化并茶几O(logn)： （NOI2018D1T1） 每个点记录每时每刻在哪个集合里 用vector记录pair 合并的时候，启发式合并，然后暴力修改 最多O(n)个集合，每个集合记录点权最大值 查询的时候 二分找到这个时间段 查询集合点权最大值即可 ）

可以做到：空间O(nlogn)时间O(nlogn)

%%ImmortalCO

可持久化平衡树：

1.还是主席树做即可。

权值暴力开到-1e9~1e9（我脑残了一下，还加了偏移量。。。）因为动态开点。。空间限制1GB

然后做就好了。

注意前驱后继的写法；

  1. #include<bits/stdc++.h>
  2. #define reg register int
  3. #define il inline
  4. #define mid (((ll)l+r)>>1)
  5. #define numb (ch^'0')
  6. using namespace std;
  7. typedef long long ll;
  8. il void rd(int &x){
  9.     char ch;x=;bool fl=false;
  10.     while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
  11.     for(x=numb;isdigit(ch=getchar());x=x*+numb);
  12.     (fl==true)&&(x=-x);
  13. }
  14. namespace Miracle{
  15. const int N=5e5+;
  16. const int U=2e9+;
  17. const int P=1e9+;
  18. const int inf=;
  19. int n;
  20. struct node{
  21.     int ls,rs,sz;
  22. }t[*N];
  23. int rt[N];
  24. int tot;
  25. void pushup(int x){
  26.     t[x].sz=t[t[x].ls].sz+t[t[x].rs].sz;
  27. }
  28. void ins(int &x,int y,int l,int r,int to){
  29.     //
  30.     x=++tot;
  31.     t[x].ls=t[y].ls,t[x].rs=t[y].rs;
  32.     t[x].sz=t[y].sz+;
  33.     if(l==r) return;
  34.     if(to<=mid) ins(t[x].ls,t[y].ls,l,mid,to);
  35.     else ins(t[x].rs,t[y].rs,mid+,r,to);
  36. }
  37. void dele(int &x,int y,int l,int r,int to){
  38. //    cout<<" deleting "<<to<<endl;
  39.     x=++tot;
  40.     t[x].ls=t[y].ls,t[x].rs=t[y].rs;
  41.     t[x].sz=t[y].sz;
  42.     if(l==r){
  43.         if(t[x].sz>=) t[x].sz--;
  44.         return;
  45.     }
  46.     if(to<=mid) dele(t[x].ls,t[y].ls,l,mid,to);
  47.     else dele(t[x].rs,t[y].rs,mid+,r,to);
  48.     pushup(x);
  49. }
  50. int rk(int x,int l,int r,int c){
  51.     if(l==r){
  52.         return (l<c)*t[x].sz;
  53.     }
  54.     if(c<=mid) return rk(t[x].ls,l,mid,c);
  55.     else return t[t[x].ls].sz+rk(t[x].rs,mid+,r,c);
  56. }
  57. int kth(int x,int l,int r,int k){
  58.     //cout<<l<<" "<<r<<" "<<mid<<" kkk "<<k<<" "<<t[x].sz<<endl;
  59.     if(l==r)return l;
  60.     int d=k-t[t[x].ls].sz;
  61.     if(d<=) return kth(t[x].ls,l,mid,k);
  62.     else return kth(t[x].rs,mid+,r,d);
  63. }
  64. int pre(int x,int l,int r,int c){
  65.     if(l>=c||t[x].sz==) return -inf;
  66.     else if(l==r) return l;
  67.     else{
  68.         int ret=pre(t[x].rs,mid+,r,c);
  69.         if(ret!=-inf) return ret;
  70.         return pre(t[x].ls,l,mid,c);
  71.     }
  72. }
  73. int bac(int x,int l,int r,int c){
  74.     //cout<<l<<" "<<r<<" "<<" : "<<t[x].sz<<endl;
  75.     if(r<=c||t[x].sz==) return inf;
  76.     else if(l==r) return l;
  77.     else{
  78.         int ret=bac(t[x].ls,l,mid,c);
  79.         if(ret!=inf) return ret;
  80.         return bac(t[x].rs,mid+,r,c);
  81.     }
  82. }
  83. int main(){
  84.     scanf("%d",&n);
  85.     int st,op,x;
  86.     int o=;
  87.     while(n--){
  88.         rd(st),rd(op);rd(x);
  89.         x+=P;
  90.         ++o;
  91.         rt[o]=rt[st];
  92.         switch(op){
  93.             case :ins(rt[o],rt[st],,U,x);break;
  94.             case :dele(rt[o],rt[st],,U,x);break;
  95.             case :printf("%d\n",rk(rt[o],,U,x)+);break;
  96.             case :{
  97.                 int tmp=kth(rt[o],,U,x-P);
  98.                 //cout<<" tmp "<<tmp<<" "<<tmp-1e9<<" "<<tmp-1e9-1<<endl;
  99.                 printf("%d\n",tmp-P);
  100.                 break;
  101.             }
  102.             case :{
  103.                 int tmp=pre(rt[o],,U,x);
  104.                 if(tmp>=&&tmp<=U){
  105.                     printf("%d\n",tmp-P);
  106.                 }
  107.                 else printf("%d\n",tmp);//not find
  108.                 break;
  109.             }
  110.             case :{
  111.                 int tmp=bac(rt[o],,U,x);
  112.                 if(tmp>=&&tmp<=U){
  113.                     printf("%d\n",tmp-P);
  114.                 }
  115.                 else printf("%d\n",tmp);//not find
  116.                 break;
  117.             }
  118.         }
  119.         //cout<<" num "<<o<<" : "<<" tot "<<tot<<" sz "<<rt[o]<<" "<<t[rt[o]].sz<<endl;
  120.     }
  121.     return ;
  122. }
  123.  
  124. }
  125. int main(){
  126.     Miracle::main();
  127.     return ;
  128. }
  129.  
  130. /*
  131.    Author: *Miracle*
  132.    Date: 2018/11/23 9:19:03
  133. */

可持久化平衡树

2.fhq-Treap？

留坑

[学习笔记]FHQ-Treap及其可持久化

例题：bzoj3946: 无聊的游戏

可持久化0/1Trie

其实就类似于主席树。（哪里都是主席树啊。。。）

维护一个序列前缀的信息。

每次加入一个点，在前一个的基础上，加入的是一个log(val)的链。

额外维护一个sz，表示，前i个位置，走到这个位置，往下还有多少个数。（就类似于主席树）

然后，给一个x，如果要找区间最大异或值，直接sz差分，判断有无，然后贪心走即可。

例题：模板：最大异或和

变一下形，就可以当“给一个x，找区间一个值异或，使得值最大”

  1. #include<bits/stdc++.h>
  2. #define reg register int
  3. #define il inline
  4. #define numb (ch^'0')
  5. using namespace std;
  6. typedef long long ll;
  7. il void rd(int &x){
  8.     char ch;x=;bool fl=false;
  9.     while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
  10.     for(x=numb;isdigit(ch=getchar());x=x*+numb);
  11.     (fl==true)&&(x=-x);
  12. }
  13. namespace Miracle{
  14. const int N=+;
  15. const int U=;
  16. int n,m;
  17. struct trie{
  18.     int ch[];
  19.     int sz;
  20. }t[*N];
  21. int tot;
  22. int s;
  23. int rt[N+N];
  24. void ins(int id,int v){
  25.     rt[id]=++tot;
  26.     int x=rt[id],y=rt[id-];
  27.     for(reg i=U;i>=;--i){
  28.         int c=(v>>i)&;
  29.         t[x].ch[!c]=t[y].ch[!c];
  30.         t[x].ch[c]=++tot;
  31.         x=t[x].ch[c];
  32.         y=t[y].ch[c];
  33.         t[x].sz=t[y].sz+;
  34.     }
  35. }
  36. int query(int l,int r,int v){
  37.     int y=l->=?rt[l-]:rt[],x=rt[r];
  38.     int ret=;
  39.     for(reg i=U;i>=;--i){
  40.         int c=(v>>i)&;
  41.         int d=t[t[x].ch[!c]].sz-t[t[y].ch[!c]].sz;
  42.         if(d){
  43.             ret+=(<<i);
  44.             x=t[x].ch[!c];y=t[y].ch[!c];
  45.         }
  46.         else{
  47.             x=t[x].ch[c];y=t[y].ch[c];
  48.         }
  49.     }
  50.     //cout<<l<<" "<<r<<" "<<x<<endl;
  51.     if(l==) ret=max(ret,v);
  52.     return ret;
  53. }
  54. int main(){
  55.     scanf("%d%d",&n,&m);
  56.     int x;
  57.     for(reg i=;i<=n;++i){
  58.         rd(x),s^=x,ins(i,s);
  59.     }
  60.     char ch[];int l,r;
  61.     int now=n;
  62.     while(m--){
  63.         scanf("%s",ch+);
  64.         //cout<<"ss "<<s<<endl;
  65.         switch(ch[]){
  66.             case 'A':rd(x);s^=x;ins(++now,s);break;
  67.             case 'Q':{
  68.                 rd(l);rd(r);rd(x);
  69.                 --l,--r;
  70.                 x=s^x;
  71.                 printf("%d\n",query(l,r,x));
  72.                 break;
  73.             }
  74.         }
  75.         //cout<<" mmm "<<m<<endl;
  76.     }
  77.     return ;
  78. }
  79.  
  80. }
  81. int main(){
  82.     Miracle::main();
  83.     return ;
  84. }
  85.  
  86. /*
  87.    Author: *Miracle*
  88.    Date: 2018/11/23 14:22:23
  89. */

最大异或和

[TJOI2018]异或

维护两个可持久化Trie，一个dfn序，处理子树。一个维护到树根的信息。

子树，dfn序直接查询

路径，拆成x到lca，y到lca分别差分查询。

注意数组大小，根节点还有2*N个空间。。。。。

31*N*2+2*N

  1. #include<bits/stdc++.h>
  2. #define reg register int
  3. #define il inline
  4. #define numb (ch^'0')
  5. using namespace std;
  6. typedef long long ll;
  7. il void rd(int &x){
  8.     char ch;x=;bool fl=false;
  9.     while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
  10.     for(x=numb;isdigit(ch=getchar());x=x*+numb);
  11.     (fl==true)&&(x=-x);
  12. }
  13. namespace Miracle{
  14. const int N=+;
  15. struct trie{
  16.     int ch[];
  17.     int sz;
  18. }t[*N*+*N];
  19. int tot;
  20. int df,dfn[N],fdfn[N],dfn2[N];
  21. int fa[N][];
  22. int dep[N];
  23. int a[N];
  24. int n,m;
  25. struct node{
  26.     int nxt,to;
  27. }e[*N];
  28. int hd[N],cnt;
  29. void add(int x,int y){
  30.     e[++cnt].nxt=hd[x];
  31.     e[cnt].to=y;
  32.     hd[x]=cnt;
  33. }
  34. int rt1[N];
  35. int lca(int x,int y){
  36.     if(dep[x]<dep[y]) swap(x,y);
  37.     for(reg j=;j>=;--j){
  38.         if(dep[fa[x][j]]>=dep[y]) x=fa[x][j];
  39.     }
  40.     if(x==y) return x;
  41.     for(reg j=;j>=;--j){
  42.         if(fa[x][j]!=fa[y][j]) x=fa[x][j],y=fa[y][j];
  43.     }
  44.     return fa[x][];
  45. }
  46. void ins1(int x,int y,int v){
  47.     rt1[x]=++tot;
  48.     x=rt1[x];
  49.     for(reg i=;i>=;--i){
  50.         int c=(v>>i)&;
  51.         t[x].ch[!c]=t[y].ch[!c];
  52.         t[x].ch[c]=++tot;
  53.         x=t[x].ch[c];
  54.         y=t[y].ch[c];
  55.         t[x].sz=t[y].sz+;
  56.     }
  57. }
  58. void dfs(int x,int d){
  59.     dep[x]=d;
  60.     dfn[x]=++df;fdfn[df]=x;
  61.     ins1(x,rt1[fa[x][]],a[x]);
  62.     for(reg i=hd[x];i;i=e[i].nxt){
  63.         int y=e[i].to;
  64.         if(y==fa[x][]) continue;
  65.         fa[y][]=x;
  66.         dfs(y,d+);
  67.     }
  68.     dfn2[x]=df;
  69. }
  70. int query1(int y,int x,int v){
  71.     x=rt1[x];y=rt1[y];
  72.     int ret=;
  73.     for(reg i=;i>=;--i){
  74.         int c=(v>>i)&;
  75.         int d=t[t[x].ch[!c]].sz-t[t[y].ch[!c]].sz;
  76.         if(d){
  77.             ret+=(<<i);
  78.             x=t[x].ch[!c];y=t[y].ch[!c];
  79.         }
  80.         else {
  81.             x=t[x].ch[c];y=t[y].ch[c];
  82.         }
  83.     }
  84.     return ret;
  85. }
  86. int rt2[N];
  87. void ins2(int x,int v){
  88.     int y=rt2[x-];
  89.     rt2[x]=++tot;
  90.     x=rt2[x];
  91.     for(reg i=;i>=;--i){
  92.         int c=(v>>i)&;
  93.         t[x].ch[!c]=t[y].ch[!c];
  94.         t[x].ch[c]=++tot;
  95.         x=t[x].ch[c];
  96.         y=t[y].ch[c];
  97.         t[x].sz=t[y].sz+;
  98.     }
  99. }
  100. int query2(int y,int x,int v){
  101.     x=rt2[x];y=rt2[y];
  102.     int ret=;
  103.     for(reg i=;i>=;--i){
  104.         int c=(v>>i)&;
  105.         int d=t[t[x].ch[!c]].sz-t[t[y].ch[!c]].sz;
  106.         if(d){
  107.             ret+=(<<i);
  108.             x=t[x].ch[!c];y=t[y].ch[!c];
  109.         }
  110.         else {
  111.             x=t[x].ch[c];y=t[y].ch[c];
  112.         }
  113.     }
  114.     return ret;
  115. }
  116. int main(){
  117.     scanf("%d%d",&n,&m);
  118.     for(reg i=;i<=n;++i){
  119.         rd(a[i]);
  120.     }
  121.     int x,y;
  122.     for(reg i=;i<=n-;++i){
  123.         rd(x);rd(y);add(x,y);add(y,x);
  124.     }
  125.     dep[]=-;
  126.     dfs(,);
  127.     for(reg j=;j<=;++j){
  128.         for(reg i=;i<=n;++i){
  129.             fa[i][j]=fa[fa[i][j-]][j-];
  130.         }
  131.     }
  132.  
  133.     for(reg i=;i<=n;++i){
  134.         ins2(i,a[fdfn[i]]);
  135.     }
  136.     int op;
  137.     int z;
  138.     while(m--){
  139.         scanf("%d",&op);
  140.         if(op==){
  141.             rd(x);rd(y);
  142.             printf("%d\n",query2(dfn[x]-,dfn2[x],y));
  143.         }
  144.         else{
  145.             rd(x);rd(y);rd(z);
  146.             int anc=lca(x,y);
  147.             printf("%d\n",max(query1(fa[anc][],x,z),query1(fa[anc][],y,z)));
  148.         }
  149.     }
  150.     return ;
  151. }
  152.  
  153. }
  154. int main(){
  155.     Miracle::main();
  156.     return ;
  157. }
  158.  
  159. /*
  160.    Author: *Miracle*
  161.    Date: 2018/11/23 16:08:01
  162. */

异或

可持久化用途

可持久化目的主要就是充分利用不会动的信息，减少时空的浪费

1.历史值查询：模板，以及可持久化trie和主席树的差分

2.路径压缩，任意字符集AC自动机

3.当做标记：bzoj3946: 无聊的游戏

[学习笔记]可持久化数据结构——数组、并查集、平衡树、Trie树的更多相关文章

  1. POJ2513 【并查集+欧拉路径+trie树】

    题目链接:http://poj.org/problem?id=2513 Colored Sticks Time Limit: 5000MS   Memory Limit: 128000K Total ...

  2. [学习笔记]我们追过的神奇异或（Trie树系列）

    引言 刚学了\(Trie\)树,写篇博客巩固一下. 题目 首先安利一发\(Trie\)树模板 1.Phone List 2.The XOR largest pair 3.The xor-longest ...

  3. UVALive - 5031 Graph and Queries (并查集+平衡树/线段树)

    给定一个图,支持三种操作: 1.删除一条边 2.查询与x结点相连的第k大的结点 3.修改x结点的权值 解法:离线倒序操作,平衡树or线段树维护连通块中的所有结点信息,加个合并操作就行了. 感觉线段树要 ...

  4. matlab学习笔记(一）单元数组

    matlab学习笔记(一)单元数组 1.floor(x) :取最小的整数 floor(3.18)=3,floor(3.98)=3 ceil(x)  :取最大的整数 ceil(3.18)=4,ceil( ...

  5. python3.4学习笔记(十一) 列表、数组实例

    python3.4学习笔记(十一) 列表.数组实例 #python列表,数组类型要相同,python不需要指定数据类型,可以把各种类型打包进去#python列表可以包含整数,浮点数,字符串,对象#创建 ...

  6. Java学习笔记之---方法和数组

    Java学习笔记之---方法与数组 (一)方法 (1)什么是方法? 方法是解决一类问题的步骤的有序组合 方法包含于类或对象中 方法在程序中被创建,在其他地方被引用 (2)方法的优点 使程序变得更简短而 ...

  7. JavaSE学习笔记（7）---数组

    JavaSE学习笔记(7)---数组 1.什么是数组 数组是相同类型数据的有序集合.数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成.其中,每一个数据称作一个元素,每个元素可以通过一个 ...

  8. 「学习笔记」字符串基础：Hash，KMP与Trie

    「学习笔记」字符串基础:Hash,KMP与Trie 点击查看目录 目录 「学习笔记」字符串基础:Hash,KMP与Trie Hash 算法 代码 KMP 算法 前置知识:\(\text{Border} ...

  9. [BZOJ3038]上帝造题的七分钟2 树状数组+并查集

    考试的时候用了两个树状数组去优化,暴力修改,树状数组维护修改后区间差值还有最终求和,最后骗了40分.. 这道题有好多种做法,求和好说,最主要的是开方.这道题过的关键就是掌握一点:在数据范围内,最多开方 ...

随机推荐

  1. scrapy框架爬取笔趣阁完整版

    继续上一篇,这一次的爬取了小说内容 pipelines.py import csv class ScrapytestPipeline(object): # 爬虫文件中提取数据的方法每yield一次it ...

  2. ts包、表、子表、section的关系

    我们经常接触到创建 DEMUX,注册 Filter 过滤数据, 通过回调过滤出 section 数据,然后我们对 section 数据做具体的解析或者其他操作. 我们这里说的 section 就是段的 ...

  3. 【Java】关于Spring框架的总结 （一）

    本文总结一些关于Spring框架的理解,注意点及基础操作.如果有不对的地方,欢迎批评和建议.大家一起努力吧! Spring 框架简介 Spring 是一个开源框架,是为了解决企业应用程序开发复杂性而创 ...

  4. Moodle 3.4中添加小组、大组、群

    Moodle在高中应用时经常要用到年级.班级和小组,我们可以用群.大组.小组来代替. 小组设置:网站首页-->现有课程-->右上角的设置按钮-->更多-->用户-->小组 ...

  5. Uber CEO博鳌论坛采访：看好中国市场共享经济的发展模式

    滴快车单单2.5倍,注册地址:http://www.udache.com/ 如何注册Uber司机(全国版最新最详细注册流程)/月入2万/不用抢单:http://www.cnblogs.com/mfry ...

  6. c/c++容器操作

    C++中的容器大致可以分为两个大类:顺序容器和关联容器.顺序容器中包含有顺序容器适配器. 顺序容器:将单一类型元素聚集起来成为容器,然后根据位置来存储和访问这些元素.主要有vector.list.de ...

  7. Hibernate-ORM:01.Hibernate恍如隔世般初见

    ------------吾亦无他,唯手熟尔,谦卑若愚,好学若饥------------- 对于学过ORM框架的朋友来说,上手HibernateORM来说,既熟悉有有一点陌生,熟悉无非是灵魂相通,陌生的 ...

  8. LinqToExcel使用简介一

             最近才看到原来也可以用Linq来访问Excel,功能还挺强大的.要使用这个功能,首先得下载一个LinqToExcel的相关文件,然后就可以调用相关的方法.         使用前面介 ...

  9. spring 读取properties文件--通过注解方式

    问题: 需要通过properties读取页面的所需楼盘的名称.为了以后便于修改. 解决: 可以通过spring的 PropertiesFactoryBean 读取properties属性,就不需要自己 ...

  10. nginx启动和配置

    1.命令行参数 -c </path/to/config> 为 Nginx 指定一个配置文件,来代替缺省的.路径应为绝对路径 -t 不运行,而仅仅测试配置文件.nginx 将检查配置文件的语 ...