2019牛客暑期多校训练营（第五场）

传送门

 

参考资料：

　　[1]:官方题解（提取码：ppi6）

 

B.generator 1(矩阵快速幂)

•题意

　　已知 $f_{i}=af_{i-1}+bf_{i-2}$;

　　输入 f₀,f₁,a,b,n,mod；

　　求 f_n%mod ；

•题解

　　矩阵快速幂入门习题；

　　首先将递推式转化为矩阵乘法表达式：

　　$\left( \begin{array}{cc} f_{i} \\ f_{i-1} \end{array}\right)=\left( \begin{array}{cc} a&b \\ 1&0 \end{array}\right)\cdot\left( \begin{array}{cc} f_{i-1} \\ f_{i-2} \end{array}\right)$

　　不妨令 $\mathbf{A_{i}} =\left( \begin{array}{cc} f_{i} \\ f_{i-1} \end{array}\right)$ , $\mathbf{T} =\left( \begin{array}{cc} a&b \\ 1&0 \end{array}\right)$;

　　那么，原式可化为 $A_{i}=T\cdot A_{i-1}=T^{2}\cdot A_{i-2}= \cdots = T^{i-1}\cdot A_{1}$;

　　处理完递推式后，是不是就大功告成了？

　　no,no,no;

　　还差最后一步，如何处理 $T^{n-1}$ ？

　　n 很大很大很大；

　　考虑到秦九韶算法，将 n 分解；

　　假设 n-1 = 3194;

　　那么 n 可分解为 $n=\bigg(\Big(\big((3\times 10)+1\big)\times 10+9\Big)\times 10+4\bigg)$;

　　在计算 $T^{3194}$ 时，可以按照字符串的位数进行处理；

　　先计算 ans = T³;

　　ans = ans¹⁰·T¹;(ans=T³¹)

　　ans = ans¹⁰·T⁹;(ans = T³¹⁹)

　　ans = ans¹⁰·T⁴;(ans = T³¹⁹⁴)

•Code

#include<bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define ll long long
const int N=5;
const int maxn=1e6+50;

int f[2];
int a,b,mod;
char s[maxn];
struct Matrix
{
    ll A[N][N];

    Matrix()
    {
        mem(A,0);
    }
    void Init()
    {
        for(int i=0;i < N;++i)
            A[i][i]=1;///构造单位阵
    }
}t,ans;

Matrix mult(Matrix a,Matrix b)///a*b
{
    Matrix tmp;
    for(int i=1;i <= 2;++i)
        for(int j=1;j <= 2;++j)
            for(int k=1;k <= 2;++k)
            {
                tmp.A[i][j] += a.A[i][k]*b.A[k][j]%mod;
                tmp.A[i][j] %= mod;
            }
    return tmp;
}
Matrix qPow(Matrix a,int b)///a^b
{
    Matrix tmp;
    tmp.Init();

    while(b)
    {
        if(b&1)
            tmp=mult(tmp,a);
        a=mult(a,a);
        b >>= 1;
    }
    return tmp;
}
int Solve()
{
    ans.Init();
    t.A[1][1]=a;
    t.A[1][2]=b;
    t.A[2][1]=1;

    int len=strlen(s+1);
    for(int i=len;;--i)
    {
        if(s[i] != '0')
        {
            s[i]--;
            for(int j=i+1;j <= len;++j)
                s[j]='9';
            break;
        }
    }

    for(int i=1;i <= len;++i)
    {
        ans=qPow(ans,10);///ans^10
        ans=mult(ans,qPow(t,s[i]-'0'));///ans*t^(s[i]-'0')
    }
    return (ans.A[1][1]*f[1]%mod+ans.A[1][2]*f[0]%mod)%mod;
}
int main()
{
    scanf("%d%d",f+0,f+1);
    scanf("%d%d",&a,&b);
    scanf("%s",s+1);
    scanf("%d",&mod);

    printf("%d\n",Solve());

    return 0;
}

 

 

---

G.subsequence(DP)

•题意

　　给你两个只包含字符 '0'~'9' ，长度分别为 n,m 的字符串 s,t；

　　求 s 的子序列 s' 的个数，满足 s' > t;

•题解

　　定义 dp[ i ][ j ] 表示 s 的前 i 个字符组成的子序列 > t₁t₂t₃...t_j 的子序列的总个数；

　　首先，预处理出 dp[ i ][ 1 ];

　　该如何处理呢？

　　dp[ i ][ 1 ] = 2ⁱ - 1 - illegal;

　　illegal 指的是不合法的子序列个数，即 s 的前 i 个字符组成的所有的子序列中 < t₁ 的子序列个数；

　　不合法的子序列主要包含两类：1.存在 s_i ≤ t₁ , 2.以0开头的子序列；

　　预处理出 dp[ i ][ 1 ] 后，接下来就是状态转移了；

　　　　dp[ i ][ j ] = dp[ i-1][ j ] + dp[ i-1][ j-1];

　　如果由 s 的前 i-1 个字符组成的子序列 s' 都满足 s' >  t₁t₂...t_j 的话，那么肯定有 s's_i > t₁t₂...t_j ；

　　如果由 s 的前 i-1 个字符组成的子序列 s' 都满足 s' >  t₁t₂...t_j-1 的话，那么肯定有 s's_i > t₁t₂...t_j-1t_j ；

　　当然，如果 s_i ≤ t_j ，上述两种情况便是 dp[ i ][ j ] 的全部情况；

　　如果 s_i > t_j 呢？

　　那是不是就漏掉了“由 s 的前 i-1 个字符组成的子序列 s' 满足 s' ==  t₁t₂...t_j”这种情况了？

　　这种情况该如何处理呢？

　　定义 $f_{i,j}$ 表示由s的前 i 位组成的子序列==t₁t₂...t_j 组成的子序列的总个数；

　　提前预处理出 $f_{i,j}$；

　　然后，在处理 s_i > t_j 的情况的时候，令 dp[ i ][ j ] 额外加上 f[ i-1][ j-1] 就好了；

•Code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
const int MOD=998244353;
const int maxn=3e3+50;

int n,m;
char s[maxn];
char t[maxn];
ll dp[maxn][maxn];///dp[i][j]:由s的前i位组成的子序列>t1,t2,...,tj组成的子序列的总个数
ll f[maxn][maxn];///f[i][j]:由s的前i位组成的子序列==t1,t2,...,tj组成的子序列的总个数
vector<int >v;

ll qPow(ll a,ll b)
{
    ll ans=1;
    a %= MOD;

    while(b)
    {
        if(b&1)
            ans=ans*a%MOD;
        a=a*a%MOD;
        b >>= 1;
    }
    return ans;
}
void initf()
{
    for(int i=1;i <= n;++i)
    {
        f[i][1]=f[i-1][1];
        if(s[i] == t[1])
            f[i][1]++;

        f[i][1] %= MOD;
    }
    for(int j=2;j <= m;++j)
    {
        for(int i=1;i <= n;++i)
        {
            f[i][j]=f[i-1][j];
            if(s[i] == t[j])
                f[i][j] += f[i-1][j-1];

            f[i][j] %= MOD;
        }
    }
}
void Initdp()
{
    for(int i=1;i <= n;++i)
        dp[i][1]=(qPow(2,i)-1+MOD)%MOD;

    int cnt=0;
    v.clear();
    for(int i=1;i <= n;++i)
    {
        if(s[i] == '0')///记录所有s[i]=='0'的位置
            v.push_back(i);

        if(s[i] <= t[1])
            cnt++;
        dp[i][1] -= cnt;///去掉si <= t1 的个数
        dp[i][1]=(dp[i][1]+MOD)%MOD;
    }
    for(int i=1;i <= n;++i)///去掉前导0的个数
    {
        for(int j=0;j < v.size();++j)
        {
            if(v[j] >= i)
                break;
            dp[i][1]=(dp[i][1]-(qPow(2,i-v[j])-1)+MOD)%MOD;
        }
    }
}
ll Solve()
{
    for(int i=0;i <= n;++i)
        for(int j=0;j <= m;++j)
            f[i][j]=dp[i][j]=0;

    initf();///预处理f
    Initdp();///预处理dp[i][1]

    for(int i=2;i <= n;++i)
    {
        for(int j=2;j <= min(i,m);++j)
        {
            dp[i][j]=dp[i-1][j]+dp[i-1][j-1];
            if(s[i] > t[j])
                dp[i][j] += f[i-1][j-1];
            dp[i][j] %= MOD;
        }
    }
    return dp[n][m]%MOD;
}
int main()
{
//    freopen("C:\\Users\\hyacinthLJP\\Desktop\\in&&out\\contest","r",stdin);
    int test;
    scanf("%d",&test);
    while(test--)
    {
        scanf("%d%d",&n,&m);
        scanf("%s%s",s+1,t+1);

        printf("%lld\n",Solve());
    }
    return 0;
}

 

 

 

---

H.subsequence 2(拓扑序)

•题意

　　有一个长度为 n 的隐藏字符串 s；

　　s 中只包含小写英文字母的前 m 个字母；

　　现在给你 $\frac{m\times (m-1)}{2}$ 对关系，每对关系给你一个只包含两种字符串；

　　让你还原 s 使得其满足上述 $\frac{m\times (m-1)}{2}$ 对关系的相对位置；

　　如果不存在这样的 s，输出 -1；

•题解

　　

•Code

#include<bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn=1e4+50;

int n,m;
int cnt;
int a[30];
int in[maxn];
char s[maxn];
bool vis[30];
vector<int >p[30];
map<int ,char>f;
int num;
int head[maxn];
struct Edge
{
    int to;
    int next;
}G[maxn*10];
void addEdge(int u,int v)
{
    G[num]=Edge{v,head[u]};
    head[u]=num++;
}
vector<int >ans;
bool vis2[maxn];

void DFS(int u)
{
    ans.push_back(u);
    vis2[u]=true;

    for(int i=head[u];~i;i=G[i].next)
    {
        int to=G[i].to;
        if(!vis2[to])
            in[to]--;
    }
    for(int i=head[u];~i;i=G[i].next)
    {
        int to=G[i].to;
        if(!vis2[to] && !in[to])
            DFS(to);
    }
}
void Solve()
{
    int x;
    for(int i=1;i <= cnt;++i)
        if(!in[i])
            x=i;

    mem(vis2,false);
    DFS(x);

    if(ans.size() != n)
    {
        puts("-1");
        return ;
    }
    
    for(int i=0;i < ans.size();++i)
        printf("%c",f[ans[i]]);
    printf("\n");
}
void Init()
{
    num=0;
    mem(head,-1);
    mem(vis,false);
    mem(in,0);
}
int main()
{
//    freopen("C:\\Users\\hyacinthLJP\\Desktop\\in&&out\\contest","r",stdin);
    Init();
    scanf("%d%d",&n,&m);

    cnt=0;///莫名bug，cnt定义成局部的就出错
    for(int k=1;k <= m*(m-1)/2;++k)
    {
        char ch[2];
        int len;
        scanf("%s%d",ch,&len);
        if(len > 0)
            scanf("%s",s+1);

        for(int i=1;i <= len;++i)
        {
            int cur=s[i]-'a';

            if(vis[cur])
                continue;

            p[cur].push_back(++cnt);
            f[cnt]=cur+'a';
        }

        vis[ch[0]-'a']=true;
        vis[ch[1]-'a']=true;

        a[ch[0]-'a']=0;
        a[ch[1]-'a']=0;

        for(int i=1;i < len;++i)
        {
            int u=s[i]-'a';
            int v=s[i+1]-'a';
            
            a[u]++;
            addEdge(p[u][a[u]-1],p[v][a[v]]);

            in[p[v][a[v]]]++;
        }
    }
    Solve();
    return 0;
}