牛客编程巅峰赛S2第6场

A:https://ac.nowcoder.com/acm/contest/9715/A

牛牛想知道在[0,n]范围中，选取一个最大的数x，满足x%a=b，不过这个范围可能会很大，牛牛不知道该如何解决，所以他想请你帮忙。

给定如上所述的a,b,n，返回满足条件的最大的x。

签到题，代码：

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 返回满足条件的最大的x。
     * @param a int整型 代表题意中的a
     * @param b int整型 代表题意中的b
     * @param n int整型 代表题意中的n
     * @return int整型
     */
    public int solve (int a, int b, int n) {
        // write code here
        long x=n/a*a+b;
        if(x>n){
            x-=a;
        }
        return (int)x;
    }
}

B：https://ac.nowcoder.com/acm/contest/9715/B

给出一个仅包含小写字母的字符串s，你最多可以操作k次，使得任意一个小写字母变为与其相邻的小写字母（ASCII码差值的绝对值为1），请你求出可能的最长相等子序列（即求这个字符串修改至多k次后的的一个最长子序列，且需要保证这个子序列中每个字母相等）。

子序列：从原字符串中取任意多个字母按照先后顺序构成的新的字符串。

暴力枚举a-z：

import java.util.*;


public class Solution {
    /**
     * 
     * @param k int整型 表示最多的操作次数
     * @param s string字符串 表示一个仅包含小写字母的字符串
     * @return int整型
     */
    public int string2 (int k, String s) {
        // write code here
        int ans=0,i,j;
        char[] ch=s.toCharArray();
        Arrays.sort(ch);
        for(i='a';i<'z';i++){
            for(j=0;j<ch.length;j++){
                int t=k,r;
                for(r=j;r<ch.length;r++){
                    t-=Math.abs(ch[r]-i);
                    if(t<0)break;
                    ans=Math.max(ans,r-j+1);
                }
            }
        }
        return ans;
    }
}

C：https://ac.nowcoder.com/acm/contest/9715/C

音游狂热爱好者牛牛接到了一个新的任务，那就是给一张乐谱设计重音符。每当玩家敲击重音符的时候就会发出"bang"的美妙声音!!

每一张乐谱都有n个音符从左到右一字排开，现在牛牛的任务就是选出其中m个音符将其标记为重音符，同时任意两个重音符之间都必须隔着至少k个音符。

一个有意思的问题诞生了，请求出这样合法的设计方案种数，并输出答案对1000000007取模的结果。

数学题，排列组合，也可以用dp来写。

排列组合：n个音符中选择m个，要求两两间隔至少为k。等价于在n-(m-1)*k个音符中选择m个音符(拿走间隔音符，选重音符)。所以答案是C(n -(m-1)* k, m)，因为数字太大可以用逆元来求组合：

import java.util.*;


public class Solution {
    /**
     * 
     * @param n int整型 乐谱总音符数
     * @param m int整型 重音符数
     * @param k int整型 重音符之间至少的间隔
     * @return long长整型
     */
    int mod=(int)(1e9+7);
    int[] jc=new int[100005];
    int[] ny=new int[100005] ;
    long ksm(long a,long b) //快速幂a的b次
    {
        long ans=1;
        while(b!=0)
        {
            if((b&1)==1){
                ans=ans*a%mod;
            }
            a=a*a%mod;
            b>>=1;
        }
        return ans;

    }
    long c(int n,int m)  //求组合数
    {
        return 1L*jc[m]*ny[n]%mod*ny[m-n]%mod;  //m的阶乘*n阶乘的逆元*（m-n）阶乘的逆元
    }


    public long solve_bangbang (int n, int m, int k) {
        if ((m - 1) * k + m > n) return 0;
        if (m == 0) return 1;
        if (m == 1) return n - 1;
        // write code here
        jc[0]=jc[1]=ny[0]=ny[1]=1;
        for(int i=2;i<100005;i++) //预处理jc数组和ny数组
        {
            jc[i]=jc[i-1]*i%mod;
            ny[i]=(int)ksm(jc[i],mod-2);
        }
        return c(m,n+k-m*k);
    }
}

逆元线性筛：

import java.util.*;


public class Solution {
    /**
     * 
     * @param n int整型 乐谱总音符数
     * @param m int整型 重音符数
     * @param k int整型 重音符之间至少的间隔
     * @return long长整型
     */
    int mod=(int)(1e9+7);
    long[] fac=new long[10005];
    long[] inv=new long[10005] ;
    long[] fi=new long[10005] ;
    long c(int x,int y){
        return 1L*fac[x]*fi[y]%mod*fi[x-y]%mod;
    }

    public long solve_bangbang (int n, int m, int k) {
        if ((m - 1) * k + m > n) return 0;
        if (m == 0) return 1;
        if (m == 1) return n - 1;
        // write code here
        fac[0]=fac[1]=inv[1]=fi[0]=fi[1]=1;
        for(int i=2;i<=10000;i++){
            fac[i]=1L*fac[i-1]*i%mod;
            inv[i]=1L*(mod-mod/i)*inv[mod%i]%mod;//逆元
            fi[i]=1L*fi[i-1]*inv[i]%mod;
        }
        return c(n+k-m*k,m);
    }
}

或者用dp去递推组合公式也可以：

import java.util.*;


public class Solution {
    /**
     * 
     * @param n int整型 乐谱总音符数
     * @param m int整型 重音符数
     * @param k int整型 重音符之间至少的间隔
     * @return long长整型
     */
    int mod=(int)(1e9+7);
    long[][] dp=new long[2005][2005];
    long c(int x,int y){
        if(y > x) return 0;
        return dp[x][y];
    }

    public long solve_bangbang (int n, int m, int k) {
        // write code here
        if ((m - 1) * k + m > n) return 0;
        if (m == 0) return 1;
        if (m == 1) return n - 1;
        for(int i = 0; i <=n; i++)
        {
            dp[i][0] = 1L;
            for(int j = 1; j < i; j++)
                dp[i][j] = (c(i - 1, j - 1) + c(i - 1, j)) % mod;
            dp[i][i] = 1L;
        }
        return c(n+k-m*k,m);
    }
}

 

这题本身也有个dp的状态方程：

dp[i][j]表示把第i个音符放在第j个位置的方案数

则有：dp[i][j]=dp[i][j-1]+dp[i-1][j-k-1]

import java.util.*;

public class Solution {
    /**
     * 
     * @param n int整型 乐谱总音符数
     * @param m int整型 重音符数
     * @param k int整型 重音符之间至少的间隔
     * @return long长整型
     */
    //int ans;
    
    public long solve_bangbang (int n, int m, int k) {
        if (m == 0) return 1;
        // write code here
        int[][] dp = new int[m][n];
        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }
        for (int i = 1; i < m; i++) {
            for (int j = k + 1; j < n; j++) {
                dp[i][j] = (dp[i][j - 1] + dp[i - 1][j - k - 1]) % 1000000007;
            }
        }
        int ans = 0;
        for (int i = 0; i < n; i++) {
            ans = (ans + dp[m - 1][i]) % 1000000007;
        }
        return ans;
    }
}