走楼梯的问题

最新推荐文章于 2023-09-06 13:44:10 发布
最新推荐文章于 2023-09-06 13:44:10 发布
阅读量409 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 有趣的算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zll441488958/article/details/79034935

问题：1000级台阶，一个人一步可以走2级也可以一步走1级，如果这个刚好把这1000级走完，那么有多少中走法？

思路如下：该问题就是N个红色球和M个黑色球的组合问题。假设一个黑色球代表1级台阶，一个红色球代表2级台阶，那么1000级台阶，就是M+2*N= 1000。然后根据

  
（n≥m)公式计算出结果即可。假设M>=N代入公式中的n = M+1,m=N。这里大家想想为什么是M+1，如果N>M,则代入公式中的n =N+1,m=M。这里卖个关子，为什么要加1？

下面给出三种解题的程序，分别是单线程处理、fork-join框架处理、threadpool处理，大家也看看具体的性能

1、单线程

package louti;

import java.math.BigInteger;
import java.util.LinkedList;
import java.util.List;

public class LouTiWenTi {

	public static final int MAX_NUM = 3000;// 楼梯总的台阶数
	public static final int MAX_2_SETP_NUM = MAX_NUM / 2;// 一步走两级台阶，最大的步数
	public static final int MAX_1_STEP_NUM = MAX_NUM;// 一步走一级台阶，最大的步数

	public static void main(String ... args) {
		System.out.println(MAX_NUM + "级台阶，一个人一步可以走2级台阶也可以一步走1级台阶，如果这个人刚好把这" + MAX_NUM + "级台阶走完，总共有多少种走法？步骤如下:");
		long begin = System.currentTimeMillis();
		BigInteger cnt = new BigInteger("0");
		for (int step1, step2 = 0; step2 <= MAX_2_SETP_NUM; step2++) {
			step1 = MAX_NUM - 2 * step2;
			if (step1 >= step2) {
				BigInteger sum = compute(step1 + 1, step2);
				System.out.println("走" + step1 + "个一级台阶，" + step2 + "个二级台阶.有" + sum + "种走法");
				cnt = cnt.add(sum);
			} else if (step2 > step1) {
				BigInteger sum = compute(step2 + 1, step1);;
				System.out.println("走" + step1 + "个一级台阶，" + step2 + "个二级台阶.有" + sum + "种走法");
				cnt = cnt.add(sum);
			}
		}
		System.out.println("总共有" + cnt + "种走法.耗费"+(System.currentTimeMillis()-begin)+"毫秒");
	}

	public static BigInteger compute(int m, int n) {
		if (m < n) {
			throw new RuntimeException("入参m必须大于等于n");
		}
		if (n == 0) {
			return new BigInteger("1");
		}
		int m_n = m - n;
		List<Integer> mList = new LinkedList<Integer>();
		List<Integer> nList = new LinkedList<Integer>();
		List<Integer> m_nList = new LinkedList<Integer>();

		if (m_n >= n) {
			for (int i = m; i > m_n; i--) {
				mList.add(i);
			}
			for (int i = 1; i <= n; i++) {
				nList.add(i);
			}
		} else {
			for (int i = m; i > n; i--) {
				mList.add(i);
			}
			for (int i = 1; i <= (m - n); i++) {
				m_nList.add(i);
			}

		}
		// 做约分
		if (nList.size() > 0) {
			for (int i = 0; i < mList.size(); i++) {
				for (int j = 0; j < nList.size(); j++) {
					if (Integer.parseInt(String.valueOf(mList.get(i))) == Integer.parseInt(String.valueOf(nList.get(j)))) {
						mList.remove(i);
						nList.remove(j);
						i--;
						break;
					}
				}
			}
		}
		// 做约分
		if (m_nList.size() > 0) {
			for (int i = 0; i < mList.size(); i++) {
				for (int j = 0; j < m_nList.size(); j++) {
					if (Integer.parseInt(String.valueOf(mList.get(i))) == Integer.parseInt(String.valueOf(m_nList.get(j)))) {
						mList.remove(i);
						m_nList.remove(j);
						i--;
						break;
					}
				}
			}
		}
		// 做约分
		if (nList.size() > 0) {
			for (int i = 0; i < mList.size(); i++) {
				for (int j = 0; j < nList.size(); j++) {
					int a = mList.get(i);
					int b = nList.get(j);
					int gys = gongyue(a, b);
					if (gys > 1) {
						nList.set(j, b / gys);
						mList.set(i, a / gys);
					}
				}
			}
		}
		// 做约分
		if (m_nList.size() > 0) {
			for (int i = 0; i < mList.size(); i++) {
				for (int j = 0; j < m_nList.size(); j++) {
					int a = mList.get(i);
					int b = m_nList.get(j);
					int gys = gongyue(a, b);
					if (gys > 1) {
						m_nList.set(j, b / gys);
						mList.set(i, a / gys);
					}
				}
			}
		}

		// 阶乘分子
		BigInteger fenzi = new BigInteger("1");
		for (int i = 0; i < mList.size(); i++) {
			fenzi = fenzi.multiply(new BigInteger(String.valueOf(mList.get(i))));
		}
		// 阶乘分母1
		BigInteger fenmu1 = new BigInteger("1");
		for (int i = 0; i < nList.size(); i++) {
			fenmu1 = fenmu1.multiply(new BigInteger(String.valueOf(nList.get(i))));
		}
		// 阶乘分母2
		BigInteger fenmu2 = new BigInteger("1");
		for (int i = 0; i < m_nList.size(); i++) {
			fenmu2 = fenmu2.multiply(new BigInteger(String.valueOf(m_nList.get(i))));
		}

		return fenzi.divide(fenmu1.multiply(fenmu2));
	}

	// 求最小公倍数
	public static int gongbei(int a, int b) {
		return (a * b) / gongyue(a, b);
	}

	// 求最大公约数函数
	public static int gongyue(int a, int b) {
		int gongyue = 0;
		if (a < b) { // 交换a、b的值
			a = a + b;
			b = a - b;
			a = a - b;
		}
		if (a % b == 0) {
			gongyue = b;
		}
		while (a % b > 0) {
			a = a % b;
			if (a < b) {
				a = a + b;
				b = a - b;
				a = a - b;
			}
			if (a % b == 0) {
				gongyue = b;
			}
		}
		return gongyue;
	}

}
2、fork-join 

package louti;

import java.math.BigInteger;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class LouTiWenTiFockJoin extends RecursiveTask<BigInteger> {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public static final int MAX_NUM = 3000;// 楼梯总的台阶数
	public static final int MAX_2_SETP_NUM = MAX_NUM / 2;// 一步走两级台阶，最大的步数
	public static final int MAX_1_STEP_NUM = MAX_NUM;// 一步走一级台阶，最大的步数
	public static final int MAX_TASK_NUM = 10;
	public String[] taskArray;
	public int start;
	public int end;

	public LouTiWenTiFockJoin(String[] taskArray, int start, int end) {
		this.taskArray = taskArray;
		this.start = start;
		this.end = end;
	}

	@Override
	protected BigInteger compute() {
		BigInteger cnt = new BigInteger("0");
		if (end - start < MAX_TASK_NUM) {
			for (int i = start; i < end; i++) {
				String[] mnStrArr = taskArray[i].split(",");
				int m = Integer.parseInt(mnStrArr[0]);
				int n = Integer.parseInt(mnStrArr[1]);
				BigInteger result = new BigInteger("0");
				if (m >= n) {
					result = compute(m + 1, n);
					System.out.println("走" + m + "个一级台阶，" + n + "个二级台阶.有" + result + "种走法");
					cnt = cnt.add(result);
				} else if (m < n) {
					result = compute(n + 1, m);
					System.out.println("走" + m + "个一级台阶，" + n + "个二级台阶.有" + result + "种走法");
					cnt = cnt.add(result);
				}
				cnt.add(result);
			}
			return cnt;
		} else {
			int middle = (start + end) / 2;
			LouTiWenTiFockJoin left = new LouTiWenTiFockJoin(taskArray, start, middle);
			LouTiWenTiFockJoin right = new LouTiWenTiFockJoin(taskArray, middle, end);
			left.fork();
			right.fork();
			return left.join().add(right.join());
		}

	}

	public static BigInteger compute(int m, int n) {
		if (m < n) {
			throw new RuntimeException("入参m必须大于等于n");
		}
		if (n == 0) {
			return new BigInteger("1");
		}
		int m_n = m - n;
		List<Integer> mList = new LinkedList<Integer>();
		List<Integer> nList = new LinkedList<Integer>();
		List<Integer> m_nList = new LinkedList<Integer>();

		if (m_n >= n) {
			for (int i = m; i > m_n; i--) {
				mList.add(i);
			}
			for (int i = 1; i <= n; i++) {
				nList.add(i);
			}
		} else {
			for (int i = m; i > n; i--) {
				mList.add(i);
			}
			for (int i = 1; i <= (m - n); i++) {
				m_nList.add(i);
			}

		}
		// 做约分
		if (nList.size() > 0) {
			for (int i = 0; i < mList.size(); i++) {
				for (int j = 0; j < nList.size(); j++) {
					if (Integer.parseInt(String.valueOf(mList.get(i))) == Integer.parseInt(String.valueOf(nList.get(j)))) {
						mList.remove(i);
						nList.remove(j);
						i--;
						break;
					}
				}
			}
		}
		// 做约分
		if (m_nList.size() > 0) {
			for (int i = 0; i < mList.size(); i++) {
				for (int j = 0; j < m_nList.size(); j++) {
					if (Integer.parseInt(String.valueOf(mList.get(i))) == Integer.parseInt(String.valueOf(m_nList.get(j)))) {
						mList.remove(i);
						m_nList.remove(j);
						i--;
						break;
					}
				}
			}
		}
		// 做约分
		if (nList.size() > 0) {
			for (int i = 0; i < mList.size(); i++) {
				for (int j = 0; j < nList.size(); j++) {
					int a = mList.get(i);
					int b = nList.get(j);
					int gys = gongyue(a, b);
					if (gys > 1) {
						nList.set(j, b / gys);
						mList.set(i, a / gys);
					}
				}
			}
		}
		// 做约分
		if (m_nList.size() > 0) {
			for (int i = 0; i < mList.size(); i++) {
				for (int j = 0; j < m_nList.size(); j++) {
					int a = mList.get(i);
					int b = m_nList.get(j);
					int gys = gongyue(a, b);
					if (gys > 1) {
						m_nList.set(j, b / gys);
						mList.set(i, a / gys);
					}
				}
			}
		}

		// 阶乘分子
		BigInteger fenzi = new BigInteger("1");
		for (int i = 0; i < mList.size(); i++) {
			fenzi = fenzi.multiply(new BigInteger(String.valueOf(mList.get(i))));
		}
		// 阶乘分母1
		BigInteger fenmu1 = new BigInteger("1");
		for (int i = 0; i < nList.size(); i++) {
			fenmu1 = fenmu1.multiply(new BigInteger(String.valueOf(nList.get(i))));
		}
		// 阶乘分母2
		BigInteger fenmu2 = new BigInteger("1");
		for (int i = 0; i < m_nList.size(); i++) {
			fenmu2 = fenmu2.multiply(new BigInteger(String.valueOf(m_nList.get(i))));
		}

		return fenzi.divide(fenmu1.multiply(fenmu2));
	}

	// 求最小公倍数
	public static int gongbei(int a, int b) {
		return (a * b) / gongyue(a, b);
	}

	// 求最大公约数函数
	public static int gongyue(int a, int b) {
		int gongyue = 0;
		if (a < b) { // 交换a、b的值
			a = a + b;
			b = a - b;
			a = a - b;
		}
		if (a % b == 0) {
			gongyue = b;
		}
		while (a % b > 0) {
			a = a % b;
			if (a < b) {
				a = a + b;
				b = a - b;
				a = a - b;
			}
			if (a % b == 0) {
				gongyue = b;
			}
		}
		return gongyue;
	}

	public static void main(String ... args) throws Exception {
		System.out.println(MAX_NUM + "级台阶，一个人一步可以走2级台阶也可以一步走1级台阶，如果这个人刚好把这" + MAX_NUM + "级台阶走完，总共有多少种走法？步骤如下:");
		long begin = System.currentTimeMillis();
		String[] taskArr = new String[MAX_2_SETP_NUM + 1];
		for (int step1, step2 = 0; step2 <= MAX_2_SETP_NUM; step2++) {
			step1 = MAX_NUM - 2 * step2;
			taskArr[step2] = step1 + "," + step2;
		}

		// 创建包含Runtime.getRuntime().availableProcessors()返回值作为个数的并行线程的ForkJoinPool
		ForkJoinPool forkJoinPool = new ForkJoinPool();
		// 提交可分解的PrintTask任务
		LouTiWenTiFockJoin task = new LouTiWenTiFockJoin(taskArr, 0, taskArr.length);
		Future<BigInteger> future = forkJoinPool.submit(task);
		while (!task.isDone()) {

		}
		System.out.println("总共有" + future.get() + "种走法.耗费" + (System.currentTimeMillis() - begin) + "毫秒");
		// 关闭线程池
		forkJoinPool.shutdown();
	}
}

3、threadpool 

package louti;

import java.math.BigInteger;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class LouTiWenTiThreadPool {

	public static final int MAX_NUM = 2000;// 楼梯总的台阶数
	public static final int MAX_2_SETP_NUM = MAX_NUM / 2;// 一步走两级台阶，最大的步数
	public static final int MAX_1_STEP_NUM = MAX_NUM;// 一步走一级台阶，最大的步数

	public static void main(String ... args) throws Exception {
		System.out.println(MAX_NUM + "级台阶，一个人一步可以走2级台阶也可以一步走1级台阶，如果这个人刚好把这" + MAX_NUM + "级台阶走完，总共有多少种走法？步骤如下:");
		long begin = System.currentTimeMillis();
		ExecutorService executor = Executors.newCachedThreadPool(Executors.defaultThreadFactory());
		Future<BigInteger>[] futures = new Future[MAX_2_SETP_NUM + 1];
		final CountDownLatch latch = new CountDownLatch(MAX_2_SETP_NUM + 1);

		for (int step2 = 0; step2 <= MAX_2_SETP_NUM; step2++) {
			int step1 = MAX_NUM - 2 * step2;
			futures[step2] = (Future<BigInteger>)executor.submit(new Task(step1, step2, latch));
		}
		executor.shutdown();
		latch.await();
		BigInteger cnt = new BigInteger("0");
		for (int i = 0; i < futures.length; i++) {
			cnt = cnt.add(futures[i].get());
		}
		System.out.println("总共有" + cnt + "种走法.耗费" + (System.currentTimeMillis() - begin) + "毫秒");
		
	}

	static class Task implements Callable<BigInteger> {

		private int m;
		private int n;
		private CountDownLatch latch;

		public Task(int m, int n, CountDownLatch latch) {
			this.m = m;
			this.n = n;
			this.latch = latch;
		}

		@Override
		public BigInteger call() throws Exception {
			BigInteger result = new BigInteger("0");
			if (m >= n) {
				result = compute(m + 1, n);
				System.out.println("走" + m + "个一级台阶，" + n + "个二级台阶.有" + result + "种走法");
			} else if (m < n) {
				result = compute(n + 1, m);
				System.out.println("走" + m + "个一级台阶，" + n + "个二级台阶.有" + result + "种走法");
			}
			this.latch.countDown();
			return result;
		}

		public static BigInteger compute(int m, int n) {
			if (m < n) {
				throw new RuntimeException("入参m必须大于等于n");
			}
			if (n == 0) {
				return new BigInteger("1");
			}
			int m_n = m - n;
			List<Integer> mList = new LinkedList<Integer>();
			List<Integer> nList = new LinkedList<Integer>();
			List<Integer> m_nList = new LinkedList<Integer>();

			if (m_n >= n) {
				for (int i = m; i > m_n; i--) {
					mList.add(i);
				}
				for (int i = 1; i <= n; i++) {
					nList.add(i);
				}
			} else {
				for (int i = m; i > n; i--) {
					mList.add(i);
				}
				for (int i = 1; i <= (m - n); i++) {
					m_nList.add(i);
				}

			}
			// 做约分
			if (nList.size() > 0) {
				for (int i = 0; i < mList.size(); i++) {
					for (int j = 0; j < nList.size(); j++) {
						if (Integer.parseInt(String.valueOf(mList.get(i))) == Integer.parseInt(String.valueOf(nList.get(j)))) {
							mList.remove(i);
							nList.remove(j);
							i--;
							break;
						}
					}
				}
			}
			// 做约分
			if (m_nList.size() > 0) {
				for (int i = 0; i < mList.size(); i++) {
					for (int j = 0; j < m_nList.size(); j++) {
						if (Integer.parseInt(String.valueOf(mList.get(i))) == Integer.parseInt(String.valueOf(m_nList.get(j)))) {
							mList.remove(i);
							m_nList.remove(j);
							i--;
							break;
						}
					}
				}
			}
			// 做约分
			if (nList.size() > 0) {
				for (int i = 0; i < mList.size(); i++) {
					for (int j = 0; j < nList.size(); j++) {
						int a = mList.get(i);
						int b = nList.get(j);
						int gys = gongyue(a, b);
						if (gys > 1) {
							nList.set(j, b / gys);
							mList.set(i, a / gys);
						}
					}
				}
			}
			// 做约分
			if (m_nList.size() > 0) {
				for (int i = 0; i < mList.size(); i++) {
					for (int j = 0; j < m_nList.size(); j++) {
						int a = mList.get(i);
						int b = m_nList.get(j);
						int gys = gongyue(a, b);
						if (gys > 1) {
							m_nList.set(j, b / gys);
							mList.set(i, a / gys);
						}
					}
				}
			}

			// 阶乘分子
			BigInteger fenzi = new BigInteger("1");
			for (int i = 0; i < mList.size(); i++) {
				fenzi = fenzi.multiply(new BigInteger(String.valueOf(mList.get(i))));
			}
			// 阶乘分母1
			BigInteger fenmu1 = new BigInteger("1");
			for (int i = 0; i < nList.size(); i++) {
				fenmu1 = fenmu1.multiply(new BigInteger(String.valueOf(nList.get(i))));
			}
			// 阶乘分母2
			BigInteger fenmu2 = new BigInteger("1");
			for (int i = 0; i < m_nList.size(); i++) {
				fenmu2 = fenmu2.multiply(new BigInteger(String.valueOf(m_nList.get(i))));
			}

			return fenzi.divide(fenmu1.multiply(fenmu2));
		}

		// 求最小公倍数
		public static int gongbei(int a, int b) {
			return (a * b) / gongyue(a, b);
		}

		// 求最大公约数函数
		public static int gongyue(int a, int b) {
			int gongyue = 0;
			if (a < b) { // 交换a、b的值
				a = a + b;
				b = a - b;
				a = a - b;
			}
			if (a % b == 0) {
				gongyue = b;
			}
			while (a % b > 0) {
				a = a % b;
				if (a < b) {
					a = a + b;
					b = a - b;
					a = a - b;
				}
				if (a % b == 0) {
					gongyue = b;
				}
			}
			return gongyue;
		}

	}

}

以下是台阶数目为1000、2000、3000在同一机器环境下的性能对比。单位（毫秒）

 100020003000
单线程274034808168578
forkjoin17591318061389
threadpool16511327711120


动态规划：走楼梯问题——01
weixin_44844089的博客
05-25 1007
走楼梯问题 动态规划简介： 动态规划 动态规划的核心思想：就是将求解问题分解成多个相互交叠的子问题进行求解，每次求解小型子问题的同时记录计算结果（相当于一个备忘录），在求解较大型子问题的时候会依赖于小型子问题的计算结果，避免重复计算。 子问题：子问题的意思就是相对于求解问题来说仅仅是计算的规模变小了，解决问题的目标和思路都没有改变。（例如：二分查找每次将数组分为两部分，每一部分的查找就可以看做是一个子问题） 相互交叠的子问题：相互交叠的意思就是大型子问题会包含小型子问题的求解。也就是说求解大型子问题的
【C++题解】走楼梯问题综合
szxguagua0807的博客
07-07 4689
楼梯有$N$级台阶，上楼可以一步上一阶，也可以一步上二阶。编写程序，计算**共有多少种不同走法**？正在准备体育考试，他为跳远感到忧愁。[$wgy$](https://blog.csdn.net/wgy_123456)建议他每天跳$N$级台阶，锻炼爆发力。为了增加“**娇喘**”之力，$why$给自己制定了一项规则：$tywz$的同学都是具有拼搏精神和团队精神的，通过不断的努力，$why$进入了$tywz$信竞团队，在知行楼$5$楼有一个神秘宝座，要到达宝座需要爬数级台阶
走楼梯问题
weixin_50340097的博客
04-13 204
题目描述为，现在有一个人，需要到达m阶的楼梯，这个人可以选择一次迈一步，或者一次迈两步，问：在到达目的地之前，会有几种方式到达目的地？（注意：比如要到达第4层，那么可以有1 1 2 或者2 1 1这些都可以看做是不一样的） 题目很简单，需要做的是递归分治，每一次的前进都可以有两种选择，选择迈两步或者迈一步，递归边界是m为0或者是m<0,而且方法种数是根据迈一步和迈两步之和求出来的。 #include <iostream> using namespace std; int Stairs(
走楼梯问题PHP,算法之走楼梯问题
weixin_33514277的博客
04-13 195
A 上楼梯时，B 从同一楼梯往下走。每次不一定只走 1 级，最多可以一次跳过 3 级(即直接前进 4 级)。但无论走多少级，1 次移动所需时间不变。两人同时开始走，求共有多少种“两人最终同时停在同一级”的情况(假设楼梯宽度足够，可以相互错开，不会撞上。另外，同时到达同一级时视为结束)。举个例子，有 4 级楼梯的时候，结果共有 4 种情况.下面是我仿照作者例子中给的代码写的js版本。//走楼梯问题，...
Python走楼梯问题解决方法示例
12-25
本文实例讲述了Python走楼梯问题解决方法。分享给大家供大家参考，具体如下： # -*- coding:utf-8 -*- #!python3 ''' 下楼问题。从楼上走到楼下共有h个台阶，每一步有两种走法： 走1个台阶，走2个台阶，问有多少可...
动态规划入门（走楼梯问题 c++）
Mo
10-20 3971
走楼梯问题问题分析改进源码 问题 一共有n阶阶梯，我们可以一步走一阶，也可以一步走两阶，求一共有几种走法 分析 第一次看到这个问题我想到了排列组合，奈何数学功底太差没有想出具体的解决方法… 既然没法用排列组合解决，那就尝试用其他方法，这里我选择用的是递归。首先我们假设共有40阶楼梯： 如果最后一步走的是1个阶梯， 那之前一定走到了第39个阶梯； 如果最后一步走的是2个阶梯，那么之前一定只走到了38个阶梯（绝对不可能走到39阶,因为只有40阶， 最后一步走两阶）。 同理， 在走到39阶前一步，也有两种可能
前端面试——走楼梯问题
xt_123456的博客
08-14 718
问题描述：一个人爬楼梯，只可以一步走一层或一步走两层，共多少种走法？ 输入：楼梯总层数 输出：有几种走法 解： 这个问题，是一个递归问题。 1.楼梯总层数为1，有一种走法，一步走一层。 2.楼梯总层数为2，有两种走法： 1）一步走一层，走两步 2）一步走两层，走一步 3.楼梯总层数为n的走法有多少种呢？ 走到n层只有两种可能： 1）在第n-1层往上走1步（一步一层）到第n层 2）在第n-2层往上走1步（一步两层）到第n层 所以： 楼梯总层数为n的走法=楼梯总层数为n-1的走法+楼梯总层数为n-2的走法 类似
【动态规划】走楼梯问题
qq_34680987的博客
05-15 1633
走楼梯问题 问题：有一座高度是10级台阶的楼梯，从下往上走，每跨一步只能向上1级或者2级台阶。一共有多少种走法。（和铺瓷砖问题是一样的） 暴力枚举很简单，先选择可能性，再根据排列组合公式，记录。 但是显然阶乘是可能溢出的，且其时间复杂度为O(n^2)（这里加上了求阶乘的复杂度） int N = 10; int M[2] = {1,2}; int sum = 0; for (int i = 0; i <= 10/M[0]; ++i) { if ((..
【经典动态规划问题】—走楼梯
gulaixiangjuejue的博客
12-24 662
动态规划的关键点： 1、找状态，找出能代表状态的元素作为矩阵下标 2、找到状态间的依赖关系，从最简单的情况依次计算 3、复杂的问题求dp[i][j]可能要考虑多种情况。 动态规划应用中非常经典的走楼梯问题： 有n级台阶，一个人每次上一级或者两级，问有多少种走完n级台阶的方法。为了防止溢出，请将结果Mod 1000000007 给定一个正整数int n，请返回一个数，代表上楼的方式数。保...
小白走楼梯问题
哥白尼-
07-27 193
package Demo; /** * * * 一步可以走一阶或两阶或三阶 输入一个阶数, 有多少种走法 * * //递推呢就是自下而上,想问题和写程序都是从下往上 从小问题到问题 * n=0 1 * n=1 1 * n=2 2 * n=3 4 (前三项和:1+1+2) * n=4 7 (前三项和:1+2+4) * * 因为如果...
递归算法----走楼梯问题（跳台阶）
qq_34478594的博客
05-21 4671
/** * 案例2 分治算法 走楼梯 * 一个台阶总共有n级，如果一次可以走1级，也可以一次走2级，求总共有多少种走法。 * 分析： * 如果只有1级台阶，则只有一种走法，如果有2级台阶，则有2种走法：一次走1级或一次走2级 * 假设有三级台阶，则可以一次走1级或一次走2级，如果一次走1级则还剩2级台阶，产生2种走法（上面已经说了）， * 一次走2级则还剩1级只有一种走法，总共的走法就是2+1=3. * 3 * /\ *剩余级数 2 1.
[面试]算法题走楼梯
weixin_41618956的博客
02-09 917
题目 假设楼梯有n层高，每次只能走一步或者两步，求有多少种走法 思路一： 计算过程就是方法，层数作为参数，声明方法f(x)。根据情况分析 一层：1种方法 f(1) = 1 二层：2种方法f(2) = 2 三层：先到达f(1)，然后从f(1)跨两步，或者先到达f(2)，从f(2)跨一步，f(3) = f(1) + f(2) 四层：先到达f(2)，然后从f(2)跨两步，或者先到达f(3)，从f(3)跨一步，f(4) = f(2) + f(3) n层：先到达f(n-2)，然后从f(n-2)跨两步，或者先到达f(n
（一步两步）走楼梯问题（C语言版）
ALLe_Y的博客
09-06 917
n = 1 的时候，只有一种走法；n = 2的时候，有两种走法；//n==1，一种方法，n=2，两种，n>3累加
走楼梯（斐波那契数列）
lm19770429的专栏
02-19 3028
【问题描述】 一个楼梯有 n 级，小苏同学从下往上走，一步可以跨一级，也可以跨两级。问：他走到第 n 级楼梯有多少种走法？ 【输入格式】 一行一个整数 n，0<n≤30。 【输出格式】 一行 n 个整数，之间用一个空格隔开，表示走到第 1 级、第 2 级、……第 n 级分别有多少种走法。 【输入样例】 2 【输出样例】 1 2 【问题分析】 假设 f (i) 表示走到第 i 级楼梯的走法，则走到第 i (i>2)级楼梯有两种可能：一种是从第 i-1级楼梯走过来；另一种是从第
[leetcode]Climbing Stairs(爬楼梯 C语言)
道虽迩，不行不至；事虽小，不为不成
03-28 3343
Climbing Stairs You are climbing a stair case. It takes n steps to reach to the top.Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top? 题意：你去爬楼梯，需要爬n个台阶，你
【数据结构与算法】用C语言写爬楼梯（斐波那契数列的应用，迭代与递归）爬楼梯问题超详细，看完这一篇就够了。
摸鱼小小虫的博客
10-22 5137
用C语言写爬楼梯（斐波那契数列的应用，迭代与递归）爬楼梯问题超详细，看完这一篇就够了。动态规划问题与递归，迭代。时间复杂度最优化。
走楼梯c语言程序,动态规划走楼梯
weixin_35990358的博客
05-17 1740
下面是编程之家 jb51.cc 通过网络收集整理的代码片段。编程之家小编现在分享给大家，也给大家做个参考。//// main.cpp// 动态规划走楼梯//// Created by liujan on 11/18/14.// Copyright (c) 2014 liujan. All rights reserved.///*问题描述：一个楼梯有20级,每次走1级或2级,从底走到 顶一共...
解决一下算法问题中的走楼梯问题
最新发布
03-11
好的，用户问的是解决算法中的走楼梯问题。首先，我需要确认走楼梯问题的具体内容。通常，这个问题是指经典的爬楼梯问题，比如每次可以走1步或2步，问到达第n阶有多少种不同的方法。这是动态规划和递归的典型例子。 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值