辣些数据结构的思维题（思维题好难一个都不会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[][];
  
   inline int f(int a,int b,int c){  //c是ab分叉，算叉出去那一段长度
       return (d[a][c]+d[b][c]-d[a][b])/;
   }
  
   int main(){
       //freopen("owo.in","r",stdin);
       while(scanf("%d",&n)==&&n){
           memset(d,,sizeof(d));
           for (int i=; i<n; i++) for (int j=i+; j<=n; j++) { scanf("%d",&d[i][j]); d[j][i]=d[i][j]; }
           int ans=d[][];
           for (int i=; i<=n; i++) {  //把每个点作为分叉加进来
               int ta=inf;
               for (int j=; j<=i; j++) for (int k=; k<=i; k++) if(k!=i&&j!=i&&j!=k) ta=min(ta, f(j,k,i) );
               ans+=ta;
           }
           printf("%d\n",ans);
       }
       return ;
   }

  ( ͡° ͜ʖ ͡°)

洛谷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=;
       memset(num,,sizeof(num));
       memset(ne,,sizeof(ne));
       memset(ta,,sizeof(ta));
       memset(jump,,sizeof(jump));
   }
  
   void build(){
       for (int i=; i<=l; i++) {
           int j=ne[i-];
           while( b[j+]!=b[i] && j ) j=ne[j];
           if(b[j+]==b[i]) ne[i]=j+;
       }
   }
  
   void b2(){ //它第一个不重叠的公共前后缀的位置
       for (int i=; i<=l; i++) {
           int p=jump[i-];
           if( b[p+] == b[i] && (p+)<=(i/) ) jump[i]=p+;
           else {
               while ( p && ( (p+)>(i/) || b[p+]!=b[i] ) )  p=ne[p];
               if(b[p+]==b[i]) jump[i]=p+;
           }
       }
   }
  
   void solve(){
       int tmp;
       for (int i=; i<=l; i++) {
           int j=ne[i],pd=i/;
           if(j) ta[i]=ta[j]+;
           if( jump[i] ) tmp=ta[jump[i]]+; else tmp=;
           ans*=(tmp+);
           ans%=mod;
       }
   }
  
   int main(){
       int t;
       cin>>t;
       while(t--){
           init();
           scanf("%s",b+);
           l=strlen(b+);
           build();
           b2();
           solve();
           printf("%lld\n",ans);
       }
       return ;
   }

  ^3^

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=,idx=;
   int e[][];
   int p[mmax],del[mmax]={};
   char in[];
  
   void floyd(){
       for(int k=;k<=n;k++)  for(int i=;i<=n;i++)  for(int j=;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=; i<=n; i++) {
           scanf("%s",in+);
           for (int j=; j<=n; j++) if(in[j]=='') e[i][j]=; else e[i][j]=inf;
       }
       floyd();
       for (int i=; i<=n; i++) e[i][i]=;
       cin>>m;
       scanf("%d%d",&p[],&p[]);
       if(m==){
           printf("2\n");
           printf("%d %d\n",p[],p[]);
       }else{
           for (int i=; i<m; i++) {
               scanf("%d",&p[i]);
               if( e[ p[idx] ][ p[i] ]>=i-idx ) {
                       ans++;
                       del[i-]=;
               }else idx=i-;
           }
  
           printf("%d\n",m-ans);
           for (int i=; i<m; i++) if(!del[i]) printf("%d ",p[i]);
           cout<<endl;
       }
       return ;
   }

  嘤雄不朽+1s

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

  嘤年早逝