辣些数据结构的思维题（思维题好难一个都不会TAT）

洛谷P1268 树的重量

• 我觉得难点在于把每个叶子节点想象成分出来的叉
• 然后如果c是a--b这条边上分出来的，可以通过Dab,Dca,Dcb算出分叉边的长度，
• 长度=(Dac+Dbc-Dab)/2
• 怎么看c到底是哪两条边分叉出来的呢？
• 取最小的（洛谷后面的题解可以看懂）
• 代码：（只有一个测试数据感觉都不知道自己写的到底对不对

  #include <bits/stdc++.h>
  #define inf 1e9
  
  using namespace std;
  int n;  //n<=30
  int d[50][50];
  
  inline int f(int a,int b,int c){  //c是ab分叉，算叉出去那一段长度
      return (d[a][c]+d[b][c]-d[a][b])/2;
  }
  
  int main(){
      //freopen("owo.in","r",stdin);
      while(scanf("%d",&n)==1&&n){
          memset(d,0,sizeof(d));
          for (int i=1; i<n; i++) for (int j=i+1; j<=n; j++) { scanf("%d",&d[i][j]); d[j][i]=d[i][j]; }
          int ans=d[1][2];
          for (int i=3; i<=n; i++) {  //把每个点作为分叉加进来
              int ta=inf;
              for (int j=1; j<=i; j++) for (int k=1; k<=i; k++) if(k!=i&&j!=i&&j!=k) ta=min(ta, f(j,k,i) );
              ans+=ta;
          }
          printf("%d
  ",ans);
      }
      return 0;
  }

洛谷P2375 [NOI2014]动物园

• 题意：构造一个num数组一一对于字符串SSS的前iii个字符构成的子串，既是它的后缀同时又是它的前缀，并且该后缀与该前缀不重叠，

          将这种字符串的数量记作num[i]

• 算两个数组：
• 第一个：jump[i]它第一个不重叠的公共前后缀的位置（类似于next[i]，但是不允许前后缀有重叠）
• 第二个：ta[i]对于下标i，它全部的公共前后缀的个数
• 这两个数组都可以通过next[i]求得，然后num[i]就等于 ta[ jump[i] ] 辣。
• 代码：

  #include <bits/stdc++.h>
  #define nmax 1000010
  #define mod 1000000007
  
  using namespace std;
  typedef long long ll;
  char b[nmax];
  int num[nmax],ne[nmax],ta[nmax],jump[nmax];
  int l;
  ll ans;
  
  void init(){
      ans=1;
      memset(num,0,sizeof(num));
      memset(ne,0,sizeof(ne));
      memset(ta,0,sizeof(ta));
      memset(jump,0,sizeof(jump));
  }
  
  void build(){
      for (int i=2; i<=l; i++) {
          int j=ne[i-1];
          while( b[j+1]!=b[i] && j ) j=ne[j];
          if(b[j+1]==b[i]) ne[i]=j+1;
      }
  }
  
  void b2(){ //它第一个不重叠的公共前后缀的位置
      for (int i=2; i<=l; i++) {
          int p=jump[i-1];
          if( b[p+1] == b[i] && (p+1)<=(i/2) ) jump[i]=p+1;
          else {
              while ( p && ( (p+1)>(i/2) || b[p+1]!=b[i] ) )  p=ne[p];
              if(b[p+1]==b[i]) jump[i]=p+1;
          }
      }
  }
  
  void solve(){
      int tmp;
      for (int i=2; i<=l; i++) {
          int j=ne[i],pd=i/2;
          if(j) ta[i]=ta[j]+1;
          if( jump[i] ) tmp=ta[jump[i]]+1; else tmp=0;
          ans*=(tmp+1);
          ans%=mod;
      }
  }
  
  int main(){
      int t;
      cin>>t;
      while(t--){
          init();
          scanf("%s",b+1);
          l=strlen(b+1);
          build();
          b2();
          solve();
          printf("%lld
  ",ans);
      }
      return 0;
  }

CF Round #581 (Div. 2)      

• 这道题。。。它给的p1,....,pn里面假设连续三个点 pk,p(k+1),p(k+2) 容易知道如果pk到p（k+2）的最短路是2的话p(k+1)是可以删去的
• 于是愉快的扫一遍每次这样看三个。
• 然后就wa6了
• wa的原因：这里如果pk已经被删去了，是要影响到p(k+1)的。
• 比如p1,p2,p3,p4，如果p2被删，p4,p2的最短路是2，会删3，但是如果p1p4的最短路是2.。。就删错了
• 正确姿势：假设前面已经得到一连串p1~pk,现在最后得到的pk，然后往后面走，走到pj，如果p(j+1)和pk的距离和j+1-k相等的话，就可以把pj删了
• 代码：

  #include <bits/stdc++.h>
  #define inf 1e6
  #define mmax 5000010
  
  using namespace std;
  int n,m,ans=0,idx=0;
  int e[200][200];
  int p[mmax],del[mmax]={0};
  char in[200];
  
  void floyd(){
      for(int k=1;k<=n;k++)  for(int i=1;i<=n;i++)  for(int j=1;j<=n;j++)
          if(e[i][j]>e[i][k]+e[k][j] )   e[i][j]=e[i][k]+e[k][j];
  }
  
  int main(){
      cin>>n;
      for (int i=1; i<=n; i++) {
          scanf("%s",in+1);
          for (int j=1; j<=n; j++) if(in[j]=='1') e[i][j]=1; else e[i][j]=inf;
      }
      floyd();
      for (int i=1; i<=n; i++) e[i][i]=0;
      cin>>m;
      scanf("%d%d",&p[0],&p[1]);
      if(m==2){
          printf("2
  ");
          printf("%d %d
  ",p[0],p[1]);
      }else{
          for (int i=2; i<m; i++) {
              scanf("%d",&p[i]);
              if( e[ p[idx] ][ p[i] ]>=i-idx ) {
                      ans++;
                      del[i-1]=1;
              }else idx=i-1;
          }
  
          printf("%d
  ",m-ans);
          for (int i=0; i<m; i++) if(!del[i]) printf("%d ",p[i]);
          cout<<endl;
      }
      return 0;
  }

UVALive - 3902

•  vjudge上的地址     https://vjudge.net/problem/UVALive-3902

• 容易想到的贪心，就是对于每个叶子节点，把服务器的复制放在尽量离他远的地方。
• 但是就算是用了上面一种贪心策略还是会有很多种放置♂方式
• 然后又贪心，从深度♂比较大的客户端开始考虑
• 代码：

  #include <bits/stdc++.h>
  #define nmax 1100
  
  using namespace std;
  int cas,k,n,ina,inb,s;
  vector <int> g[nmax];
  int vis[nmax]={0},fa[nmax]={0};
  struct node{
      int d,u;
      bool operator < (const node a){ return a.d<d; }
  }x[nmax];
  
  void dfs1(int u){ //以s为根拉树，然后处理出每个点的父亲
      for (int i=0; i<g[u].size(); i++) {
          int v=g[u][i];
          if(fa[v]==0) { fa[v]=u; x[v].d=x[u].d+1; dfs1(v); }
      }
  }
  
  void dfs(int f,int u,int dep){  //给某个服务器服务到的点标1
      vis[u]=1;
      if(dep==k) return;
      for (int i=0; i<g[u].size(); i++) if(g[u][i]!=f) dfs(u,g[u][i],dep+1);
  }
  
  int main(){
      cin>>cas;
      while(cas--){
          memset(vis,0,sizeof(vis));
          memset(fa,0,sizeof(fa));
          scanf("%d%d%d",&n,&s,&k);
          x[s].d=0;
          for (int i=1; i<=n; i++) { x[i].u=i; g[i].clear(); }
          for (int i=1; i<n; i++) {
              scanf("%d%d",&ina,&inb);
              g[ina].push_back(inb);
              g[inb].push_back(ina);
          }
          fa[s]=s;
          dfs1(s);
          sort(x+1,x+n+1);
          dfs(s,s,0);
          int ans=0;
          for (int i=1; i<=n; i++) {
              int u=x[i].u;
              if( g[u].size()>1 || vis[u] ) continue;
              int v=u;
              for (int i=0; i<k; i++) v=fa[v];
              dfs(v,v,0);
              ans++;
          }
          printf("%d
  ",ans);
      }
      return 0;
  }