最近公共祖先问题（LCA）是求一颗树上的某两点距离他们最近的公共祖先节点，由于树的特性，树上两点之间路径是唯一的，所以对于很多处理关于树的路径问题的时候为了得知树两点的间的路径，LCA是几乎最有效的解法。

首先是LCA的倍增算法。算法主体是依靠首先对整个树的预处理DFS，用来预处理出每个点的直接父节点，同时可以处理出每个点的深度和与根节点的距离，然后利用类似RMQ的思想处理出每个点的 2 的幂次的祖先节点，这就可以用 nlogn 的时间完成整个预处理的工作。然后每一次求两个点的LCA时只要对两个点深度经行考察，将深度深的那个利用倍增先爬到和浅的同一深度，然后一起一步一步爬直到爬到相同节点，就是LCA了。

具体模板是从鹏神的模板小改来的。

注释方便理解版：

  1.  #include<stdio.h>
  2.  #include<string.h>
  3.  #include<algorithm>
  4.  using namespace std;
  5.  
  6.  const int maxn=1e5+;
  7.  const int maxm=1e5+;
  8.  const int maxl=;        //总点数的log范围，一般会开稍大一点
  9.  
  10.  int fa[maxl][maxn],dep[maxn],dis[maxn];        //fa[i][j]是j点向上（不包括自己）2**i 层的父节点，dep是某个点的深度（根节点深度为0），dis是节点到根节点的距离
  11.  int head[maxn],point[maxm],nxt[maxm],val[maxm],size;
  12.  int n;
  13.  
  14.  void init(){
  15.      size=;
  16.      memset(head,-,sizeof(head));
  17.  }
  18.  
  19.  void add(int a,int b,int v){
  20.      point[size]=b;
  21.      val[size]=v;
  22.      nxt[size]=head[a];
  23.      head[a]=size++;
  24.      point[size]=a;
  25.      val[size]=v;
  26.      nxt[size]=head[b];
  27.      head[b]=size++;
  28.  }
  29.  
  30.  void Dfs(int s,int pre,int d){        //传入当前节点标号，父亲节点标号，以及当前深度
  31.      fa[][s]=pre;                    //当前节点的上一层父节点是传入的父节点标号
  32.      dep[s]=d;
  33.      for(int i=head[s];~i;i=nxt[i]){
  34.          int j=point[i];
  35.          if(j==pre)continue;
  36.          dis[j]=dis[s]+val[i];
  37.          Dfs(j,s,d+);
  38.      }
  39.  }
  40.  
  41.  void Pre(){
  42.      dis[]=;
  43.      Dfs(,-,);
  44.      for(int k=;k+<maxl;++k){        //类似RMQ的做法，处理出点向上2的幂次的祖先。
  45.          for(int v=;v<=n;++v){
  46.              if(fa[k][v]<)fa[k+][v]=-;
  47.              else fa[k+][v]=fa[k][fa[k][v]];    //处理出两倍距离的祖先
  48.          }
  49.      }
  50.  }
  51.  
  52.  int Lca(int u,int v){
  53.      if(dep[u]>dep[v])swap(u,v);        //定u为靠近根的点
  54.      for(int k=maxl-;k>=;--k){
  55.          if((dep[v]-dep[u])&(<<k))    //根据层数差值的二进制向上找v的父亲
  56.              v=fa[k][v];
  57.      }
  58.      if(u==v)return u;                //u为v的根
  59.      for(int k=maxl-;k>=;--k){
  60.          if(fa[k][u]!=fa[k][v]){        //保持在相等层数，同时上爬寻找相同父节点
  61.              u=fa[k][u];
  62.              v=fa[k][v];
  63.          }
  64.      }
  65.      return fa[][u];                //u离lca只差一步
  66.  }

木有注释版：

  1.  #include<stdio.h>
  2.  #include<string.h>
  3.  #include<algorithm>
  4.  using namespace std;
  5.  
  6.  const int maxn=1e5+;
  7.  const int maxm=1e5+;
  8.  const int maxl=;
  9.  
  10.  int fa[maxl][maxn],dep[maxn],dis[maxn];
  11.  int head[maxn],point[maxm],nxt[maxm],val[maxm],size;
  12.  int n;
  13.  
  14.  void init(){
  15.      size=;
  16.      memset(head,-,sizeof(head));
  17.  }
  18.  
  19.  void add(int a,int b,int v){
  20.      point[size]=b;
  21.      val[size]=v;
  22.      nxt[size]=head[a];
  23.      head[a]=size++;
  24.      point[size]=a;
  25.      val[size]=v;
  26.      nxt[size]=head[b];
  27.      head[b]=size++;
  28.  }
  29.  
  30.  void Dfs(int s,int pre,int d){
  31.      fa[][s]=pre;
  32.      dep[s]=d;
  33.      for(int i=head[s];~i;i=nxt[i]){
  34.          int j=point[i];
  35.          if(j==pre)continue;
  36.          dis[j]=dis[s]+val[i];
  37.          Dfs(j,s,d+);
  38.      }
  39.  }
  40.  
  41.  void Pre(){
  42.      dis[]=;
  43.      Dfs(,-,);
  44.      for(int k=;k+<maxl;++k){
  45.          for(int v=;v<=n;++v){
  46.              if(fa[k][v]<)fa[k+][v]=-;
  47.              else fa[k+][v]=fa[k][fa[k][v]];
  48.          }
  49.      }
  50.  }
  51.  
  52.  int Lca(int u,int v){
  53.      if(dep[u]>dep[v])swap(u,v);
  54.      for(int k=maxl-;k>=;--k){
  55.          if((dep[v]-dep[u])&(<<k))
  56.              v=fa[k][v];
  57.      }
  58.      if(u==v)return u;
  59.      for(int k=maxl-;k>=;--k){
  60.          if(fa[k][u]!=fa[k][v]){
  61.              u=fa[k][u];
  62.              v=fa[k][v];
  63.          }
  64.      }
  65.      return fa[][u];
  66.  }

静态树上路径求最小值：LCA倍增

  1.  #include<bits/stdc++.h>
  2.  using namespace std;
  3.  
  4.  const int maxn=1e6+;
  5.  const int maxm=2e6+;
  6.  const int maxl=;
  7.  const int INF = 0x3f3f3f3f;
  8.  
  9.  int fa[maxl][maxn],dep[maxn],dis[maxl][maxn];
  10.  int head[maxn],point[maxm],nxt[maxm],val[maxm],size;
  11.  int vis[maxn];
  12.  int n,q,tmp=INF;
  13.  
  14.  void init(){
  15.      size=;
  16.      memset(head,-,sizeof(head));
  17.      memset(vis,,sizeof(vis));
  18.  }
  19.  
  20.  void add(int a,int b){
  21.      point[size]=b;
  22.      nxt[size]=head[a];
  23.      head[a]=size++;
  24.      point[size]=a;
  25.      nxt[size]=head[b];
  26.      head[b]=size++;
  27.  }
  28.  
  29.  void Dfs(int s,int pre,int d){
  30.      fa[][s]=pre;
  31.      dis[][s]=s;
  32.      dep[s]=d;
  33.      for(int i=head[s];~i;i=nxt[i]){
  34.          int j=point[i];
  35.          if(j==pre)continue;
  36.          Dfs(j,s,d+);
  37.      }
  38.  }
  39.  
  40.  void Pre(){
  41.      Dfs(,-,);
  42.      for(int k=;k+<maxl;++k){
  43.          for(int v=;v<=n;++v){
  44.              if(fa[k][v]<)fa[k+][v]=-;
  45.              else fa[k+][v]=fa[k][fa[k][v]];
  46.              if(fa[k][v]<)dis[k+][v]=dis[k][v];
  47.              else dis[k+][v]=min(dis[k][v],dis[k][fa[k][v]]);
  48.          }
  49.      }
  50.  }
  51.  
  52.  int Lca(int u,int v){
  53.      tmp = min( u, v );
  54.      if(dep[u]>dep[v])swap(u,v);
  55.      for(int k=maxl-;k>=;--k){
  56.          if((dep[v]-dep[u])&(<<k)){
  57.              tmp = min( tmp, dis[k][v]);
  58.              v=fa[k][v];
  59.          }
  60.      }
  61.      tmp = min( tmp,v );
  62.      if(u==v)return u;
  63.      for(int k=maxl-;k>=;--k){
  64.          if(fa[k][u]!=fa[k][v]){
  65.              tmp=min(tmp,min(dis[k][u],dis[k][v]));
  66.              u=fa[k][u],v=fa[k][v];
  67.          }
  68.      }
  69.      tmp = min( tmp, min(u,v));
  70.      tmp = min( tmp, fa[][u]);
  71.      return fa[][u];
  72.  }
  73.  //tmp即为u、v路径上的最小值

离线Tarjan的做法主要是防止由于每个点对可能被询问多次，导致每次求都需要 logn 的时间，会超时，所以离线来一并处理所有的询问。

Tarjan的做法是通过递归到最底层，然后开始不断递归回去合并并查集，这样就能够在访问完每个点之后赋值它有关切另一个点已经被访问过的询问。

同样是鹏神的模板修改成自己的代码风格后的。

注释版：

  1.  #include<stdio.h>        //差不多要这些头文件
  2.  #include<string.h>
  3.  #include<vector>
  4.  #include<algorithm>
  5.  using namespace std;
  6.  
  7.  const int maxn=1e5+;    //点数、边数、询问数
  8.  const int maxm=2e5+;
  9.  const int maxq=1e4+;
  10.  
  11.  int n;
  12.  int head[maxn],nxt[maxm],point[maxm],val[maxm],size;
  13.  int vis[maxn],fa[maxn],dep[maxn],dis[maxn];
  14.  int ans[maxq];
  15.  vector<pair<int,int> >v[maxn];    //记录询问、问题编号
  16.  
  17.  void init(){
  18.      memset(head,-,sizeof(head));
  19.      size=;
  20.      memset(vis,,sizeof(vis));
  21.      for(int i=;i<=n;++i){
  22.          v[i].clear();
  23.          fa[i]=i;
  24.      }
  25.      dis[]=dep[]=;
  26.  }
  27.  
  28.  void add(int a,int b,int v){
  29.      point[size]=b;
  30.      val[size]=v;
  31.      nxt[size]=head[a];
  32.      head[a]=size++;
  33.      point[size]=a;
  34.      val[size]=v;
  35.      nxt[size]=head[b];
  36.      head[b]=size++;
  37.  }
  38.  
  39.  int find(int x){
  40.      return x==fa[x]?x:fa[x]=find(fa[x]);
  41.  }
  42.  
  43.  void Tarjan(int s,int pre){
  44.      for(int i=head[s];~i;i=nxt[i]){
  45.          int j=point[i];
  46.          if(j!=pre){
  47.              dis[j]=dis[s]+val[i];
  48.              dep[j]=dep[s]+;
  49.              Tarjan(j,s);                //这里Tarjan的DPS操作必须在并查集合并之前，这样才能保证求lca的时候lca是每一小部分合并时的祖先节点，如果顺序交换，那么所有的查询都会得到 1 节点，就是错误的
  50.              int x=find(j),y=find(s);
  51.              if(x!=y)fa[x]=y;
  52.          }
  53.      }
  54.      vis[s]=;
  55.      for(int i=;i<v[s].size();++i){
  56.          int j=v[s][i].first;
  57.          if(vis[j]){
  58.              int lca=find(j);
  59.              int id=v[s][i].second;
  60.              ans[id]=lca;            //这里视题目要求给答案赋值
  61.          //    ans[id]=dep[s]+dep[j]-2*dep[lca];
  62.          //    ans[id]=dis[s]+dis[j]-2*dis[lca];
  63.          }
  64.      }
  65.  }
  66.  
  67.  for(int i=;i<=k;++i){        //主函数中的主要部分
  68.      int a,b;
  69.      scanf("%d%d",&a,&b);
  70.      v[a].push_back(make_pair(b,i));        //加问题的时候两个点都要加一次
  71.      v[b].push_back(make_pair(a,i));
  72.  }
  73.  Tarjan(,);

木有注释版：

  1.  #include<stdio.h>
  2.  #include<string.h>
  3.  #include<vector>
  4.  #include<algorithm>
  5.  using namespace std;
  6.  
  7.  const int maxn=1e5+;
  8.  const int maxm=2e5+;
  9.  const int maxq=1e4+;
  10.  
  11.  int n;
  12.  int head[maxn],nxt[maxm],point[maxm],val[maxm],size;
  13.  int vis[maxn],fa[maxn],dep[maxn],dis[maxn];
  14.  int ans[maxq];
  15.  vector<pair<int,int> >v[maxn];
  16.  
  17.  void init(){
  18.      memset(head,-,sizeof(head));
  19.      size=;
  20.      memset(vis,,sizeof(vis));
  21.      for(int i=;i<=n;++i){
  22.          v[i].clear();
  23.          fa[i]=i;
  24.      }
  25.      dis[]=dep[]=;
  26.  }
  27.  
  28.  void add(int a,int b,int v){
  29.      point[size]=b;
  30.      val[size]=v;
  31.      nxt[size]=head[a];
  32.      head[a]=size++;
  33.      point[size]=a;
  34.      val[size]=v;
  35.      nxt[size]=head[b];
  36.      head[b]=size++;
  37.  }
  38.  
  39.  int find(int x){
  40.      return x==fa[x]?x:fa[x]=find(fa[x]);
  41.  }
  42.  
  43.  void Tarjan(int s,int pre){
  44.      for(int i=head[s];~i;i=nxt[i]){
  45.          int j=point[i];
  46.          if(j!=pre){
  47.              dis[j]=dis[s]+val[i];
  48.              dep[j]=dep[s]+;
  49.              Tarjan(j,s);
  50.              int x=find(j),y=find(s);
  51.              if(x!=y)fa[x]=y;
  52.          }
  53.      }
  54.      vis[s]=;
  55.      for(int i=;i<v[s].size();++i){
  56.          int j=v[s][i].first;
  57.          if(vis[j]){
  58.              int lca=find(j);
  59.              int id=v[s][i].second;
  60.              ans[id]=lca;
  61.          //    ans[id]=dep[s]+dep[j]-2*dep[lca];
  62.          //    ans[id]=dis[s]+dis[j]-2*dis[lca];
  63.          }
  64.      }
  65.  }
  66.  
  67.  for(int i=;i<=k;++i){
  68.      int a,b;
  69.      scanf("%d%d",&a,&b);
  70.      v[a].push_back(make_pair(b,i));
  71.      v[b].push_back(make_pair(a,i));
  72.  }
  73.  Tarjan(,);

另外，现在又有LCA用dfs序+RMQ的做法，可以实现O(nlogn)预处理，O(1)查询的LCA，基本可以完全替代倍增LCA和TarjanLCA，但是树上路径长度和树上路径最小值无法用这个来做。

  1.  #include <bits/stdc++.h>
  2.  using namespace std;
  3.  
  4.  const int maxn = 2e5+;
  5.  const int maxl = ;
  6.  int vis[maxn],dep[maxn],dp[maxn][maxl];
  7.  
  8.  int head[maxn],in[maxn],id[maxn];
  9.  int point[maxn],nxt[maxn],sz;
  10.  int val[maxn];
  11.  int fa[maxl][maxn];        //fa[i][j]是j点向上（不包括自己）2**i 层的父节点，dep是某个点的深度（根节点深度为0），dis是节点到根节点的距离
  12.  int n;
  13.  
  14.  void init(){
  15.      sz = ;
  16.      memset(head,-,sizeof(head));
  17.      memset(fa,-,sizeof(fa));
  18.  }
  19.  
  20.  void Pre(){
  21.      for(int k=;k+<maxl;++k){        //类似RMQ的做法，处理出点向上2的幂次的祖先。
  22.          for(int v=;v<=n;++v){
  23.              if(fa[k][v]<)fa[k+][v]=-;
  24.              else fa[k+][v]=fa[k][fa[k][v]];    //处理出两倍距离的祖先
  25.          }
  26.      }
  27.  }
  28.  
  29.  void dfs(int u,int p,int d,int&k){
  30.      fa[][u]=p;                    //当前节点的上一层父节点是传入的父节点标号
  31.      vis[k] = u;
  32.      id[u] = k;
  33.      dep[k++]=d;
  34.      for(int i = head[u];~i;i=nxt[i]){
  35.          int v = point[i];
  36.          if(v == p)continue;
  37.          dfs(v,u,d+,k);
  38.          vis[k] = u;
  39.          dep[k++]=d;
  40.      }
  41.  }
  42.  
  43.  void RMQ(int root){
  44.      int k = ;
  45.      dfs(root,-,,k);
  46.      int m = k;
  47.      int e= (int)(log2(m+1.0));
  48.      for(int i =  ; i < m ; ++ i)dp[i][]=i;
  49.      for(int j =  ; j <= e ; ++ j){
  50.          for(int i =  ; i + ( << j ) -  < m ; ++ i){
  51.              int N = i + (<<(j-));
  52.              if(dep[dp[i][j-]] < dep[dp[N][j-]]){
  53.                  dp[i][j] = dp[i][j-];
  54.              }
  55.              else dp[i][j] = dp[N][j-];
  56.          }
  57.      }
  58.  }
  59.  
  60.  void add(int a,int b){
  61.      point[sz] = b;
  62.      nxt[sz] = head[a];
  63.      head[a] = sz++;
  64.  }
  65.  
  66.  int LCA(int u,int v){
  67.      int left = min(id[u],id[v]),right = max(id[u],id[v]);
  68.      int k = (int)(log2(right- left+1.0));
  69.      int pos,N = right - (<<k)+;
  70.      if(dep[dp[left][k]] < dep[dp[N][k]])pos = dp[left][k];
  71.      else pos = dp[N][k];
  72.      return vis[pos];
  73.  }
  74.  
  75.  int q;
  76.  
  77.  inline int get(int a,int k){
  78.      int res = a;
  79.      for(int i =  ; (1ll << i ) <= k ; ++ i){
  80.          if(k&(1ll<<i)){
  81.              res = fa[i][res];
  82.          }
  83.      }
  84.      return res;
  85.  }
  86.  
  87.  void run(){
  88.      while(q--){
  89.          int a,b,k;
  90.          scanf("%d%d%d",&a,&b,&k);
  91.          int lca = LCA(a,b);
  92.          int num = dep[id[a]] - dep[id[lca]] + dep[id[b]] - dep[id[lca]] + ;
  93.          int up = (num - )%k;
  94.          int ans = val[a];
  95.  //        printf("a : %d\n",a);
  96.          while(dep[id[a]] - dep[id[lca]] >= k){
  97.              int Id = get(a,k);
  98.              ans ^= val[Id];
  99.          //    printf("a : %d\n",Id);
  100.              a = Id;
  101.          }
  102.          if(dep[id[b]] - dep[id[lca]] > up){
  103.          //    printf("up: %d\n",up);
  104.                 if(up == )ans^= val[b];
  105.              b = get(b,up);
  106.              while(dep[id[b]] - dep[id[lca]] >k ){
  107.                  int Id = get(b,k);
  108.                  ans ^= val[Id];
  109.                  b = Id;
  110.              }
  111.          }
  112.          printf("%d\n",ans);
  113.      }
  114.  }
  115.  
  116.  int main(){
  117.      while(scanf("%d%d",&n,&q)!=EOF){
  118.  
  119.          init();
  120.          for(int i = ; i < n; ++ i){
  121.              int a,b;
  122.              scanf("%d%d",&a,&b);
  123.              add(a,b);
  124.              add(b,a);
  125.          }
  126.          for(int i = ;i <= n ; ++ i)scanf("%d",&val[i]);
  127.          RMQ();
  128.          Pre();
  129.          run();
  130.  
  131.      }
  132.      return ;
  133.  }

图论--最近公共祖先问题（LCA）模板的更多相关文章

  1. 洛谷P3379 【模板】最近公共祖先（LCA）

    P3379 [模板]最近公共祖先(LCA) 152通过 532提交 题目提供者HansBug 标签 难度普及+/提高 提交  讨论  题解 最新讨论 为什么还是超时.... 倍增怎么70!!题解好像有 ...

  2. P3379 【模板】最近公共祖先（LCA）

    P3379 [模板]最近公共祖先(LCA) 题目描述 如题,给定一棵有根多叉树,请求出指定两个点直接最近的公共祖先. 输入输出格式 输入格式: 第一行包含三个正整数N.M.S,分别表示树的结点个数.询 ...

  3. 洛谷P3379 【模板】最近公共祖先（LCA）（dfs序+倍增）

    P3379 [模板]最近公共祖先(LCA) 题目描述 如题,给定一棵有根多叉树,请求出指定两个点直接最近的公共祖先. 输入输出格式 输入格式: 第一行包含三个正整数N.M.S,分别表示树的结点个数.询 ...

  4. 「LuoguP3379」 【模板】最近公共祖先（LCA）

    题目描述 如题,给定一棵有根多叉树,请求出指定两个点直接最近的公共祖先. 输入输出格式 输入格式: 第一行包含三个正整数N.M.S,分别表示树的结点个数.询问的个数和树根结点的序号. 接下来N-1行每 ...

  5. 洛谷——P3379 【模板】最近公共祖先（LCA）

    P3379 [模板]最近公共祖先(LCA) 题目描述 如题,给定一棵有根多叉树,请求出指定两个点直接最近的公共祖先. 输入输出格式 输入格式: 第一行包含三个正整数N.M.S,分别表示树的结点个数.询 ...

  6. LCA 最近公共祖先 (笔记、模板)

    求lca的方法大体有三种: 1.dfs+RMQ(线段树 ST表什么的) 在线 2.倍增 在线 3.tarjan 离线 ps:离线:所有查询全输入后一次解决 在线:有一个查询输出一次 以下模板题为 洛谷 ...

  7. luogo p3379 【模板】最近公共祖先（LCA）

    [模板]最近公共祖先(LCA) 题意 给一个树,然后多次询问(a,b)的LCA 模板(主要参考一些大佬的模板) #include<bits/stdc++.h> //自己的2点:树的邻接链表 ...

  8. 【原创】洛谷 LUOGU P3379 【模板】最近公共祖先（LCA） -> 倍增

    P3379 [模板]最近公共祖先(LCA) 题目描述 如题,给定一棵有根多叉树,请求出指定两个点直接最近的公共祖先. 输入输出格式 输入格式: 第一行包含三个正整数N.M.S,分别表示树的结点个数.询 ...

  9. P3379 【模板】最近公共祖先（LCA）（欧拉序+rmq）

    P3379 [模板]最近公共祖先(LCA) 用欧拉序$+rmq$维护的$lca$可以做到$O(nlogn)$预处理,$O(1)$查询 从这里剻个图 #include<iostream> # ...

  10. 最近公共祖先（LCA）学习笔记 | P3379 【模板】最近公共祖先（LCA）题解

    研究了LCA,写篇笔记记录一下. 讲解使用例题 P3379 [模板]最近公共祖先(LCA). 什么是LCA 最近公共祖先简称 LCA(Lowest Common Ancestor).两个节点的最近公共 ...

随机推荐

  1. 《BI项目笔记》创建多维数据集Cube（2）

    本节建立: 历年的初烟水分均值变化分析Cube:区域维度:地州,专县时间维度:年等级维度:大等级,小等级指标:水分均值 数据源视图: 数据处理: ) ) DELETE FROM T_QualMoist ...

  2. golang csv问题

    go语言自带的有csv文件读取模块,看起来好像不错,今天玩玩,也算是系统学习go语言的一部分--^_^ 一.写csv文件 函数: func NewWriter(w io.Writer) *Writer ...

  3. javascript事件之：谈谈自定义事件

    对于JavaScript自定义事件,印象最深刻的是用jQuery在做图片懒加载的时候.给需要懒加载的图片定义一个appear事件.当页面图片开始出现时候,触发这个自定义的appear事件(注意,这里只 ...

  4. Deep Learning 6_深度学习UFLDL教程：Softmax Regression_Exercise（斯坦福大学深度学习教程）

    前言 练习内容:Exercise:Softmax Regression.完成MNIST手写数字数据库中手写数字的识别,即:用6万个已标注数据(即:6万张28*28的图像块(patches)),作训练数 ...

  5. USACO2011Brownie Slicing巧克力蛋糕切片

    Description     Bessie烘焙了一块巧克力蛋糕.这块蛋糕是由R*C(1 <= R,C <= 500)个小的巧克力蛋糕组成的. 第i行,第j列的蛋糕有N_ij(1 < ...

  6. t检验

    例子:以往通过大规模调查已知某地新生儿出生体重为3.30kg.从该地难产儿中随机抽取35名新生儿作为研究样本,平均出生体重为3.42kg,标准差为0.40kg. 问该地难产儿出生体重是否与一般新生儿体 ...

  7. 浅谈HTTP协议(上)

    今天讨论一下HTTP协议.一个做前端的,如果连HTTP协议都不了解,那实在是太不合格了. 首先,什么是HTTP?Hyper Text Transfer Protocol(超文本传输协议),用在浏览器和 ...

  8. js+css3文字模糊代码

    在写文字模糊的时候要理清自己的思路,根据以下的步骤来: 对你要模糊的文字进行布局 <body style="background:#ccc;"> <ul clas ...

  9. 关于在biweb 中安装完成后 首页上方报错问题的解决

    在利用biweb进行网站开发的时候 首先得安装biweb    安装就是下一步,,,下一步....下一步   最后就成功了 .但是有种情况我总是竟让遇到,而已有的人安装会遇到 有的人安装就不会遇到,后 ...

  10. iOS开发UI篇—简单的浏览器查看程序

    iOS开发UI篇—简单的浏览器查看程序 一.程序实现要求 1.要求 2. 界面分析 (1) 需要读取或修改属性的控件需要设置属性 序号标签 图片 图片描述 左边按钮 右边按钮 (2) 需要监听响应事件 ...