庞果网 合法字符串

题目详情:
用n个不同的字符（编号1 - n），组成一个字符串，有如下2点要求：
    1、对于编号为i 的字符，如果2 * i > n，则该字符可以作为最后一个字符，但如果该字符不是作为最后一个字符的话，则该字符后面可以接任意字符；
    2、对于编号为i的字符，如果2 * i <= n，则该字符不可以作为最后一个字符，且该字符后面所紧接着的下一个字符的编号一定要 >= 2 * i。
问有多少长度为M且符合条件的字符串。
例如：N = 2，M = 3。则abb, bab, bbb是符合条件的字符串，剩下的均为不符合条件的字符串。


输入：n,m  (2<=n,m<=1000000000)；
输出：满足条件的字符串的个数，由于数据很大，输出该数Mod 10^9 + 7的结果。


函数头部
int validstring(int n,int m) {

}

代码如下：

 

import java.math.BigDecimal;

import java.util.LinkedList;

import java.util.Queue;



public class Main {

    public static int validstring(int n,int m) {

        if (n > 2 || m > 1000000000){

            System.err.println("‘n’或者‘m’超出范围了！");

            return 0;

        }

        long count = countValid(n, m);

        return BigDecimal.valueOf(count % (Math.pow(10, 9) + 7)).intValue();

    }

    

    //n个字符m位的全排列组合

    private static long countValid(int n, int m) {

        String v = "";

        long s = 0;

        char[] charArray = buildCharArray(n);

        // 队列用来保存被访问节点的分支节点(邻接点）

        Queue<String> que = new LinkedList<String>();

        que.offer(v);// 起点入队列

        while (!que.isEmpty()) {

            v = que.poll();// 弹出当前顶点

            // 将当前节点的分支节(邻接）点加入到队列中

            for (int i = 0; i < n; i++) {

                String u = v + charArray[i];

                if (u.length() == m) {//m位，则校验是不是符合题目的要求

                    if (checkStr(u, charArray, 0)){

                        System.out.println(u);

                        ++s;

                    }

                } else{

                    que.add(u); // 邻接点入队

                }

            }

        }

        return s;

    }

    

    //校验字符串是否符合规则

    private static boolean checkStr(String str, char[] charArray, int j){

        boolean returnFlag = false;

        int n = charArray.length;

        int m = str.length();

        char c = str.charAt(j);

        Integer i = getCharArrayIndex(charArray, c);

        //如果2 * i > n，则该字符可以作为最后一个字符，但如果该字符不是作为最后一个字符的话，则该字符后面可以接任意字符；

        if (2 * (i + 1) > n){

            if (j == m - 1){

                returnFlag = true;

            }else{

                returnFlag = checkStr(str, charArray, j + 1);

            }

        }else{//如果2 * i <= n，则该字符不可以作为最后一个字符，且该字符后面所紧接着的下一个字符的编号一定要 >= 2 * i。

            if (j == m - 1){

                returnFlag = false;

            }else{

                char d = str.charAt(j + 1);

                int ii = getCharArrayIndex(charArray, d);

                if (ii + 1 < 2 * (i + 1)){

                    returnFlag = false;

                }else{

                    returnFlag = checkStr(str, charArray, j + 1);

                }

            }

        }

        return returnFlag;

    }

    

    private static Integer getCharArrayIndex(char[] charArray, char c){

        Integer returnIndex = null;

        for (int i = 0; i < charArray.length; i++){

            char d = charArray[i];

            if (d == c){

                returnIndex = i;

            }

        }

        return returnIndex;

    }

    

    //产生1-n的随机字符

    private static char[] buildCharArray(int n){

        StringBuffer returnValue = new StringBuffer();

        for (int i = 0; i < n; i++){

            char c = 'a';

            c = (char)(c + i);

            returnValue.append(c);

        }

        return returnValue.toString().toCharArray();

    }



    //start 提示：自动阅卷起始唯一标识，请勿删除或增加。 

    public static void main(String args[]) 

    { 

           System.out.println(validstring(2, 10) + " 次");

    } 

    //end //提示：自动阅卷结束唯一标识，请勿删除或增加。

}