USACO2023Jan游记

由于学校要求，过来打 USACO。

似乎要求起码升到白金？

由于是第一次打，只有从铜组开始了。

Brouze

简单题，就给核心代码。

30min AK。

Leaders

http://usaco.org/current/index.php?page=viewproblem&cpid=1263

chr C[100005];uint R[100005];
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    uint n;scanf("%u%s",&n,C);for(uint i=0;i<n;i++)scanf("%u",R+i);
    chr c=*C;uint p=0;while(C[p]==c)p++;
    uint ans=0;for(uint i=0;i<p;i++)ans+=R[i]>p;
    bol ok=R[0]==p;for(uint i=p;i<n;i++)ok&=C[i]!=c;
    ans+=ok;
    printf("%u\n",ans);
    return 0;
}

Air Cownditioning II

http://usaco.org/current/index.php?page=viewproblem&cpid=1264

uint L[25],R[25],C[25],A[25],B[25],P[25],M[25],Cnt[105];
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    uint n,m;scanf("%u%u",&n,&m);
    for(uint i=0;i<n;i++)scanf("%u%u%u",L+i,R+i,C+i),L[i]--;
    for(uint i=0;i<m;i++)scanf("%u%u%u%u",A+i,B+i,P+i,M+i),A[i]--;
    uint ans=-1;
    for(uint i=0;i<(1u<<m);i++){
        for(uint i=0;i<100;i++)Cnt[i]=0;
        uint wil=0;
        for(uint j=0;j<m;j++)if(i>>j&1){
            wil+=M[j];for(uint k=A[j];k<B[j];k++)Cnt[k]+=P[j];
        }
        bol ok=1;
        for(uint j=0;j<n;j++)for(uint k=L[j];k<R[j];k++)ok&=Cnt[k]>=C[j];
        if(ok)_min(ans,wil);
    }
    printf("%u\n",ans);
    return 0;
}

Moo Operations

http://usaco.org/current/index.php?page=viewproblem&cpid=1265

chr C[105];
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    uint t;scanf("%u",&t);
    while(t--){
        uint n=0;scanf("%s",C);while(C[n])n++;
        uint ans=-1;
        for(uint i=1;i+1<n;i++)if(C[i]=='O')
            _min(ans,n-1-(C[i-1]=='M')-(C[i+1]=='O'));
        printf("%d\n",(int)ans);
    }
    return 0;
}

Silver

1h30min AK。

Find and Replace

http://usaco.org/current/index.php?page=viewproblem&cpid=1266

恶心的题目，做了 1h。

基环树和环的答案是不同的！！！

由于只能变字母，要特判 \(52\rightarrow52\) 的全环情况！！！

chr A[100005],B[100005],To[128];
bol Gone[128];
voi solve(){
    for(uint i=0;i<=127;i++)Gone[i]=0;
    uint ans=0;scanf("%s%s",A,B);
    for(uint i=0;A[i];i++){
        if(!Gone[(uint)A[i]])To[(uint)A[i]]=B[i],Gone[(uint)A[i]]=1,ans+=A[i]!=B[i];
        if(To[(uint)A[i]]!=B[i]){puts("-1");return;}
    }
    if(ans){
        std::set<uint>S1,S2;
        for(uint c=0;c<=127;c++)if(Gone[c])S1.insert(c),S2.insert(To[c]);
        if(S1.size()==52&&S2.size()==52){puts("-1");return;}
        for(uint c:S1)if((uint)To[c]==c)Gone[c]=false;
        for(uint p:S1)if(Gone[p]&&!S2.count(p)){
            std::vector<uint>V;
            while(Gone[p])Gone[p]=false,V.push_back(p),p=To[p];
        }
        for(uint p:S1)if(Gone[p]&&S2.count(p)){
            std::vector<uint>V;
            while(Gone[p])Gone[p]=false,V.push_back(p),p=To[p];
            for(auto s:V)if(s==p)ans++;
        }
    }
    printf("%u\n",ans);
}

Following Directions

http://usaco.org/current/index.php?page=viewproblem&cpid=1267

注意到形成树的结构，直接记录每个子树大小即可。

线段树分治可以做，但没有必要。

chr C[2005][2005];
uint R[2005],D[2005];
uint V[2005][2005];
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    uint n,q;scanf("%u",&n);
    for(uint i=0;i<n;i++)scanf("%s%u",C[i],R+i);
    for(uint i=0;i<n;i++)scanf("%u",D+i);
    for(uint i=0;i<n;i++)for(uint j=0;j<n;j++)V[i][j]=1;
    for(uint i=0;i<n;i++)for(uint j=0;j<n;j++)(C[i][j]=='R'?V[i][j+1]:V[i+1][j])+=V[i][j];
    uint sum=0;
    for(uint i=0;i<n;i++)sum+=V[i][n]*R[i]+V[n][i]*D[i];
    printf("%u\n",sum);
    scanf("%u",&q);
    while(q--){
        uint x,y;scanf("%u%u",&x,&y),x--,y--;
        for(uint i=x,j=y;;){
            C[i][j]=='R'?j++:i++,V[i][j]-=V[x][y];
            if(i==n){sum-=V[x][y]*D[j];break;}
            if(j==n){sum-=V[x][y]*R[i];break;}
        }
        C[x][y]^='R'^'D';
        for(uint i=x,j=y;;){
            C[i][j]=='R'?j++:i++,V[i][j]+=V[x][y];
            if(i==n){sum+=V[x][y]*D[j];break;}
            if(j==n){sum+=V[x][y]*R[i];break;}
        }
        printf("%u\n",sum);
    }
    return 0;
}

Moo Route

http://usaco.org/current/index.php?page=viewproblem&cpid=1268

画个图就做完了。

uint A[100005];
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    uint n;scanf("%u",&n);
    for(uint i=0;i<n;i++)scanf("%u",A+i),A[i]--;
    for(uint p=0;A[p];)
    {
        while(!p||A[p]>A[p-1])--A[p++],putchar('R');
        while(p&&A[p-1])--A[--p],putchar('L');
    }
    for(uint i=0;i<n;i++)putchar('L');
    putchar('\n');
    return 0;
}

Gold

2h AK。

Find and Replace

http://usaco.org/index.php?page=viewproblem&cpid=1269

考虑动态维护每个串的每个字母会被哪个规则替换，则加入一条新规则时，其将作用于之前所有未被替换的某个字母。

这个可以拿 \(26\) 个 vector 直接维护。

记录下来后，整个结构是一张 DAG，把每个串串长记录下来即可。

然后如果直接在 DAG 上 dfs，很容易卡到 \(O(nq)\)（\(n\) 表示查询区间长度）：

1 200000 200000
a aa
a aa
a aa
a aa
...
a aa
a b
b a
a b
b a
...
b a

这个东西每找一个字符都会跑满整一层，不优。

考虑在 DAG 的每个节点处，若其对应串长不超过 \(B\)，则把其整个字符串记录下来。

查询时如果串长不超过 \(B\)，就不再往下递归，直接输出这段区间。

容易分析这样的总复杂度为 \(O(q(B+\frac nB))\)，取 \(B=\sqrt n\)，得复杂度为 \(O(q\sqrt n)\)。

由于这个东西非常跑不满，直接取 \(B=20\) 即可通过。

（当然也不排除可以进一步分析出 \(O(q(B+\frac n{B^2}))\) 等更紧的界，因为我会构造的最坏数据只能达到这个复杂度级别，那样的平衡复杂度就是 \(O(q\ {}^3\!\!\!\!\sqrt n)\)）

std::vector<std::pair<uint,uint> >Find[26];
std::vector<chr>S[200005],S2[200005];
std::vector<uint>To[200005];
chr C[200005];
ullt Len[200005];
voi dfs(uint q,ullt l,ullt r){
    if(S2[q].size()){
        for(uint i=l;i<r;i++)putchar(S2[q][i]);
        return;
    }
    for(uint i=0;i<To[q].size()&&l<r;i++)
        if(~To[q][i])
            if(l<Len[To[q][i]])
                if(r<=Len[To[q][i]])dfs(To[q][i],l,r),l=r=0;
                else dfs(To[q][i],l,Len[To[q][i]]),r-=Len[To[q][i]],l=0;
            else r-=Len[To[q][i]],l-=Len[To[q][i]];
        else
        {
            if(!l)putchar(S[q][i]);else l--;
            r--;
        }
}
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    ullt l,r;uint q;scanf("%llu%llu%u",&l,&r,&q);
    S[0]={'a'},To[0]={-1u},Find[0].push_back({0,0});
    for(uint i=1;i<=q;i++){
        scanf("%s",C);for(auto s:Find[*C-'a'])To[s.first][s.second]=i;
        Find[*C-'a'].clear(),scanf("%s",C);
        for(uint j=0;C[j];j++)S[i].push_back(C[j]),Find[C[j]-'a'].push_back({i,j});
        To[i].resize(S[i].size(),-1);
    }
    for(uint i=q;~i;i--){
        for(uint j=0;j<To[i].size();j++)
            if(~To[i][j])_min(Len[i]+=Len[To[i][j]],2000000000000000000llu);
            else _min(++Len[i],2000000000000000000llu);
        if(Len[i]<=20)for(uint j=0;j<To[i].size();j++){
            if(~To[i][j])S2[i].insert(S2[i].end(),S2[To[i][j]].begin(),S2[To[i][j]].end());
            else S2[i].push_back(S[i][j]);
        }
    }
    dfs(0,l-1,r),putchar('\n');
    return 0;
}

Lights Off

http://usaco.org/index.php?page=viewproblem&cpid=1270

感觉题目里给的这个 move 操作很奇怪，数据范围也很怪（\(n\) 很小但 \(T\) 很大），时限也给了 \(4s\)，考虑大胆猜结论：答案很小，是 \(O(n)\) 或者类似的级别，可以暴力枚举；但是信息的预处理复杂度与 \(2^n\) 有关。

考虑把对答案的贡献拆分，发现操作了 \(a\) 步时，原有的开关串会带来其旋转 \(0,1,2,\dots,a-1\) 步后的结果的贡献，自己扭动的开关会带来长度为 \(1,2,3,\dots,a\) 的连续 \(1\) 的贡献。

我们由于在暴力枚举答案，前面的贡献容易直接算掉，考虑判断剩下部分的贡献是否可以用由长度为 \(1,2,3,\dots,a\) 的连续 \(1\) 的贡献异或而成。

这个东西我们考虑 dp 预处理，设 \(f_{a,v}=\tt true\) 表示 \(v\) 可以由长度为 \(1,2,3,\dots,a\) 的连续 \(1\) 的贡献异或而成，反之则不能。

容易有一个 \(O(na2^n)\) 复杂度的 dp。

把 \(a\) 取遍 \(0\sim n\) 甚至 \(0\sim n+5\)，把结果打个表观察一下，容易发现，\(k>n/2\) 时总有 \(f_{k,v}=f_{k+4,v}\)。

证明感觉很复杂，我不会证，但是我把 \(n=2,\dots,20\) 中随机取了几个验证了一下，似乎都是对的。那就当做这是对的吧。

因此 \(a\) 更大的时候可以直接调用 \(a\) 很小的值，于是直接把 \(a\) 预处理到 \(n/2+4\) 是可行的！

总复杂度不会分析，但是应该是 \(O(n^22^n+Tn)\) 的，实测可以通过。

uint n;chr C[25];
bol Ok[21][1u<<20|1];
inline uint nxt(uint v){return(v<<1&((1u<<n)-1))|(v>>(n-1)&1);}
voi solve(){
    uint a=0,b=0;
    scanf("%s",C);for(uint i=0;i<n;i++)a|=(C[i]=='1')<<i;
    scanf("%s",C);for(uint i=0;i<n;i++)b|=(C[i]=='1')<<i;
    uint ans=0;
    while(!Ok[ans<=n/2?ans:(ans-n/2-1)%4+n/2+1][a])ans++,a^=b,b=nxt(b);
    printf("%u\n",ans);
}
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    uint t;scanf("%u%u",&t,&n);
    Ok[0][0]=1;
    for(uint i=1,v=1,t=1;i<=n/2+4;i++,v^=t=nxt(t))
        for(uint t=0;t<n;t++,v=nxt(v))for(uint j=0;j<(1u<<n);j++)
            Ok[i][j]|=Ok[i-1][j^v];
    // for(uint i=1;i<=n/2+4;i++,putchar('\n'))
    //     for(uint j=0;j<(1u<<n);j++)
    //         putchar('0'+Ok[i][j]);
    while(t--)solve();
    return 0;
}

Moo Route

http://usaco.org/index.php?page=viewproblem&cpid=1271

银组对应题目的计数版本！

把 \(a\) 除二，仅仅考虑向右的路径。

显然我们可以把向右的路径自上而下排成一排，使得上一行的右端点大于下一行的左端点。

对这些路径从左往右扫描，当前列应当剩下恰好 \(a\) 条路径。

假设扫描过程中某一步 \(a\) 变成了 \(a'\)。

当 \(a'>a\) 时，你要在之前的路径基础上增加 \(a'-a\) 条，并且均放在之前的某些路径的下面，方案数为 \(\binom{a'-1}{a-1}\)；之所以不能放在最上面一条路径的上面，是因为上一行的右端点应大于下一行的左端点。

当 \(a'\le a\) 时，你要从之前的路径中选出 \(a'\) 条留下，其余的删除，有 \(\binom a{a'}\) 种方案；这个不会影响后续插入时对方案数的分析，因为任意一个被删除的路径下面之后也不能再有路径了。

于是答案即为

\[\prod_{i=1}^{N-1}\begin{cases}\binom{A_i-1}{A_{i-1}-1}&(A_i>A_{i-1})\\\binom{A_{i-1}}{A_i}&(A_i\le A_{i-1})\end{cases}
\]

总复杂度 \(O(T)\)。（其中 \(T=\sum A\)）

（从某种角度上来看，这种做法其实质是构造了一个双射）

const ullt Mod=1e9+7;
typedef ConstMod::mod_ullt<Mod>modint;
typedef std::vector<modint>modvec;
modint P[4000005],Q[4000005];
uint A[100005];
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    // freopen("QAQ.out","w",stdout);
#endif
    P[0]=1;for(uint i=1;i<=4000000;i++)P[i]=P[i-1]*i;
    Q[4000000]=P[4000000].inv();for(uint i=4000000;i;i--)Q[i-1]=Q[i]*i;
    uint n;scanf("%u",&n);for(uint i=0;i<n;i++)scanf("%u",A+i),A[i]>>=1;
    // modint ans=Q[A[0]]*P[A[0]-1];
    modint ans=1;
    for(uint i=1;i<n;i++)
        if(A[i]<=A[i-1])ans*=P[A[i-1]]*Q[A[i]]*Q[A[i-1]-A[i]];
        else ans*=P[A[i]-1]*Q[A[i-1]-1]*Q[A[i]-A[i-1]];
    ans.println();
    return 0;
}

Platinum

力不从心，打不起哩。