2016弱校联萌十一专场10.5

Posted DGUT_FLY

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2016弱校联萌十一专场10.5相关的知识,希望对你有一定的参考价值。

A.

因为字符串不可以交叉,其实容易解

把不同字符的可用区域看成一个区间,用类似于链表的方法连接起来

查询的就是查询到的链表数量/4(当然右区间必须属于y)

区间查询用倍增或线段树都可以

//倍增
#include <cstdio>
#include <cstring>

char s[100005];
int m, n, pe, pa, ps, py, dep;
int pre[100005], ed[100005];
int fa[100005][20];

int main() {
    scanf("%s", s);
    scanf("%d", &m);
    n = strlen(s);
    for (int i = 0; i < n; ++i) {
        if (s[i] == \'e\') {
            pre[i + 1] = py;
            pe = i + 1;
        }
        if (s[i] == \'a\') {
            pre[i + 1] = pe;
            pa = i + 1;
        }
        if (s[i] == \'s\') {
            pre[i + 1] = pa;
            ps = i + 1;
        }
        if (s[i] == \'y\') {
            pre[i + 1] = ps;
            py = i + 1;
        }
        ed[i + 1] = py;
    }
    for (int i = 1; i <= n; ++i) fa[i][0] = pre[i];
    for (dep = 1; 1 << dep < n; ++dep);
    for (int i = 1; i < dep; ++i)
        for (int j = 1; j <= n; ++j)
            fa[j][i] = fa[fa[j][i - 1]][i - 1];
    for (; m--;) {
        int l, r;
        scanf("%d%d", &l, &r);
        int x = ed[r];
        int res = 1;
        for (int i = dep - 1; i >= 0; --i) {
            if (fa[x][i] >= l) {
                x = fa[x][i];
                res += 1 << i;
            }
        }
        printf("%d\\n", res / 4);
    }
    return 0;
}
View Code

 

B.

给一堆点,要求连最小生成树,注:边的权值是两边点的权值异或和。

对整个点集合的权值建0/1 trie树

可以把一个结点当成对应的点集合

如果此点只有1子树则此结点集合就是下面一层那点的

否则此点对应连接左右两子树对应集合的最小权值边

trie树碰到有左右子树的,对1个子树暴力查询另1子树的元素,得到最小异或和权值o(nlogm)

如果没有想到把2个子树以o(n)的时间合并的方法就老实1个1个合并先

再说可能时间也不够

但是真的没想到有人真的就把2个子树以o(n)的时间合并了

整个合并也不是不可以,不过这样就要搞vector储存每一层的结点可能性(跟我那时想到一块去了。。。只不过我怕复杂度太高不敢下码)

并且如果能找到异或位0的位置就必须置一样

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, tot;
ll ans;
int a[4000009][2];
int num[4000009];
int dp[400009], dd[400009];
int dp1[400009], dd1[400009];
void add(int x)
{
    int q = 0;
    ++num[0];
    for(int i = 30; ~i; --i)
    {
        bool w = x >> i & 1;

        if(!a[q][w])
        {
            a[q][w] = ++tot;
        }
        ++num[q = a[q][w]];
    }
}
void zz(int x, int t)
{
    if(t == -1)return ;
    int l = a[x][0], r = a[x][1];
    if(l && num[l] > 1)zz(l, t - 1);
    if(r && num[r] > 1)zz(r, t - 1);
    if(!l || !r)return ;
    if(num[l] && num[r])
    {
        int q = 1 << t, *q1 = dp, *w1 = dd, *q2 = dp1, *w2 = dd1, num1 = 1, num2;
        q1[0] = l;
        w1[0] = r;
        for(int i = t - 1; ~i; --i)
        {
            bool f = 1;
            for(int j = 0; j < num1; ++j)
            {
                if((a[q1[j]][0]&&a[w1[j]][0]&&num[a[q1[j]][0]] && num[a[w1[j]][0]]) 
                || (a[q1[j]][1]&&a[w1[j]][1]&&num[a[q1[j]][1]] && num[a[w1[j]][1]]))
                {
                    f = 0;
                    break;
                }
            }
            num2 = 0;
            for(int j = 0; j < num1; ++j)
            {
                if(a[q1[j]][0]&&a[w1[j]][f]&&num[a[q1[j]][0]] && num[a[w1[j]][f]])
                {
                    q2[num2] = a[q1[j]][0];
                    w2[num2++] = a[w1[j]][f];
                }
                if(a[q1[j]][1]&&a[w1[j]][1 ^ f]&&num[a[q1[j]][1]] && num[a[w1[j]][1 ^ f]])
                {
                    q2[num2] = a[q1[j]][1];
                    w2[num2++] = a[w1[j]][1 ^ f];
                }
            }
            swap(q1, q2);
            swap(w1, w2);
            swap(num1, num2);
            if(f)q |= 1 << i;
        }
        ans += q;
    }
}
int main()
{
    ans=0;
    scanf("%d", &n);
    for(int i = 0; i < n; ++i)
    {
        int p;
        scanf("%d", &p);
        add(p);
    }
    zz(0, 30);
    printf("%lld\\n", ans);
}
View Code

 

C.

给m个空环,其中第i个长度为si,把1~sum(s)这些数填上去,要求相邻数互质,并输出具体排布,填不下去则输出"QQ"

还好题目的复杂度较低。。。

不能做到偶数之间至少隔1格,环就不能填,否则肯定能填上环(别问我怎么知道的,我也是靠直觉,n~n+1个奇数肯定能对上n个互质的偶数)

先看m个环能否容下总的偶数个数,不能就是无解。

然后这题是special judge,可以随便组。

我的方法:先把1~sum(s)这些数链按照题目给的环长切成对应环(gcd(n,n+1)==1,所以相邻数肯定互质)

然后看那几个环头尾是否互质,不是则遍历左边的环,找出交换数后两个环继续满足互质链的位置,然后交换。

查找次数可达2000*500*6=6000000,实际第2个环可能交换不了那么多次,第3、4也不用整个环都遍历一次

 

D.

给多个点,对任意2个点连边(不与点或线相交),谁先画不了谁输,问谁能在最佳策略下赢

其实不管怎么连都是三角剖分,所以不存在什么需要博弈论的东西

求三角剖分后总的边数是否偶数即可

发现一个凸包多加点使其仍为凸包,相当于向外多加2条边;在凸包内部加点,相当于加3条边

然后规律就出来了

 

E.

一个n*m棋盘,问能走遍棋盘的骑士棋种类数(只有一次向xy两轴走至少1格并不走出棋盘的骑士)

可以知道不能走所有格的骑士有这些情况:

设dx<=dy,n<=m

gcd(dx,dy)!=1 骑士只能走指定的格集合

(dx+dy)%2==0 那些(x+y)%2==1的点走不到

dy>m/2 骑士不能走2个方向,使得一些点走不到

dx+dy>n 中间区域无法到达

老规矩,用莫比乌斯容斥

由于还有奇偶判定,直接算还是有些麻烦

祭出公式:1<=k<=min(m,n) miu(k)*f(floor(m/k),floor(n.k))

其中f(m,n)就是不包括dx dy不互质,除去上述无法走全棋盘的骑士种类数

由于处于gcd(dx,dy)%2==0的格子肯定会被除去,上述公式的k是不算偶数的

f(m,n) o(1)求出,答案因为floor()可以归并某些答案的关系,可以o(sqrt(min(m,n)))

 

F.

求f(f(n))%20160519,其中f(0)=0 f(1)=1 f(i)=f(i-1)+f(i-2)

fib数列其实有循环节的,当运行到f(k-1)%k==k-1 f(k)==1 那循环节就是k

顺带补下这种数列的循环节知识:

当模数是质数模5余1或4,则这种数是5的二次剩余,则循环节是p-1的因子

当模数是质数模5余2或3,则这种数是5的二次非剩余,则循环节是2p+2的因子

当模数是合数,p=p1^a1*p2^a2*.....

可以想到积性函数,循环节是lcm(p1^(a1-1)*(p1的对应循环节数)*p2^(a2-1)*(p2的对应循环节数)*...)

lcm(...)是里面所有数的最小公倍数

然后快速幂一波AC

 

H.

题意:只有\'A\'-\'Z\'的字符串*s对应hash函数是这样得到的:h=0;for(i=0;i<n;i++)h=((h*p)+s[i])%m,给n,m,p问长度为n的字符串会哈希冲突的对数

用数位dp的思想可以知道,设dp(n,h)是长度n且哈希值为h的字符串个数,则dp(n,h)=for(i=0;i<m;i++)d(n1,i)*d(n-n1,(h-i*p^n1)mod m)

把第1维相同的值组成一个向量,可以发现其实就是多项式乘法

但是不可能真的就n次递推,那样o(nm*logn)超时

但是我们会发现,这个式子可以当成向量卷积

所以拆分dp的方法可以像快速幂一样,储存第1维是2^n的向量就可以,然后结果向量看当前n扫描到的2进制位是1是0决定乘不乘

多项式乘法可以FFT(喂精度被你吃了?)NTT(用CRT合并2个小素数模下结果就可以,或者直接long long快速乘)=>o(nlogmlogn)

 

I.

题意:求出[l,r]所有单调不递增||单调不递减数

数位dp,没得说的,注意常数太大,o(10logn)会超时

所以就愉快地记忆化搜索,把指定位置是包括0~9位的全部填上

或者直接开场直接处理9、99、999...这些数的对应计数

这样就可以o(logn)胡搞了

果然不应该搞这么久的。。。比赛哪有那么多时间给你搞

以上是标准做法,已AC,我的非主流做法在下:

我是想用前缀和把搜索过程的复杂度压缩一下的,结果WA

大神求教

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<stdlib.h>
#include<cmath>
#include<string>
#include<algorithm>
#include<iostream>
#include<assert.h>
using namespace std;
typedef long long ll;
int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}

ll fac[21];
ll tal[20][10][2],pre[20][10][2];
//0:down,1:all
ll f(int n){return n<0?0:fac[n];}
void gettal()
{
    fac[0]=1;
    memset(tal,0,sizeof(tal));
    memset(pre,0,sizeof(pre));
    int i,j;
    for(i=1;i<21;i++)fac[i]=fac[i-1]*i;
    for(i=0;i<10;i++)tal[0][i][1]=1,tal[0][i][0]=0,pre[0][i][1]=pre[0][i][0]=i+1;
    for(i=1;i<20;i++)
    {
        for(j=0;j<10;j++)
        {
            tal[i][j][0]=j==0?0:f(i+j-1)/f(j-1)/f(i);
            tal[i][j][0]+=tal[i-1][j][0];

            tal[i][j][1]=tal[i][j][0]+tal[i-1][j][1]-tal[i-1][j][0];
            tal[i][j][1]+=j==9?0:f(8-j+i)/f(8-j)/f(i);

            pre[i][j][0]=j?pre[i][j-1][0]+tal[i][j][0]:tal[i][j][0];
            pre[i][j][1]=j?pre[i][j-1][1]+tal[i][j][1]:tal[i][j][1];
        }
    }
}
ll solve(ll n)
{
    if(!n)return 1;
    int i,j,path,ph;
    ll tmp,ans=0;
    for(i=0,tmp=1;n>=tmp;i++,tmp*=10);i--;tmp/=10;
    int stat=1;
    path=n/tmp;
    ans+=pre[i][path-1][1]-pre[i][0][1];
    tmp/=10;
    for(i--;i>0;i--)
    {
        ans+=pre[i][9][1]-pre[i][0][1];
        ph=(n%(tmp*10))/tmp;
        if(stat==1)//keep
        {
            if(path>ph){stat=0;if(ph)ans+=pre[i][ph-1][0]+ph;}
            else if(path==ph){if(ph)ans+=pre[i][ph-1][0]+ph;}
            else
            {
                stat=2;
                ans+=pre[i][ph-1][0]+ph;
                ans+=tal[i][ph][1],
                ans+=pre[i][ph-1][1]-pre[i][path][1];
                ans-=pre[i][ph-1][0]-pre[i][path][0];
            }
            path=ph;
        }
        else if(stat==2)//increase
        {
            if(path>ph)
            {
                stat=3;
                break;
            }
            ans+=pre[i][ph-1][1]-pre[i][path-1][1]-pre[i][ph-1][0]+pre[i][path-1][0];
            path=ph;
        }
        else if(stat==0 && path)//decrease
        {
            if(ph)ans+=pre[i][min(path,ph)-1][0]+min(path,ph);
            path=min(path,ph);
        }
        tmp/=10;
    }
    ans+=pre[0][9][1];
    ph=(n%(tmp*10))/tmp;
    if(stat==0)ans+=min(path,ph)+1;
    else if(stat==1)ans+=ph+1;
    else if(stat==2)ans+=max(0,ph-path+1);
    return ans;
}
int main()
{
    int t;
    ll l,r;
    gettal();
    scanf("%d",&t);
    while(t--)
    {
        scanf("%lld%lld",&l,&r);
        printf("%lld\\n",solve(r)-solve(l-1));
    }
    return 0;
}
View Code

 

J.

题意。。。实在难以描述,看https://acm.bnu.edu.cn/v3/statments/taiwan2016.pdf吧

这题一看像是多项式乘法,但是下面的不是加而是取其最大,所以什么fft,nft都可以歇歇了

其实也不难想到解法,把最大数填上对应位置,之后从大到小填,碰到已填元素就跳过

直到整个表都填满为止

为什么这样看似o(n^2)的解法不会超时。。。我也不知道。。。

写时SB了,数组开成10^5结果老RE

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<stdlib.h>
#include<cmath>
#include<string>
#include<algorithm>
#include<iostream>
#include<assert.h>
using namespace std;
typedef long long ll;
int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}
int a[2][200060];
int occupy[200060];
int main()
{
    int n,j,i,t;
    memset(occupy,-1,sizeof(occupy));
    scanf("%d",&n);
    for(j=0;j<2;j++)
    {
        for(i=0;i<n;i++)
        {
            scanf("%d",&t);
            a[j][t]=i;
        }
    }
    int cnt=n;
    for(i=n*2-2;cnt;i--)
    {
        for(j=max(0,i-n+1);j<n && cnt;j++)
        {
            if(i<j)continue;
            if(i-j>=n)break;
            t=a[0][j]+a[1][i-j];
            if(occupy[t%n]==-1)occupy[t%n]=i,cnt--;
        }
    }
    for(i=0;i<n;i++)printf("%d%c",occupy[i],i==n-1?\'\\n\':\' \');
    return 0;
}
View Code

 

以上是关于2016弱校联萌十一专场10.5的主要内容,如果未能解决你的问题,请参考以下文章

2016弱校联萌十一专场10.2

弱校联萌十一大决战之背水一战C. Counting Pair

西南弱校联萌

(2016弱校联盟十一专场10.5) F. Fibonacci of Fibonacci

(2016弱校联盟十一专场10.3)DParentheses

2016弱校联盟十一专场10.3---Similarity of Subtrees(深搜+hash映射)