这个题的搜索可以打到48分……

  1. #include <cstdio>
  2. #include <cstring>
  3. #include <algorithm>
  4. const int N=;
  5. bool must[N],in[N];
  6. int cnt;
  7. int n,a[N][N],q[N],b[N];
  8. inline bool judge(int len,int lim){
  9.   return lim-len>=cnt;
  10. }
  11. inline bool check(int len){
  12.   register int i,j,k,pos,g;
  13.   register bool can;
  14.   for(i=;i<=n;++i){
  15.     can=false;
  16.     for(j=;j<=len;++j){
  17.       if(len-j+>=a[i][]){
  18.         pos=,g=;
  19.         for(k=j;k<=len;++k){
  20.           if(in[q[k]])continue;
  21.           if(q[k]!=a[i][pos+]){g=-;break;}
  22.           b[++pos]=q[k];
  23.           in[q[k]]=true;
  24.         }
  25.         can=g!=-&&pos==a[i][];
  26.         while(pos--)in[b[pos+]]=false;
  27.         if(can)break;
  28.       }
  29.       if(j>=a[i][]){
  30.         pos=,g=;
  31.         for(k=j;k>;--k){
  32.           if(in[q[k]])continue;
  33.           if(q[k]!=a[i][pos+]){g=-;break;}
  34.           b[++pos]=q[k];
  35.           in[q[k]]=true;
  36.         }
  37.         can=g!=-&&pos==a[i][];
  38.         while(pos--)in[b[pos+]]=false;
  39.         if(can)break;
  40.       }
  41.     }
  42.     if(!can)return false;
  43.   }
  44.   return true;
  45. }
  46. inline bool dfs(int pos,int lim){
  47.   if(!judge(pos-,lim))return false;
  48.   if(pos==lim+)return check(pos-);
  49.   register int i;
  50.   register bool keep;
  51.   for(i=;i<=;++i)
  52.     if(i!=q[pos-]){
  53.       q[pos]=i;
  54.       if(must[i]){
  55.         must[i]=false,--cnt;
  56.         keep=true;
  57.       }else keep=false;
  58.       if(dfs(pos+,lim))return true;
  59.       if(keep)must[i]=true,++cnt;
  60.     }
  61.   return false;
  62. }
  63. int main(){
  64.   //freopen("rio.in","r",stdin);
  65.   scanf("%d",&n);
  66.   register int i,j;
  67.   for(i=;i<=n;++i){
  68.     while(true){
  69.       scanf("%d",&j);
  70.       if(!j)break;
  71.       a[i][++a[i][]]=j;
  72.       must[j]=true;
  73.     }
  74.   }
  75.   for(i=;i<=;++i)
  76.     cnt+=must[i];
  77.   for(i=cnt;i<=;++i){
  78.     if(cnt<&&i==)break;
  79.     if(dfs(,i)){
  80.       printf("%d\n",i);
  81.       return ;
  82.     }
  83.   }
  84.   puts("-1");
  85.   return ;
  86. }

Kod

搜索的时候减枝实在是太重要了,其次梦想与搜索之间的平衡也是很重要的,但是一定要合理且适当.
正解很神.
贴一发题解:

还有一位大佬的代码注释也很好:https://loj.ac/submission/66283
我就是看的这两个资料,然后码出来的.(把写法从spfa改成记忆化dfs会快3倍……）
在这里说一下坑吧,就是正着走的状态可以在半截出现,倒着走的状态可以在半截消失.
分享一下代码.
正着走的单向40分:

  1. #include <cstdio>
  2. #include <cstring>
  3. #include <algorithm>
  4. const int N=;
  5. const int F=;
  6. const int Inf=0x3f3f3f3f;
  7. int n,ans,full,bit[N],a[N][N],l[N],b[N];
  8. int f[N][N][F];
  9. bool ex[N][N],can[N][N][N],in[N],fin[N][N][F];
  10. inline bool check(int id,int len,int to){
  11.   register int i,pos=;
  12.   memset(in,,sizeof(in));
  13.   for(i=;i<=len;++i)
  14.     in[a[id][i]]=true;
  15.   for(i=;i<=l[to];++i){
  16.     if(in[a[to][i]])continue;
  17.     b[++pos]=a[to][i];
  18.     in[a[to][i]]=true;
  19.   }
  20.   if(pos!=l[id]-len)return false;
  21.   for(i=len+;i<=l[id];++i)
  22.     if(a[id][i]!=b[i-len])
  23.       return false;
  24.   return true;
  25. }
  26. inline void dfs(int id,int pos,int st){
  27.   //printf("%d %d %d\n",id,pos,st);
  28.   if(fin[id][pos][st]){
  29.     //puts("GG");
  30.     ans=std::min(ans,f[id][pos][st]);
  31.     return;
  32.   }
  33.   register int i;
  34.   for(i=;i<=n;++i)
  35.     if(i!=id&&(bit[i]&st)==)
  36.       if(can[id][pos][i]&&f[i][][st|bit[id]]>f[id][pos][st]){
  37.         f[i][][st|bit[id]]=f[id][pos][st];
  38.         dfs(i,,st|bit[id]);
  39.       }
  40.   if(pos!=l[id]&&f[id][pos+][st]>f[id][pos][st]+){
  41.     f[id][pos+][st]=f[id][pos][st]+;
  42.     dfs(id,pos+,st);
  43.   }
  44. }
  45. int main(){
  46.   //freopen("rio.in","r",stdin);
  47.   scanf("%d",&n);
  48.   full=(<<n)-;
  49.   register int i,j,k;
  50.   for(i=;i<=n;++i){
  51.     bit[i]=<<(i-);
  52.     while(true){
  53.       scanf("%d",&j);
  54.       if(!j)break;
  55.       a[i][++l[i]]=j;
  56.       ex[i][j]=true;
  57.     }
  58.   }
  59.   for(i=;i<=n;++i)
  60.     for(j=;j<=l[i];++j)
  61.       for(k=;k<=n;++k)
  62.         can[i][j][k]=check(i,j,k);
  63.   memset(f,0x3f,sizeof(f));
  64.   ans=Inf;
  65.   for(i=;i<=n;++i)
  66.     fin[i][l[i]][full^bit[i]]=true;
  67.   for(i=;i<=n;++i){
  68.     f[i][][]=;
  69.     dfs(i,,);
  70.   }
  71.   printf("%d\n",ans==Inf?-:ans);
  72.   return ;
  73. }

Kod

倒着走的单向40分:

  1. #include <cstdio>
  2. #include <cstring>
  3. #include <algorithm>
  4. const int N=;
  5. const int F=;
  6. const int Inf=0x3f3f3f3f;
  7. int n,ans,full,bit[N],a[N][N],l[N],b[N];
  8. int f[N][N][F];
  9. bool can[N][N][N],in[N],fin[N][N][F];
  10. inline bool check(int id,int len,int to){
  11.   register int i,pos=;
  12.   memset(in,,sizeof(in));
  13.   for(i=;i<=len;++i)
  14.     in[a[id][i]]=true;
  15.   for(i=;i<=l[to];++i){
  16.     if(in[a[to][i]])continue;
  17.     b[++pos]=a[to][i];
  18.     in[a[to][i]]=true;
  19.   }
  20.   if(pos!=l[id]-len)return false;
  21.   for(i=len+;i<=l[id];++i)
  22.     if(a[id][i]!=b[i-len])
  23.       return false;
  24.   return true;
  25. }
  26. inline void dfs(int id,int pos,int st){
  27.   //printf("%d %d %d\n",id,pos,st);
  28.   if(fin[id][pos][st]){
  29.     //puts("GG");
  30.     ans=std::min(ans,f[id][pos][st]);
  31.     return;
  32.   }
  33.   if(!pos){
  34.     register int i,j;
  35.     for(i=;i<=n;++i)
  36.       if(i!=id&&(bit[i]&st)==)
  37.         for(j=;j<=l[i];++j)
  38.           if(can[i][j][id]&&f[i][j][st|bit[id]]>f[id][pos][st]){
  39.             f[i][j][st|bit[id]]=f[id][pos][st];
  40.             dfs(i,j,st|bit[id]);
  41.           }
  42.   }
  43.   if(pos&&f[id][pos-][st]>f[id][pos][st]+){
  44.     f[id][pos-][st]=f[id][pos][st]+;
  45.     dfs(id,pos-,st);
  46.   }
  47. }
  48. int main(){
  49.   //freopen("rio.in","r",stdin);
  50.   scanf("%d",&n);
  51.   full=(<<n)-;
  52.   register int i,j,k;
  53.   for(i=;i<=n;++i){
  54.     bit[i]=<<(i-);
  55.     while(true){
  56.       scanf("%d",&j);
  57.       if(!j)break;
  58.       a[i][++l[i]]=j;
  59.     }
  60.   }
  61.   for(i=;i<=n;++i)
  62.     for(j=;j<=l[i];++j)
  63.       for(k=;k<=n;++k)
  64.         can[i][j][k]=check(i,j,k);
  65.   memset(f,0x3f,sizeof(f));
  66.   ans=Inf;
  67.   for(i=;i<=n;++i)
  68.     fin[i][][full^bit[i]]=true;
  69.   for(i=;i<=n;++i){
  70.     f[i][l[i]][]=;
  71.     dfs(i,l[i],);
  72.   }
  73.   printf("%d\n",ans==Inf?-:ans);
  74.   return ;
  75. }

Kod

经过我不断修改的清真美丽100分代码:

  1. #include <set>
  2. #include <cstdio>
  3. #include <cstring>
  4. #include <algorithm>
  5. typedef long long LL;
  6. std::set<LL> ext;
  7. const int N=;
  8. const int F=;
  9. const int Inf=0x3f3f3f3f;
  10. int n,full,bit[N],a[N][N],l[N];
  11. int f[N][N][N][N][F];
  12. bool ex[N][N][N],can[N][N][N],in[N],vis[N][N][N][N][F];
  13. inline bool check(int id,int len,int to){
  14.   int i,pos=;
  15.   memcpy(in,ex[id][len],sizeof(in));
  16.   for(i=;i<=l[to];++i){
  17.     if(in[a[to][i]])continue;
  18.     ++pos,in[a[to][i]]=true;
  19.     if(a[to][i]!=a[id][len+pos])
  20.       return false;
  21.   }
  22.   if(pos!=l[id]-len)return false;
  23.   return true;
  24. }
  25. inline void Init(){
  26.   scanf("%d",&n);
  27.   int i,j,k;
  28.   LL key;
  29.   for(i=;i<=n;++i){
  30.     l[i]=,key=;
  31.     memset(ex[i],,sizeof(ex[i]));
  32.     bit[i]=<<(i-),j=;
  33.     while(j){
  34.       scanf("%d",&j);
  35.       key=key*+j;
  36.       a[i][++l[i]]=j;
  37.       for(k=;k<=l[i];++k)
  38.         if(a[i][k])
  39.           ex[i][l[i]][a[i][k]]=true;
  40.     }
  41.     --l[i];
  42.     if(ext.count(key))--i,--n;
  43.     ext.insert(key);
  44.   }
  45.   full=(<<n)-;
  46.   for(i=;i<=n;++i){
  47.     can[][][i]=true;
  48.     for(j=;j<=l[i];++j)
  49.       for(k=;k<=n;++k)
  50.         can[i][j][k]=check(i,j,k);
  51.   }
  52.   memset(f,0x3f,sizeof(f));
  53. }
  54. #define cover(id1,pos1,id2,pos2,st,add) (k=std::min(dfs(id1,pos1,id2,pos2,st)+add,k))
  55. inline int dfs(int id1,int pos1,int id2,int pos2,int st){
  56.   if(st==full&&pos1==l[id1]&&!pos2)return ;
  57.   int i,j,&k=f[id1][pos1][id2][pos2][st];
  58.   if(vis[id1][pos1][id2][pos2][st])return k;
  59.   vis[id1][pos1][id2][pos2][st]=true;
  60.   if(id2&&!pos2){
  61.     for(i=;i<=n;++i)
  62.       if(i!=id1&&!(bit[i]&st))
  63.         for(j=;j<=l[i];++j)
  64.           if(can[i][j][id2])
  65.             cover(id1,pos1,i,j,st|bit[i],);
  66.   }
  67.   for(i=;i<=n;++i)
  68.     if(can[id1][pos1][i]&&!(bit[i]&st))
  69.       cover(i,,id2,pos2,st|bit[i],);
  70.   if(pos1==l[id1]&&!pos2)return k;
  71.   if(pos1!=l[id1]&&(ex[id2][pos2+][a[id1][pos1+]]||!id2))
  72.     cover(id1,pos1+,id2,pos2,st,);
  73.   if(pos2&&(ex[id1][pos1][a[id2][pos2]]||!id1))
  74.     cover(id1,pos1,id2,pos2-,st,);
  75.   if(pos1!=l[id1]&&pos2&&a[id2][pos2]==a[id1][pos1+])
  76.     cover(id1,pos1+,id2,pos2-,st,);
  77.   return k;
  78. }
  79. inline void Work(){
  80.   int i,ans=Inf;
  81.   for(i=;i<=n;++i)
  82.     ans=std::min(dfs(,,i,l[i],bit[i]),ans);
  83.   printf("%d\n",ans==Inf?-:ans);
  84. }
  85. int main(){
  86.   Init(),Work();
  87.   return ;
  88. }

Kod

我第一次A掉的时候写的100分(这个代码又臭又长又屎):

  1. #include <cstdio>
  2. #include <cstring>
  3. #include <algorithm>
  4. const int N=;
  5. const int F=;
  6. const int Inf=0x3f3f3f3f;
  7. int n,ans,full,bit[N],a[N][N],l[N],b[N];
  8. int f[N][N][N][N][F];
  9. bool ex[N][N][N],can[N][N][N],in[N],fin[N][N][N][N][F];
  10. inline bool check(int id,int len,int to){
  11.   register int i,pos=;
  12.   memset(in,,sizeof(in));
  13.   for(i=;i<=len;++i)
  14.     in[a[id][i]]=true;
  15.   for(i=;i<=l[to];++i){
  16.     if(in[a[to][i]])continue;
  17.     b[++pos]=a[to][i];
  18.     in[a[to][i]]=true;
  19.   }
  20.   if(pos!=l[id]-len)return false;
  21.   for(i=len+;i<=l[id];++i)
  22.     if(a[id][i]!=b[i-len])
  23.       return false;
  24.   return true;
  25. }
  26. inline void dfs(int id1,int pos1,int id2,int pos2,int st){
  27.   //printf("%d %d %d %d %d\n",id1,pos1,id2,pos2,st);
  28.   if(fin[id1][pos1][id2][pos2][st]){
  29.     //puts("GG");
  30.     ans=std::min(ans,f[id1][pos1][id2][pos2][st]);
  31.     return;
  32.   }
  33.   if(id2&&!pos2){
  34.     register int i,j;
  35.     for(i=;i<=n;++i)
  36.       if(i!=id1&&i!=id2&&(bit[i]&st)==)
  37.         for(j=;j<=l[i];++j)
  38.           if(can[i][j][id2]&&f[id1][pos1][i][j][st|bit[id2]]>f[id1][pos1][id2][pos2][st]){
  39.             f[id1][pos1][i][j][st|bit[id2]]=f[id1][pos1][id2][pos2][st];
  40.             dfs(id1,pos1,i,j,st|bit[id2]);
  41.           }
  42.     if(id1){
  43.       if(f[id1][pos1][][][st|bit[id2]]>f[id1][pos1][id2][pos2][st]){
  44.         f[id1][pos1][][][st|bit[id2]]=f[id1][pos1][id2][pos2][st];
  45.         dfs(id1,pos1,,,st|bit[id2]);
  46.       }
  47.     }else{
  48.       for(i=;i<=n;++i)
  49.         if(i!=id2&&(bit[i]&st)==&&f[i][][][][st|bit[id2]]>f[id1][pos1][id2][pos2][st]){
  50.           f[i][][][][st|bit[id2]]=f[id1][pos1][id2][pos2][st];
  51.           dfs(i,,,,st|bit[id2]);
  52.         }
  53.     }
  54.   }
  55.   if(id1){
  56.     register int i;
  57.     for(i=;i<=n;++i)
  58.       if(i!=id1&&i!=id2&&(bit[i]&st)==)
  59.         if(can[id1][pos1][i]&&f[i][][id2][pos2][st|bit[id1]]>f[id1][pos1][id2][pos2][st]){
  60.           f[i][][id2][pos2][st|bit[id1]]=f[id1][pos1][id2][pos2][st];
  61.           dfs(i,,id2,pos2,st|bit[id1]);
  62.         }
  63.   }else{
  64.     register int i;
  65.     for(i=;i<=n;++i)
  66.       if(i!=id2&&(bit[i]&st)==&&f[i][][id2][pos2][st]>f[id1][pos1][id2][pos2][st]){
  67.         f[i][][id2][pos2][st]=f[id1][pos1][id2][pos2][st];
  68.         dfs(i,,id2,pos2,st);
  69.       }
  70.   }
  71.   if((id2==||pos2==)&&(id1==||pos1==l[id1]))return;
  72.   if(id1&&pos1!=l[id1]&&(ex[id2][pos2+][a[id1][pos1+]]||!id2)&&f[id1][pos1+][id2][pos2][st]>f[id1][pos1][id2][pos2][st]+){
  73.     f[id1][pos1+][id2][pos2][st]=f[id1][pos1][id2][pos2][st]+;
  74.     dfs(id1,pos1+,id2,pos2,st);
  75.   }
  76.   if(id2&&pos2&&(ex[id1][pos1+][a[id2][pos2]]||!id1)&&f[id1][pos1][id2][pos2-][st]>f[id1][pos1][id2][pos2][st]+){
  77.     f[id1][pos1][id2][pos2-][st]=f[id1][pos1][id2][pos2][st]+;
  78.     dfs(id1,pos1,id2,pos2-,st);
  79.   }
  80.   //printf("<>%d %d %d %d %d\n",id1,pos1,id2,pos2,st);
  81.   if(id1&&id2&&pos2&&pos1!=l[id1]&&a[id2][pos2]==a[id1][pos1+]&&f[id1][pos1+][id2][pos2-][st]>f[id1][pos1][id2][pos2][st]+){
  82.     //puts("OK");
  83.     f[id1][pos1+][id2][pos2-][st]=f[id1][pos1][id2][pos2][st]+;
  84.     dfs(id1,pos1+,id2,pos2-,st);
  85.   }
  86.   //else puts("NO");
  87. }
  88. int main(){
  89.   //freopen("rio.in","r",stdin);
  90.   //freopen("wq.out","w",stdout);
  91.   scanf("%d",&n),full=(<<n)-;
  92.   register int i,j,k;
  93.   for(i=;i<=n;++i){
  94.     bit[i]=<<(i-);
  95.     while(true){
  96.       scanf("%d",&j);
  97.       if(!j)break;
  98.       a[i][++l[i]]=j;
  99.     }
  100.   }
  101.   for(i=;i<=n;++i)
  102.     for(j=;j<=l[i];++j)
  103.       for(k=;k<=n;++k)
  104.         can[i][j][k]=check(i,j,k);
  105.   for(i=;i<=n;++i)
  106.     for(j=;j<=;++j)
  107.       for(k=;k<=j;++k)
  108.         ex[i][j][a[i][k]]=true;
  109.   memset(f,0x3f,sizeof(f));
  110.   ans=Inf;
  111.   for(i=;i<=n;++i){
  112.     for(j=;j<=n;++j){
  113.       if(i==j)continue;
  114.       fin[i][l[i]][j][][full^bit[i]^bit[j]]=true;
  115.       f[i][][j][l[j]][]=;
  116.     }
  117.     fin[i][l[i]][][][full^bit[i]]=true;
  118.     f[i][][][][]=;
  119.     fin[][][i][][full^bit[i]]=true;
  120.     f[][][i][l[i]][]=;
  121.   }
  122.   for(i=;i<=n;++i){
  123.     for(j=;j<=n;++j){
  124.       if(i==j)continue;
  125.       dfs(i,,j,l[j],);
  126.     }
  127.     dfs(i,,,,);
  128.     dfs(,,i,l[i],);
  129.   }
  130.   printf("%d\n",ans==Inf?-:ans);
  131.   return ;
  132. }

Kod

我在这里说一下我对于这道题的解法的理解吧.
看到题解之后,就会发现这道题dp的状态定义很谜.我们先看正着走单向的,我们之所以这么定义,是因为最终方案也一定是这样构成的,这很好理解.再看倒着走的,同样,我们之所以这么定义,也是因为最终方案也一定是这样构成的.那么我们再看双向的状态,思考一下,发现也是这样的.那么我们这么转移就一定没有问题.而这神奇的状态设计从哪里来呢.我觉得,就是抓出题目给出的操作的性质——“远观不如近看”,让“近看”去满足“远观”,用“远观”去匹配“近看”,再加上增量构造的思路,就迸发出了这道题的状态以及转移.
现在以我的水平,我对于这道题的理解大概也就这么多,也许以后会有更好的理解把.利用状态压缩,以及对于特殊的问题,设计合理的状态,大概就是我从这道题里学到的宝贵的东西,对于设计状态,我还是摸不着头脑的.

LOJ #6037.「雅礼集训 2017 Day4」猜数列 状压dp的更多相关文章

  1. loj 6037 「雅礼集训 2017 Day4」猜数列 - 动态规划

    题目传送门 传送门 题目大意 有一个位置数列,给定$n$条线索,每条线索从某一个位置开始,一直向左或者向右走,每遇到一个还没有在线索中出现的数就将它加入线索,问最小的可能的数列长度. 依次从左到右考虑 ...

  2. Loj 6036 「雅礼集训 2017 Day4」编码 - 2-sat

    题目传送门 唯一的传送门 题目大意 给定$n$个串,每个串只包含 ' .问是否可能任意两个不同的串不满足一个是另一个的前缀. 2-sat的是显然的. 枚举每个通配符填0还是1,然后插入Trie树. 对 ...

  3. 2018.10.27 loj#6035. 「雅礼集训 2017 Day4」洗衣服（贪心+堆）

    传送门 显然的贪心题啊...考试没调出来10pts滚了妙的一啊 直接分别用堆贪心出洗完第iii件衣服需要的最少时间和晾完第iii件衣服需要的最少时间. 我们设第一个算出来的数组是aaa,第二个是bbb ...

  4. LOJ#6035. 「雅礼集训 2017 Day4」洗衣服

    传送门 先处理出每一件衣服最早什么时候洗完,堆+贪心即可 然后同样处理出每件衣服最早什么时候烘干 然后倒序相加取最大值 # include <bits/stdc++.h> using na ...

  5. LOJ #6035.「雅礼集训 2017 Day4」洗衣服 贪心

    这道题的贪心好迷啊~我们对于两个过程进行单独贪心,然后再翻转一个,把这两个拼起来.先说一下单独贪心,单独贪心的话就是用一个堆,每次取出最小的,并且把这个最小的加上他单次的,再放进去.这样,我们得到的结 ...

  6. LOJ #6036.「雅礼集训 2017 Day4」编码 Trie树上2-sat

    记得之前做过几道2-sat裸体,以及几道2-sat前缀优化建图,这道题使用了前缀树上前缀树优化建图.我们暴力建图肯定是n^2级别的,那么我们要是想让边数少点,就得使用一些骚操作.我们观察我们的限制条件 ...

  7. loj #6032. 「雅礼集训 2017 Day2」水箱 线段树优化DP转移

    $ \color{#0066ff}{ 题目描述 }$ 给出一个长度为 \(n\) 宽度为 \(1\) ,高度无限的水箱,有 \(n-1\) 个挡板将其分为 \(n\) 个 \(1 - 1\) 的小格, ...

  8. [LOJ 6031]「雅礼集训 2017 Day1」字符串

    [LOJ 6031] 「雅礼集训 2017 Day1」字符串 题意 给定一个长度为 \(n\) 的字符串 \(s\), \(m\) 对 \((l_i,r_i)\), 回答 \(q\) 个询问. 每个询 ...

  9. [LOJ 6030]「雅礼集训 2017 Day1」矩阵

    [LOJ 6030] 「雅礼集训 2017 Day1」矩阵 题意 给定一个 \(n\times n\) 的 01 矩阵, 每次操作可以将一行转置后赋值给某一列, 问最少几次操作能让矩阵全为 1. 无解 ...

随机推荐

  1. centos7 python2.7.5 升级python3.6.4

    (转)Linux Centos7 升级python2至python3 - 依然范儿特西的文章 - 知乎 https://zhuanlan.zhihu.com/p/33660059 1 查看python ...

  2. Nginx高性能优化

    #Nginx配置文件优化 worker_processes ; # nginx进程数,建议按照cpu数目来指定,一般为它的倍数. worker_cpu_affinity ; # 为每个进程分配CPU的 ...

  3. 《图解 HTTP 》阅读 —— 第二章

    第2章 简单的http协议 http 协议用于客户端和服务器端的通信. 请求访问文本或图像等资源的一端称为客户端,提供资源响应的一端称为服务器端. 请求报文: 响应报文: 为了能够处理大量的事务,ht ...

  4. leetcode28_C++实现strStr()函数

    实现 strStr() 函数. 给定一个 haystack 字符串和一个 needle 字符串,在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始).如果不存在,则返 ...

  5. 笔试题：C++打印队列

    题目:打印队列 题目介绍:现在用打印机打印队列,已知打印任务有9个优先级(1-9),现在给出一系列任务,求输出打印顺序(任务下标,从0开始). 例: 输入:9,3,5,4,7,1 输出:0,4,2,3 ...

  6. Linux虚拟机centos系统安装

    linux 其他知识目录 安装完后如果虚拟机网络不通请参考:虚拟机网络不通故障解决 1.centos6.9安装 后面安装出了点问题,ip没有并且eth0网卡找不到,不过重新配置ifcfg-eth0后重 ...

  7. 关于 WebView 知识点的详解

    什么是 WebView WebView 是手机中内置了一款高性能 webkit 内核浏览器,在 SDK 中封装的一个组件.没有提供地址栏和导航栏, WebView 只是单纯的展示一个网页界面.在开发中 ...

  8. 15 分钟用 ML 破解一个验证码系统

    人人都恨验证码——那些恼人的图片,显示着你在登陆某网站前得输入的文本.设计验证码的目的是,通过验证你是真实的人来避免电脑自动填充表格.但是随着深度学习和计算机视觉的兴起,现在验证码常常易被攻破. 我拜 ...

  9. hadoop 中balance 机制

    Hadoop的HDFS集群非常容易出现机器与机器之间磁盘利用率不平衡的情况,比如集群中添加新的数据节点.当HDFS出现不平衡状况的时候,将引发很多问题,比如MR程序无法很好地利用本地计算的优势,机器之 ...

  10. Python 深浅复制

    (一)浅复制 复制列表最简单的方式是使用内置类型的构造方法: >>> l1 = [1, [2, 3], (4, 5)] >>> l2 = list(l1) > ...