2019杭电多校第二场

6595 Everything Is Generated In Equal Probability

题意

给定一个(n)，从([1,n])中等概率取出一个数，再等概率生成一个(n)的全排列，再计算这个全排列的函数值，求这个函数值的期望。

函数表达为输入一个全排列，计算其逆序数，再等概率取出一个子序列(可以是空，可以是原序列)，递归计算该子序列的函数值，累加返回。

分析

• 暴力求出样例输出对应的分数，发现前三个答案就是(frac{0}{9}，)(frac{3}{9})和(frac{8}{9})，然后瞎猜几个规律((frac{n^2-1}{9}))也许就过了...
• 正解和证明：
  • 首先一个长度为(n)的全排列，逆序数的期望应该是(frac{C_n^2}{2})，即任取两个数产生逆序数的期望为(frac{1}{2})
  • 同时注意到全排列的子序列离散化之后也是一个全排列，因此这个递归的函数我们可以转化为递推式子
  • 设(f[i])表示取出数字为(i)所得到的函数值，因此(f[i]=frac{C_i^2}{2}+frac{1}{2^i}sum_{j=0}^iC_i^jf[j])。
  • 左右边都有(f[i])，将右边拆开并移项，得到(f[i]=frac{2^{i-1}}{2^i-1}frac{C_i^2}{2}+frac{1}{2^i-1}sum_{j=0}^{i-1}C_i^jf[j])(网上的题解基本都是推错的...官方题解也写的很模糊...)，而我们要求的答案就是(g[n]=frac{1}{n}sum_{i=1}^nf[i])。
  • 根据(f[i])的递推应该能推出通项？不过感觉最好的方法应该是根据样例即(g[1],g[2],g[3])推出接下来几项找规律更容易。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=998244353;
ll Pow(ll a,ll n){
    ll ans=1ll;
    while(n){
        if(n%2){
            ans=ans*a%mod;
        }
        a=a*a%mod;
        n/=2;
    }
    return ans;
}
ll inv(ll x){
    return Pow(x,mod-2)%mod;
}
ll n;
int main(void){
    ll inv9=inv(9);
    while(~scanf("%lld",&n)){
        printf("%lld
",(Pow(n,2)-1)*inv9%mod);
    }
    return 0;
}

6599 I Love Palindrome String

题意

给定一个字符串，询问(1-n)每种长度的回文子串有多少个，且必须满足前半部分也是回文串。

分析

• 回文树可以求出每个本质不同的回文串长度和个数，且最多只有(len(S))个，然后枚举每个回文子串，再判断前半部分是否是回文串。
• 回文串要判断前半部分是否回文，只需判断前半部分和后半部分是否相等即可，可以用字符串哈希。
• 所以这是一道回文树模板题，可以用来修正板子。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned ull;
const int N=3e5+50;
const ull base=19260817;
int ans[N];
ull has[N],pw[N];
void initHash(){
    pw[0]=1;
    for(int i=1;i<N;i++){
        pw[i]=pw[i-1]*base;
    }
}
ull getHash(int l,int r){
    return has[r]-has[l-1]*pw[r-l+1];
}
//判断回文串[l,r]，前后两部分是否相等，若是，说明是回文
bool check(int l,int r){
    int len=r-l+1;
    int mid=(l+r)/2;
    return getHash(l,mid)==getHash((len%2?mid:mid+1),r);
}
struct PT{
    int next[N][26],fail[N],cnt[N],num[N],len[N];
    int S[N],last,id[N],n,p;
    int newnode(int l){
        for(int i=0;i<26;i++){
            next[p][i]=0;
        }
        cnt[p]=num[p]=0;
        len[p]=l;
        return p++;
    }
    void init(){
        p=0;
        //先0再-1 这样-1(p=1)的儿子就是0(p=0)，后面0(p=0)的fail就是-1(p=1)
        newnode(0);
        newnode(-1);
        last=0;
        n=0;
        S[n]=-1;
        fail[0]=1;
    }
    int getFail(int x){
        while(S[n-len[x]-1]!=S[n]){
            x=fail[x];
        }
        return x;
    }
    void add(int c){
        c-='a';
        S[++n]=c;
        int cur=getFail(last);
        if(!next[cur][c]){
            int now=newnode(len[cur]+2);
            fail[now]=next[getFail(fail[cur])][c];
            num[now]=num[fail[now]]+1;
            next[cur][c]=now;
        }
        last=next[cur][c];
        cnt[last]++;
        id[last]=n;
    }
    void count(){
        for(int i=p-1;i>=0;i--){
            cnt[fail[i]]+=cnt[i];
        }
    }
    void getAns(){
        for(int i=2;i<p;i++){
            //枚举每个节点
            if(check(id[i]-len[i]+1,id[i])){
                ans[len[i]]+=cnt[i];
            }
        }
    }
}ac;
char s[N];
int main(void){
    // freopen("in.txt","r",stdin);
    initHash();
    while(~scanf("%s",s+1)){
        int n=strlen(s+1);
        ac.init();
        has[0]=0;
        for(int i=1;i<=n;i++){
            ac.add(s[i]);
            //这里记得别写成*10
            has[i]=has[i-1]*base+(s[i]-'a');
        }
        memset(ans,0,sizeof(ans));
        ac.count();
        ac.getAns();
        for(int i=1;i<=n;i++){
            printf("%d%c",ans[i],i==n?'
':' ');
        }
    }
    return 0;
}

6600 Just Skip The Problem

题意

通过询问确定一个数(x)，每次询问(y_i)，回答(x&y_i)是否等于(y_i)，问最少询问次数的方案数。

分析

• 显然是每次询问确定一位是最优的，可以通过计算期望证明。

• 所以(x)有(n)位数，就是有(n!)种不同的询问排列来确定这个数。

• 当(n>1e6+3)时，(n!)肯定含有因子(1e6+3)，因此结果为0。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e6+3;
ll n;
int main(void){
    while(~scanf("%lld",&n)){
        //n>=1e6+3 n!肯定含有1e6+3这个因子，所以结果一定为0
        if(n>=1000003){
            printf("0
");
            continue;
        }
        ll ans=1ll;
        for(ll i=2ll;i<=n;i++){
            ans=ans*i%mod;
        }
        printf("%lld
",ans);
    }
    return 0;
}

6601 Keen On Everything But Triangle

题意

给n个棍子，多次询问区间内能组成三角形的最大周长。

分析

• 如果不考虑不能组成三角形的情况，那么答案就是区间内前三大的值之和。

• 考虑有不能组合的情况，仍然是从大到小贪心地判断下一组能否组成三角形。

• 长度在1e9范围内，连续判断的次数不会超过44次。

• 证明就是斐波那契数列，假设连续的(n)个长度都不能组成三角形(1,1,10000000...这种肯定可以)，假设长度增长很慢，每次都只是刚好前两个木棍的和，那么这就是斐波那契数列，而第45项斐波那契数列已经超过了1e9

• 所以用主席树查询区间第k小。

代码

#include <bits/stdc++.h>
using namespace std;
#define mid (l+r)/2
typedef long long ll;
const int N=1e5+50;
int tr[N*30],sum[N*30],lr[N*30],rr[N*30];
int n,q,a[N],b[N],l,r;
int cnt;
int build(int l,int r){
    int rt=++cnt;
    sum[rt]=0;
    if(l==r){
        return rt;
    }
    lr[rt]=build(l,mid);
    rr[rt]=build(mid+1,r);
    return rt;
}
int update(int pre,int l,int r,int x){
    int rt=++cnt;
    lr[rt]=lr[pre];
    rr[rt]=rr[pre];
    sum[rt]=sum[pre]+1;
    if(l==r){
        return rt;
    }
    if(x<=mid){
        lr[rt]=update(lr[pre],l,mid,x);
    }else{
        rr[rt]=update(rr[pre],mid+1,r,x);
    }
    return rt;
}
int kth(int a,int b,int l,int r,int k){
    if(l>=r){
        return l;
    }
    int x=sum[lr[b]]-sum[lr[a]];
    if(k<=x){
        return kth(lr[a],lr[b],l,mid,k);
    }else{
        return kth(rr[a],rr[b],mid+1,r,k-x);
    }
}
int main(void){
    // freopen("in.txt","r",stdin);
    while(~scanf("%d%d",&n,&q)){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            b[i]=a[i];
        }
        //权值建树记得离散化
        sort(b+1,b+1+n);
        int m=unique(b+1,b+1+n)-b-1;
        //多组记得初始化
        cnt=0;
        //离散化后范围记得是m
        tr[0]=build(1,m);
        for(int i=1;i<=n;i++){
            a[i]=lower_bound(b+1,b+1+m,a[i])-b;
            tr[i]=update(tr[i-1],1,m,a[i]);
        }
        while(q--){
            scanf("%d%d",&l,&r);
            int len=r-l+1;
            ll ans=-1;
            while(len>=3){
                int aa=b[kth(tr[l-1],tr[r],1,m,len)];
                int bb=b[kth(tr[l-1],tr[r],1,m,len-1)];
                int cc=b[kth(tr[l-1],tr[r],1,m,len-2)];
                if(aa>=bb+cc){
                    len--;
                    continue;
                }
                ans=1ll*aa+1ll*bb+1ll*cc;
                break;
            }
            printf("%lld
",ans);
        }
    }
    return 0;
}