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(100005);
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+1); n=strlen(s+1);
    cnt=1;
    for(int k=0; k<26; ++k)
      for(int i=1; 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+1,a+cnt+1);
    for(int i=1; i<=cnt; ++i)
//        printf("%d %d
",a[i].l,a[i].r);
      for(int j=i+1; j<=cnt; ++j)
      {
          if(a[i].r<a[j].l) break;
          ans+=(a[i].r<a[j].r);
      }
    printf("%d
",ans);
    return 0;
}

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

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=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}

const int INF(0x3f3f3f);
const int M(2333);
const int N(505);
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=0,int next=0,int w=0):
        v(v),next(next),w(w){}
}edge[M<<1];
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=1; i<=n; ++i)
        dis[s][i]=INF,vis[i]=0;
    u.dis=dis[s][s]=0,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]=1;
        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=0,int v=0,int w=0):u(u),v(v),w(w){}
}road[M];

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

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

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

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

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=0; register char ch=getchar();
    for(; ch>'9'||ch<'0'; ) ch=getchar();
    for(; ch>='0'&&ch<='9'; ch=getchar()) x=x*10+ch-'0';
}
const int mod(786433);
const int N(5233);
int n,q,ans,dis[N][N];
int head[N],sumedge;
struct Edge {
    int v,next;
    Edge(int v=0,int next=0):v(v),next(next){}
}edge[N<<1];
inline void ins(int u,int v)
{
    edge[++sumedge]=Edge(v,head[u]);
    head[u]=sumedge,dis[u][v]=1;
}

int size[N],tmp[N],f[N][N];
void DFS(int u,int pre)
{
    size[u]=1; f[u][1]=1;
    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=1; j<=tot; ++j) tmp[j]=0;
        for(int j=1; j<=size[u]; ++j)
            tmp[j]=1ll*f[v][0]*f[u][j]%mod;
        for(int j=1; j<=size[u]; ++j)
          for(int k=1; k<=size[v]; ++k)
              tmp[k+j]=(tmp[k+j]%mod+1ll*f[u][j]*f[v][k]%mod)%mod;
        for(int j=1; j<=tot; ++j) f[u][j]=tmp[j];
        size[u]+=size[v];
    }
    for(int i=q; i<=size[u]; ++i) f[u][0]=(f[u][0]+f[u][i])%mod;
}

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

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