上台阶

一、题目

有n级台阶。从地面（第0级）出发，首先连续的上台阶，上到不超过第n级的某一个位置后再连续的下台阶，
直到回到地面。若每次上下台阶只允许走1级或2级，请问可能的上下台阶的方案数是多少？
特别地，在0级站着不动也算一种方案。
数据格式：

输入一行包含两个正整数n和m。
输出一个整数，表示n级台阶有多少种合法的走楼梯方案，答案对m取余。

例如：输入：
2 10007
程序应该输出
6

【样例说明1】
共有6种方案(其中+表示上台阶，-表示下台阶)：
(1) 原地不动
(2) +1 -1
(3) +2 -2
(4) +2 -1 -1
(5) +1 +1 -2
(6) +1 +1 -1 -1

再例如，输入：
3 14
程序应该输出：
1

【样例说明2】
共有15种方案，对14取余后得1。

【数据规模】
对于30%的数据，n<=10000；
对于100%的数据，n<=10^17，m<=2*10^9。


资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms


请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

二、分析

斐波那契数列:
1,1,2,3,5,,,,,,n
过程:
1、当只有1个台阶时，上台阶时有1种方式，下台阶时也是1种方式，那么走1阶楼梯方式有1+1*1种，即2种。(注:第一个1代表待在原地不动，1*1则代表上台阶时的方式*下台阶时的方式。
2、当只有2个台阶时，上台阶时有2种方式，下台阶时也是2种方式，那么走2阶楼梯方式有1+1*1+2*2种，即6种。
3、当只有3个台阶时，上台阶时有3种方式，下台阶时也是3种方式，那么走
3阶楼梯方式有1+1*1+2*2+3*3种，即15种。

通过上述描述便可以发现与斐波那契数列的关系，由此便可以写出相应的代码。

数据规模为n<=10^17，m<=2*10^9，故采用了矩阵快速幂的方法来求解斐波那契数，参考http://blog.youkuaiyun.com/xiaofengcanyuelong/article/details/79317195

public class Question7 {
    public static void main(String[] args) {
        String string[] = new String[2];
        int n, k, sum = 0;
        Scanner scanner = new Scanner(System.in);
        string = scanner.nextLine().split(" ");
        n = Integer.parseInt(string[0]);
        k = Integer.parseInt(string[1]);
        int a[] = new int[n + 1];
        for (int i = 1; i < a.length; i++) {
            a[i] = f(i);
            sum = sum + a[i] * a[i];
        }
        System.out.println((sum + 1) % k);//输出结果
    }

    public static int f(int n) {
        if (n == 1 || n == 0) {
            return 1;
        } else {
            return getResult(n);
        }
    }

    /*
     * 矩阵快速幂求斐波那契数
     */
    public static int getResult(int n) {
        long[][] base = { { 1, 1 }, { 1, 0 } };
        long[][] ret = { { 1, 0 }, { 0, 1 } };
        while (n != 0) {
            if (n % 2 == 1) {
                ret = Mul(ret, base);
            }
            base = Mul(base, base);
            n = n >> 1;
        }
        return (int)ret[0][0];
    }
    /*
     * 矩阵相乘
     */
    public static long[][] Mul(long[][] ret, long[][] base) {
        long[][] temp = new long[2][2];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                temp[i][j] = (ret[i][0] * base[0][j] + ret[i][1] * base[1][j]) % 1000000007;
            }
        }
        for (int k = 0; k < 2; k++)
            for (int q = 0; q < 2; q++)
                ret[k][q] = temp[k][q];
        return ret;
    }

}

Don’t part with your illusions.When they are gone you may still exist,but you have ceased to live.