20190922 模拟

Task1

这个是USACO 2019 JAN Gold的原题，可能因为过于水，所以我即使八点多才开始做也提前ak。。。来写一篇题解。。

A. Cow Poetry

显然押同一韵的行只需要最后一个词属于一个韵部，前面长度$K-s_i$随便排，DP一下长度$i$的有多少种，类似于背包转移，只是把物品放在内层，容量放在外层枚举，这样保证顺序不同时有不同的种类数。

然后对于每一种要求韵相同的行，可以枚举每一种韵，结合乘法原理和加法原理得出方案数。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define dbg(x) cerr << #x << " = " << x <<endl
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
template<typename T>inline T _min(T A,T B){return A<B?A:B;}
template<typename T>inline T _max(T A,T B){return A>B?A:B;}
template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,1):0;}
template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,1):0;}
template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
template<typename T>inline T read(T&x){
    x=0;int f=0;char c;while(!isdigit(c=getchar()))if(c=='-')f=1;
    while(isdigit(c))x=x*10+(c&15),c=getchar();return f?x=-x:x;
}
const int N=5000+7,P=1e9+7;
char opt[3];
int f[N],now;
int cnt[27],typ[N];
int s[N],c[N];
int n,m,k,maxc,ans=1;
inline void add(int&A,int B){A+=B;A>=P&&(A-=P);}
inline int fpow(int x,int p){int ret=1;for(;p;p>>=1,x=x*1ll*x%P)if(p&1)ret=ret*1ll*x%P;return ret;}

int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
    read(n),read(m),read(k);
    for(register int i=1;i<=n;++i)read(s[i]),MAX(maxc,read(c[i]));
    for(register int i=1;i<=m;++i)scanf("%s",opt),++cnt[opt[0]-'A'];
    f[0]=1;
    for(register int i=0;i<=k;++i)
        for(register int j=1;j<=n;++j)if(i+s[j]<=k)add(f[i+s[j]],f[i]);
    for(register int i=1;i<=n;++i)if(k>=s[i])add(typ[c[i]],f[k-s[i]]);
    for(register int i=0;i<26;++i)if(cnt[i]){
        int tmp=0;
        for(register int j=1;j<=maxc;++j)if(typ[j]){
            add(tmp,fpow(typ[j],cnt[i]));
        }
        ans=ans*1ll*tmp%P;
    }
    printf("%d
",ans);
    return 0;
}

B. Sleepy Cow Sorting

这个真的水。。可以发现显然最后最长的有序上升序列不要动，把前面的数不断往后插，这样就保证了次数最少。于是BIT维护一发即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define dbg(x) cerr << #x << " = " << x <<endl
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
template<typename T>inline T _min(T A,T B){return A<B?A:B;}
template<typename T>inline T _max(T A,T B){return A>B?A:B;}
template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,1):0;}
template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,1):0;}
template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
template<typename T>inline T read(T&x){
    x=0;int f=0;char c;while(!isdigit(c=getchar()))if(c=='-')f=1;
    while(isdigit(c))x=x*10+(c&15),c=getchar();return f?x=-x:x;
}
const int N=1e5+7;
int C[N];
int a[N];
int n,las,pos;
#define lowbit(x) x&(-x)
inline void add(int x){for(;x<=n;x+=lowbit(x))++C[x];}
inline int sum(int x){int ret=0;for(;x;x-=lowbit(x))ret+=C[x];return ret;}

int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
    read(n);
    for(register int i=1;i<=n;++i)read(a[i]);
    las=a[n];add(las);pos=n-1;
    for(register int i=n-1;i;--i)if(MIN(las,a[i]))--pos,add(a[i]);else break;
    printf("%d
",pos);
    for(register int i=1;i<=pos;++i)printf("%d ",pos-i+sum(a[i])),add(a[i]);
    puts("");return 0;
}

C. Shortcut

每个点到根的最短路路径是唯一的（因为字典序已经要求最小的），所以构成的最短路树就是唯一的，于是跑一遍dijkstra记录父边（注意更新min）之后在最短路树上暴力枚举把哪个和根相连，计算贡献取max即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#define dbg(x) cerr << #x << " = " << x <<endl
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
template<typename T>inline T _min(T A,T B){return A<B?A:B;}
template<typename T>inline T _max(T A,T B){return A>B?A:B;}
template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,1):0;}
template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,1):0;}
template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
template<typename T>inline T read(T&x){
    x=0;int f=0;char c;while(!isdigit(c=getchar()))if(c=='-')f=1;
    while(isdigit(c))x=x*10+(c&15),c=getchar();return f?x=-x:x;
}
const int N=1e5+7;
struct thxorz{int to,nxt,w;}G[N];
int Head[N],tot,c[N];
int n,m,t;
inline void Addedge(int x,int y,int z){
    G[++tot].to=y,G[tot].nxt=Head[x],Head[x]=tot,G[tot].w=z;
    G[++tot].to=x,G[tot].nxt=Head[y],Head[y]=tot,G[tot].w=z;
}
int dis[N],fa[N],val[N];
priority_queue<pii,vector<pii>,greater<pii> > q;
#define y G[j].to
inline void dij(){
    memset(fa,0x3f,sizeof fa);
    memset(dis,0x3f,sizeof dis);q.push(make_pair(dis[1]=0,1));
    while(!q.empty()){
        int d=q.top().first,x=q.top().second;q.pop();
        if(dis[x]^d)continue;
        for(register int j=Head[x];j;j=G[j].nxt)
            if(d+G[j].w==dis[y]&&MIN(fa[y],x))val[y]=G[j].w;
            else if(d+G[j].w<dis[y])q.push(make_pair(dis[y]=d+G[j].w,y)),fa[y]=x,val[y]=G[j].w;
    }
}
ll ans=0;
int dfs(int x,int fa,int dep){
    int siz=c[x];
    for(register int j=Head[x];j;j=G[j].nxt)if(y^fa)siz+=dfs(y,x,dep+G[j].w);
    MAX(ans,(dep-t)*1ll*siz);
    return siz;
}
#undef y
int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
    read(n),read(m),read(t);
    for(register int i=1;i<=n;++i)read(c[i]);
    for(register int i=1,x,y,z;i<=m;++i)read(x),read(y),read(z),Addedge(x,y,z);
    dij();memset(Head,0,sizeof Head);tot=0;
    for(register int i=2;i<=n;++i)Addedge(i,fa[i],val[i]);
    dfs(1,0,0);
    printf("%lld
",ans);
    return 0;
}

Task2

A. Redistricting

简化题意：01序列划分块，每块最多$K$个，最小化：块内1个数大于等于0个数的块数。

列出dp式子

$f_i=min{f_j+[s_i-s_jge lfloorfrac{i-j+1}{2} floor]}$

其中$s_i$是G数量前缀和。

然后那个判断式只能是$0/1$，可以用单调队列维护一个$f$单调不减的序列，新元素小于队尾的肯定更优（因为最多相差1），当相等时讨论，如果这两个元素之间的1数量大于等于0数量，之前决策一定不优，因为选他只会增加1相对于0的数量。

然后用这两个条件维护队列即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define dbg(x) cerr << #x << " = " << x <<endl
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
template<typename T>inline T _min(T A,T B){return A<B?A:B;}
template<typename T>inline T _max(T A,T B){return A>B?A:B;}
template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,1):0;}
template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,1):0;}
template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
template<typename T>inline T read(T&x){
    x=0;int f=0;char c;while(!isdigit(c=getchar()))if(c=='-')f=1;
    while(isdigit(c))x=x*10+(c&15),c=getchar();return f?x=-x:x;
}
const int N=3e5+7;
int a[N],f[N],q[N],n,k,l,r;
char s[N];

int main(){//freopen("testdata.in","r",stdin);//freopen("test.ans","w",stdout);
    read(n),read(k);
    scanf("%s",s+1);
    for(register int i=1;i<=n;++i)a[i]+=a[i-1]+(s[i]=='G');
    q[l=r=1]=0;
    for(register int i=1;i<=n;++i){
        while(l<=r&&q[l]<i-k)++l;
        f[i]=f[q[l]]+(a[i]-a[q[l]]>=i-q[l]+1>>1);//dbg(i),dbg(f[i]);
        while(l<=r&&(f[q[r]]>f[i]||f[q[r]]==f[i]&&a[i]-a[q[r]]>=i-q[r]+1>>1))--r;
        q[++r]=i;
    }
    printf("%d
",f[n]);
    return 0;
}

B. Exercise

题意：就是说给一棵树，然后有一堆非树边，问这张图有多少简单环恰好包含两条非树边。

首先由一个非常神仙的结论，对于两条非树边，他们对应的路径必须有相交的边才可以在一个环内。

反正我是真的想不到。。然后还不知道为什么他就是对的，坑了几个小时，配合各种大力分类，感觉是可以理解一点了。。

比如说一条非树边对应两点$x,y$，另外一条非树边的一点$a$希望走到$x$、跳到$y$然后再走到$b$。一个显然的套路是把非树边转化为树链。

如果$a$在$x$子树内，$b$只要不同时在其子树内即可。$a$不在子树内，那么寻找一条树上路径$a o x$，然后跳到$y$。因为要求路径上的点不重合，所以$y$出发，不能走到之前走过的地方，也就是要“提前拐弯”走别的路，这样，$a o x o y o b$的路径在树链$x,y$上没有交，又发现，树链上有一小段路没有走过，画一下发现$a$出发到达这个地方直接走这段路后可以直接到$b$，也就是说，$a,b$和$x,y$的树链有相交部分，才可以有点不重复路径，换言之就是简单环。然后发现上述两种分类都成立。

所以问题就转化为若干个树链有多少对有相交部分。

先考虑序列上给若干个区间，显然做法是每一个区间统计它后面有多少区间和他相交（不然会算两次），也就是后面起点在$[L_i,R_i]$的区间个数，这个直接用前缀和就行了，注意：对于起点相同的区间，每个区间都会去统计另外几个，注意减去多余的。

放到树上，一个树链拆成两个直上直下的链，看有多少其他链至少和其中一个相交，方法类似，相当于从根向下的一条链上一个区间，有多少其他区间和他相交。这里注意几点：必须统计起点（指靠上的点）落在这个区间内部的区间个数，如果是结束点会有问题。。我一开始就是挂在这里的，有一种两条链中间相交然后分叉的反例。另外，也要注意两种重复的情况：一种是链起始边相同会造成重复统计，这个记录同一条边作为起始边个数，另一种是拆出来的两条链和问的两条链都有相交，这个用map塞pair统计解决。

并不是很容易说。。个人也没有很深入的理解。。具体还是要看代码。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<map>
#define mst(x) memset(x,0,sizeof x)
#define dbg(x) cerr << #x << " = " << x <<endl
#define dbg2(x,y) cerr<< #x <<" = "<< x <<"  "<< #y <<" = "<< y <<endl
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
template<typename T>inline T _min(T A,T B){return A<B?A:B;}
template<typename T>inline T _max(T A,T B){return A>B?A:B;}
template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,1):0;}
template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,1):0;}
template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
template<typename T>inline T read(T&x){
    x=0;int f=0;char c;while(!isdigit(c=getchar()))if(c=='-')f=1;
    while(isdigit(c))x=x*10+(c&15),c=getchar();return f?x=-x:x;
}
const int N=2e5+7;
struct thxorz{
    int head[N],nxt[N<<1],to[N<<1],tot;
    thxorz(){tot=1;}
    inline void add(int x,int y){
        to[++tot]=y,nxt[tot]=head[x],head[x]=tot;
        to[++tot]=x,nxt[tot]=head[y],head[y]=tot;
    }
}G;
map<pii,int> mp;
int qx[N],qy[N],lca[N];
int n,m,tmp;
ll ans;
#define y G.to[j]
int dep[N],son[N],sum[N],fa[N],topfa[N],st[N];
void dfs0(int x,int fat){
    fa[x]=fat,dep[x]=dep[fat]+1,sum[x]=1;int tmp=-1;
    for(register int j=G.head[x];j;j=G.nxt[j])if(y^fat)dfs0(y,x),sum[x]+=sum[y],MAX(tmp,sum[y])&&(son[x]=y);
}
void dfs1(int x,int topf){
    topfa[x]=topf;if(!son[x])return;dfs1(son[x],topf);
    for(register int j=G.head[x];j;j=G.nxt[j])if(y^fa[x]&&y^son[x])dfs1(y,y);
}
void dfs2(int x){for(register int j=G.head[x];j;j=G.nxt[j])if(y^fa[x])st[y]+=st[x],dfs2(y);}
#undef y
inline int LCA(int x,int y){
    while(topfa[x]^topfa[y])dep[topfa[x]]>dep[topfa[y]]?x=fa[topfa[x]]:y=fa[topfa[y]];
    return dep[x]<dep[y]?x:y;
}
inline int jump(int x,int lca){
    int las=0;
    while(topfa[x]^topfa[lca])las=topfa[x],x=fa[las];
    return x==lca?las:son[lca];
}

int main(){freopen("exercise.in","r",stdin);freopen("exercise.out","w",stdout);
    read(n),m=read(m)-n+1;
    for(register int i=1,x,y;i<n;++i)read(x),read(y),G.add(x,y);
    dfs0(1,0),dfs1(1,1);
    for(register int i=1,bx,by;i<=m;++i){
        read(qx[i]),read(qy[i]);
        lca[i]=LCA(qx[i],qy[i]);
        if(lca[i]^qx[i])bx=jump(qx[i],lca[i]),ans-=++st[bx];
        if(lca[i]^qy[i])by=jump(qy[i],lca[i]),ans-=++st[by];
        if(lca[i]^qx[i]&&lca[i]^qy[i]){
            if(bx>by)_swap(bx,by);
            ans-=mp[make_pair(bx,by)]++;
        }
    }
    dfs2(1);
    for(register int i=1;i<=m;++i)ans+=st[qx[i]]+st[qy[i]]-(st[lca[i]]<<1);
    printf("%lld
",ans);
    return 0;
}

C. tracking2

神仙计数题，不会，自闭中。。。

To be continued.