10/16/2018 GNY Region 2015 ACM Regional Running Steps

本文链接：https://blog.youkuaiyun.com/DreamyHacker/article/details/83170328

本文介绍了一个算法问题，即计算在给定的总步数下，运动员如何按照特定规则上楼梯的不同方式数量。规则包括每条腿的两步和一步数量相等，且两步数量不少于一步。文章提供了一个Java程序实现，通过组合数学方法计算可能的步数组合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Problem H
Running Steps

The coach wants his team members to run up the stadium steps taking either one or two steps with each stride so that:

The number of two step strides taken by each leg is the same.
The number of one step strides taken by each leg is the same.
The number of two step strides is no smaller than the number of one step strides.
Start with the left leg.

The coach wants to know for a given (necessarily even) number of steps how many different ways there are to run the steps and satisfy his rules.

For example, with six steps (three for each leg), there are 4 possibilities:

2211, 2112, 1221, 1122 (right leg strides are in highlighted type)

With eight steps (four for each leg) there is only one possibility since there must be at least as many two step strides as one step strides:

2222

For this problem, you will write a program that calculates the number of different ways there are to run the steps that satisfy the coach’s four criteria.

Input

The first line of input contains a single integer P, (1≤P≤1000), which is the number of data sets that follow. Each data set should be processed identically and independently.

Each data set consists of a single line of input. It contains the data set number, K, followed by an even integer which is the total number of steps to be run, S, (2≤S≤100).

Output

For each data set there is a single line of output. The single output line consists of the data set number, K, followed by a single space followed by the number of different ways of running the steps that satisfy the coach’s four criteria.

Sample Input 1 Sample Output 1

Sample Input 1	Sample Output 1
`5 1 6 2 8 3 10 4 12 5 60`	`1 4 2 1 3 9 4 37 5 40197719157`

1 4
2 1
3 9
4 37
5 40197719157

思路：只有步数是偶数的时候才能被走完。因为2步的步数一定不小于1步的步数，所以我们直接从两步开始走，但注意因为教练的要求，两步的步数必须是偶数，所以假如一开始用两步走完所有步数的次数是奇数的话，则要将初始两步的步数减一，一步的步数加二（1 * 2 - (2 * 1) = 0)。之后我们进行一个While循环，每次减少两次迈两步的步数并且加上四步一步的次数，答案加上在这种情况下的排列组合，直到一步的次数大于两步的次数。

$C_m^n = C_{m - 1} ^ {n - 1} + C_{m -1} ^{n}$ : This is how we get the combination table

import java.util.*;
public class RunningSteps {
	static long[][] c;
	public static void combination() {
		c = new long[55][55];
		c[0][0] = 1;
		c[1][0] = 1;
		c[1][1] = 1;
		//The combination table: C^n _k: i stands for n, j stands for j;
		//That is, the ways to select j items from i items
		for (int i = 2; i <= 50; i++) {
			c[i][0] = 1;
			for (int j = 1; j <= i; j++) c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
		}
	}
	public static void main(String args[]) {
		combination();
		Scanner sc = new Scanner(System.in);
		int kase = sc.nextInt();
		while (kase > 0) {
			int idx = sc.nextInt();
			int steps = sc.nextInt();
			int two_step = steps / 2;
			int one_step = 0;
//If the num of 2-steps is odd, you have to subtract one to make it even
			if (two_step % 2 == 1) {
				two_step--;
				one_step += 2;
			}
			long ans = 0;
			while (two_step >= one_step) {
//bundle two steps as a unit
				long temp = c[two_step / 2 + one_step / 2][one_step / 2];
				ans += (temp * temp);
				two_step -= 2; one_step += 4;
			}
			System.out.println(idx + " " + ans);
			kase--;
		}
		sc.close();
	}
}