Java算法(二)：力扣：斐波那契数、爬楼梯、杨辉三角、杨辉三角Ⅱ、比特位计数

本周自己暂时还未学习动态规划，所以有两道算法题：最小花费爬楼梯、不同路径 还没写。等学完动态规划之后补上。

1.斐波那契数

/*
        斐波那契数列（从0开始）
    */
    public static void main(String[] args) {
        fib(2);
        fib(3);
        fib(5);
    }

    public static int fib(int n) {
        int i = 0; //f(0)
        int j = 1; //f(1)
        int s = 1; //f(2)
        for (int k = 3; k <= n; k++) { //从f(3)开始，f(n)=f(n-1)+f(n-2)
            i = j;
            j = s;
            s = i + j;
        }
        System.out.println("f(" + n + ") = " + s);
        return s;
    }

2.爬楼梯

 /*
        假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
        每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
    */
 public static void main(String[] args) {
        climbStairs2(2);
        climbStairs2(4);
    }

//    关键：
//        它意味着爬到第 x 级台阶的方案数是爬到第 x−1 级台阶的方案数和爬到第 x−2 级台阶的方案数的和。
//        很好理解，因为每次只能爬 1级或 2级，所以 f(x) 只能从 f(x−1) 和 f(x−2) 转移过来。

    public static int climbStairs(int n){ //n>=1
        int p = 0, q = 0, r = 1;
        for (int i = 1; i <= n; ++i) {
            p = q;
            q = r;
            r = p + q;
        }
        System.out.println(r + "种方法");
        return r;
    }

    /* 类似 斐波那契数列 */
    public static int climbStairs2(int n){ //n>=1
        int i = 1; //f(1)
        int j = 2; //f(2)
        int s = 3; //f(3)
        if(n == 1)  return i;
        if(n == 2)  return j;
        for (int k = 3; k <= n; k++) {
            s = i + j;
            i = j;
            j = s;
        }
        System.out.println(n + "级台阶时有" + s + "种方法");
        return s;
    }

3.杨辉三角

/*
        给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
    */
    public static void main(String[] args) {
        generate(5);
        generate(1);
    }

    public static List<List<Integer>> generate(int numRows) { //看题目要求返回一个两层的嵌套集合
        List<List<Integer>> flist =  new ArrayList<>(); //外层集合

        for (int i = 0; i < numRows; ++i) { //TODO ++i or i++ ？
            List<Integer> ilist = new ArrayList<>(); //内层集合
            for (int j = 0; j <= i; ++j) { //第i行，索引从0开始
                if (j == 0 || j == i) {
                    ilist.add(1);
                } else {
                    ilist.add(flist.get(i-1).get(j-1) + flist.get(i-1).get(j)); /* 两个get()获取某行第几个元素 */
                }
            }
            flist.add(ilist);
        }
        System.out.println(flist);
        return flist;
    }

4.杨辉三角Ⅱ

 /*
        给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。
     */
public static void main(String[] args) {
        getRow(3);
        getRow(0);
        getRow(1);
    }

    public static List<Integer> getRow(int rowIndex) {  // rowIndex比行数少1
        List<List<Integer>> flist =  new ArrayList<>();

        for (int i = 0; i <= rowIndex; ++i) {
            List<Integer> ilist = new ArrayList<>();
            for (int j = 0; j <= i; ++j) {
                if (j == 0 || j == i) {
                    ilist.add(1);
                } else {
                    ilist.add(flist.get(i-1).get(j-1) + flist.get(i-1).get(j)); /* 两个get()获取某行第几个元素 */
                }
            }
            flist.add(ilist);
        }
        System.out.println(flist.get(rowIndex));
        return flist.get(rowIndex);
    }

5.比特位计数

/*
        给你一个整数 n ，对于 0 <= i <= n 中的每个 i ，
        计算其二进制表示中 1 的个数 ，返回一个长度为 n + 1 的数组 ans 作为答案。
    */
    public static void main(String[] args) {
        countBits(2);
        countBits(5);
    }

    public static int[] countBits(int n) {
        int[] arrs = new int[n+1];

        for (int i = 0; i <= n; i++) {
            String b = Integer.toBinaryString(i).toString(); //java 10进制转2进制
            int count = b.length() - b.replace("1", "").length();
            //用 "" 替换 b 中 "1"，替换前后两者的长度差即为 二进制中含 1 的个数
            arrs[i] = count;
        }

        System.out.println(Arrays.toString(arrs)); //Java工具类 Arrays类中的toString方法：打印数组
        return arrs;
    }