2017-10-23学大伟业Day1

T1 叉叉

题目名称	叉叉
程序文件名	cross
输入文件名	cross.in
输出文件名	cross.out
每个测试点时限	1秒
内存限制	128MB
测试点数目	10
每个测试点分值	10
是否有部分分	无
试题类型	传统

题目描述

现在有一个字符串，每个字母出现的次数均为偶数。接下来我们把第一次出现的字母a和第二次出现的a连一条线，第三次出现的和四次出现的字母a连一条线，第五次出现的和六次出现的字母a连一条线...对其他25个字母也做同样的操作。

现在我们想知道有多少对连线交叉。交叉的定义为一个连线的端点在另外一个连线的内部，另外一个端点在外部。

下图是一个例子，共有三对连线交叉（我们连线的时候，只能从字符串上方经过）。

输入格式

一行一个字符串。保证字符串均由小写字母组成，且每个字母出现次数为偶数次。

输出格式

一个整数，表示答案。

样例输入

abaazooabz

样例输出

3

数据范围

对于30% 的数据，字符串长度不超过50。

对于100% 的数据，字符串长度不超过100,000。

处理出每对字符的两个位置，按左端点排序，判断是否会相交，加一个小剪枝、、、暴力做法数据水就过了。。

 #include <algorithm>
 #include <cstring>
 #include <cstdio>

 const int N();
 int cnt,n,ans;
 struct Node {
     int l,r;
     bool operator < (const Node&x)const
     {
         return l<x.l;
     }
 }a[N];
 char s[N];

 int Presist()
 {
     freopen("cross.in","r",stdin);
     freopen("cross.out","w",stdout);
     scanf("%s",s+); n=strlen(s+);
     cnt=;
     for(int k=; k<; ++k)
       for(int i=; i<=n; ++i)
           if(s[i]-'a'==k)
           {
               if(a[cnt].r) a[++cnt].l=i;
               else if(!a[cnt].l) a[cnt].l=i;
                    else a[cnt].r=i;
         }
     std::sort(a+,a+cnt+);
     for(int i=; i<=cnt; ++i)
 //        printf("%d %d\n",a[i].l,a[i].r);
       for(int j=i+; j<=cnt; ++j)
       {
           if(a[i].r<a[j].l) break;
           ans+=(a[i].r<a[j].r);
       }
     printf("%d\n",ans);
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}

AC

T2 跳跳虎想回家

k==0的就是普通的最短路，k==1的可以Floyd求出多源最短路，枚举每个传送通道更新最小值，

另外就是乱搞的（把传送通道全加进去跑最短路。。可能还是数据水）、、考试时数组开小了80分、

 #include <cstdio>
 #include <queue>

 #define min(a,b) ((a)<(b)?(a):(b))

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }

 const int INF(0x3f3f3f);
 const int M();
 const int N();
 int n,m,q,k,ans;
 int dis[N][N];
 bool vis[N];

 int head[N],sumedge;
 struct Edge {
     int v,next,w;
     Edge(int v=,int next=,int w=):
         v(v),next(next),w(w){}
 }edge[M<<];
 inline void ins(int u,int v,int w)
 {
     edge[++sumedge]=Edge(v,head[u],w);
     head[u]=sumedge; dis[u][v]=w;
 }

 struct Node {
     int pos,dis;
     bool operator < (const Node&x)const
     {
         return dis>x.dis;
     }
 }u,v;
 std::priority_queue<Node>que;

 inline void Dijkstra(int s)
 {
     for(int i=; i<=n; ++i)
         dis[s][i]=INF,vis[i]=;
     u.dis=dis[s][s]=,u.pos=s;
     for(; !que.empty(); ) que.pop(); que.push(u);
     for(; !que.empty(); )
     {
         u=que.top(); que.pop();
         if(vis[u.pos]) continue; vis[u.pos]=;
         for(int i=head[u.pos]; i; i=edge[i].next)
         {
             v.pos=edge[i].v;
             if(dis[s][v.pos]>dis[s][u.pos]+edge[i].w)
             {
                 dis[s][v.pos]=dis[s][u.pos]+edge[i].w;
                 v.dis=dis[s][v.pos]; que.push(v);
             }
         }
     }
 }

 struct Road {
     int u,v,w;
     Road(int u=,int v=,int w=):u(u),v(v),w(w){}
 }road[M];

 inline void violence()
 {
     for(int k=; k<=n; ++k)
       for(int i=; i<=n; ++i)
           for(int j=; j<=n; ++j)
           dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
     ans=dis[][n];
     for(int u,w,v,i=; i<=q; ++i)
     {
         u=road[i].u,v=road[i].v,w=road[i].w;
         ans=min(ans,dis[][u]+dis[v][n]+w);
     }
     printf("%d\n",ans>=INF?(-):ans);
 }

 inline void violence2()
 {
     for(int u,w,v,i=; i<=q; ++i)
         ins(road[i].u,road[i].v,road[i].w);
     Dijkstra(); printf("%d\n",dis[][n]>=INF?(-):dis[][n]);
 }

 int Presist()
 {
     freopen("move.in","r",stdin);
     freopen("move.out","w",stdout);
     read(n),read(m),read(q),read(k);
     for(int i=; i<=n; ++i)
       for(int j=; j<=n; ++j)
           dis[i][j]=(i!=j)*INF;
     for(int u,v,w,i=; i<=m; ++i)
         read(u),read(v),read(w),ins(u,v,w);
     for(int u,v,w,i=; i<=q; ++i)
         read(u),read(v),read(w),road[i]=Road(u,v,w);
     if(!k) { Dijkstra(); printf("%d\n",dis[][n]>=INF?(-):dis[][n]); return ;}
     else if(k==) { violence(); return ; }
          else { violence2(); return ; }
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}

AC

T3 秀秀 和哺 噜国 （ cut ）

f[i][j]表示以i为根，连通块大小为k的满足题目要求联通个数的方案数，f[i][0]表示以i为根的所有合法方案数

对于u的一个孩子v，f[u][j+k]+=f[u][j]*f[v][k]，（乘法原理，一颗以u的孩子为根的树的贡献与其余树互不影响）

f[u][0]+=f[u][i](k<=i<=size[u])

只枚举当前 u 所在子树的大小，每当枚举到它的其中孩子时，当前 u 所在子树的大小加上它孩子为根的子树的大小。

可以理解为每一个点对只被枚举到一次。 这样可以优化到n^2

ans=f[root][0]

 #include <cstdio>

 #define min(a,b) ((a)<(b)?(a):(b))

 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int mod();
 const int N();
 int n,q,ans,dis[N][N];
 int head[N],sumedge;
 struct Edge {
     int v,next;
     Edge(int v=,int next=):v(v),next(next){}
 }edge[N<<];
 inline void ins(int u,int v)
 {
     edge[++sumedge]=Edge(v,head[u]);
     head[u]=sumedge,dis[u][v]=;
 }

 int size[N],tmp[N],f[N][N];
 void DFS(int u,int pre)
 {
     size[u]=; f[u][]=;
     for(int v,i=head[u]; i; i=edge[i].next)
     {
         v=edge[i].v; if(v==pre) continue;
         DFS(v,u); int tot=size[u]+size[v];
         for(int j=; j<=tot; ++j) tmp[j]=;
         for(int j=; j<=size[u]; ++j)
             tmp[j]=1ll*f[v][]*f[u][j]%mod;
         for(int j=; j<=size[u]; ++j)
           for(int k=; k<=size[v]; ++k)
               tmp[k+j]=(tmp[k+j]%mod+1ll*f[u][j]*f[v][k]%mod)%mod;
         for(int j=; j<=tot; ++j) f[u][j]=tmp[j];
         size[u]+=size[v];
     }
     for(int i=q; i<=size[u]; ++i) f[u][]=(f[u][]+f[u][i])%mod;
 }

 int Presist()
 {
 //    freopen("cut.in","r",stdin);
 //    freopen("cut.out","w",stdout);
     read(n),read(q);
     for(int i=; i<=n; ++i)
       for(int j=; j<=n; ++j)
         dis[i][j]=(i!=j)*(n+);
     for(int u,v,i=; i<n; ++i)
         read(u),read(v),ins(u,v);
     DFS(,-);
     printf("%d\n",f[][]);
     return ;
 }

 int Aptal=Presist();
 int main(int argc,char**argv){;}

AC