问题：有一个有着n级台阶的楼梯，从最底下往上走，每一步只能向上1级或者2级台阶，求一共有多少种走法。 例：如图， 到第二级台阶有2种方法， 到第四级台阶有5种方法， 到第六级台阶有13种方法。 数据说明：共十个测试点，1<=级数<=77。

这是一个经典的动态规划问题，可以使用递推的方式来计算。具体方法如下：

定义一个长度为 n+1 的数组 dp，其中 dp[i] 表示到达第 i 级台阶的走法总数。

初始化 dp[1] = 1 和 dp[2] = 2，即到达第一级台阶只有一种走法，到达第二级台阶有两种走法。

然后对于 i > 2，有两种情况：

- 从第 i-1 级台阶走一步到达第 i 级台阶，此时走法总数为 dp[i-1]。
- 从第 i-2 级台阶走两步到达第 i 级台阶，此时走法总数为 dp[i-2]。

因此，dp[i] = dp[i-1] + dp[i-2]。

最终的结果为 dp[n]。

以下是 Python 代码实现：

def climbStairs(n: int) -> int:
    if n == 1:
        return 1
    elif n == 2:
        return 2
    else:
        dp = [0] * (n+1)
        dp[1] = 1
        dp[2] = 2
        for i in range(3, n+1):
            dp[i] = dp[i-1] + dp[i-2]
        return dp[n]

输入不同的 n 值，可以得到相应的结果。

相关问题

用java写一个代码，实现把指定文件路径filePath底下的文件按照参数n，按照每组n个进行分组保存到指定路径path2下

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FileGroup {

    public static void main(String[] args) {
        String filePath = "/path/to/source/folder";
        String path2 = "/path/to/target/folder";
        int n = 5;
        try {
            List<File> fileList = getFileList(filePath);
            List<List<File>> fileGroupList = groupFiles(fileList, n);
            saveFileGroups(fileGroupList, path2);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static List<File> getFileList(String filePath) throws IOException {
        List<File> fileList = new ArrayList<>();
        File folder = new File(filePath);
        if (!folder.exists()) {
            throw new IOException("文件夹不存在");
        }
        File[] files = folder.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                fileList.add(file);
            }
        }
        return fileList;
    }

    public static List<List<File>> groupFiles(List<File> fileList, int n) {
        List<List<File>> fileGroupList = new ArrayList<>();
        int size = fileList.size();
        int groupNum = size / n;
        int remainder = size % n;
        int index = 0;
        for (int i = 0; i < groupNum; i++) {
            List<File> fileGroup = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                fileGroup.add(fileList.get(index++));
            }
            fileGroupList.add(fileGroup);
        }
        if (remainder > 0) {
            List<File> fileGroup = new ArrayList<>();
            for (int i = 0; i < remainder; i++) {
                fileGroup.add(fileList.get(index++));
            }
            fileGroupList.add(fileGroup);
        }
        return fileGroupList;
    }

    public static void saveFileGroups(List<List<File>> fileGroupList, String path2) throws IOException {
        File folder = new File(path2);
        if (!folder.exists()) {
            folder.mkdirs();
        }
        for (int i = 0; i < fileGroupList.size(); i++) {
            File fileGroupFolder = new File(folder, "group" + (i + 1));
            if (!fileGroupFolder.exists()) {
                fileGroupFolder.mkdirs();
            }
            List<File> fileGroup = fileGroupList.get(i);
            for (File file : fileGroup) {
                FileInputStream fis = new FileInputStream(file);
                FileOutputStream fos = new FileOutputStream(new File(fileGroupFolder, file.getName()));
                byte[] buffer = new byte[1024];
                int len;
                while ((len = fis.read(buffer)) > 0) {
                    fos.write(buffer, 0, len);
                }
                fis.close();
                fos.close();
            }
        }
    }
}

解释：

1. `getFileList`方法获取指定路径下的所有文件。

2. `groupFiles`方法将文件列表按照参数n分组，每组n个。

3. `saveFileGroups`方法将分组后的文件列表保存到指定路径下。

4. 在`main`方法中调用以上三个方法，传入相应的参数，实现分组保存。

js先把上面的n-1个盘子经c移到b,然后将最底下的盘子移到c,再讲b上面的n-1个盘子经

c移到a，这样就完成了整个汉诺塔的移动过程。这个算法可以通过递归来实现，即先移动n-1个盘子到b柱，再将最后一个盘子移动到c柱，最后再将n-1个盘子从b柱移动到c柱。以下是一个使用JavaScript实现的汉诺塔算法示例代码：

function hanoi(n, a, b, c) {
  if(n === 1) {
    console.log(`Move disk ${n} from ${a} to ${c}`);
  } else {
    hanoi(n-1, a, c, b);
    console.log(`Move disk ${n} from ${a} to ${c}`);
    hanoi(n-1, b, a, c);
  }
}

hanoi(3, 'A', 'B', 'C');

输出结果为：

Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C