题目
代码
关键:两个人的情况、及利用对称性;
import java.util.Scanner;
/**
* 题目描述:https://exercise.acmcoder.com/online/online_judge_ques?ques_id=719&konwledgeId=134
*
* 学校联欢晚会的时候,为了使每一个同学都能参与进来,主持人常常会带着同学们玩击鼓传花的游戏。游戏规则是这样的:n个同学坐
* 着围成一个圆圈,指定一个同学手里拿着一束花,主持人在旁边背对着大家开始击鼓,鼓声开始之后拿着花的同学开始传花,每个同
* 学都可以把花传给自己左右的两个同学中的一个(左右任意),当主持人停止击鼓时,传花停止,此时,正拿着花没传出去的那个同学
* 就要给大家表演一个节目。
* 聪明的小赛提出一个有趣的问题:有多少种不同的方法可以使得从小赛手里开始传的花,传了m次以后,又回到小赛手里。
* 对于传递的方法当且仅当这两种方法中,接到花的同学按接球顺序组成的序列是不同的,才视作两种传花的方法不同。
* 比如有3个同学1号、2号、3号,并假设小赛为1号,花传了3次回到小赛手里的方式有1->2->3->1和1->3->2->1,共2种。
*
* @author ydfind
* @date 2019.07.26
*/
public class Main {
/**
* 计算某一个方向满足条件的次数,为-1时无法判断
* @param distance 该方向下最少传递次数
* @param last
* @return
*/
private static int calcDirectionCount(int last, int distance){
int remain = last - distance;
// 距离太远,或多余一次传递,均无法成功
if(remain < 0 || (remain % 2 == 1)){
return 0;
}
return remain == 0 ? 1 : -1;
}
/**
* 符合条件下,有多少种传递情况
* @param n 总人数
* @param index 当前传递到的人(1-n)
* @param last 还剩下的传递次数
* @return 符合条件下,有多少种传递情况
*/
private static int calcCount(int n, int index, int last){
// 已经传到最后不需要再传了
if(last == 0){
return index == 1 ? 1 : 0;
}
// 利用对称性
if(index == 1){
return 2 * calcCount(n, index + 1, last -1);
}
// 看是否能直接判断出结果
int leftCount = calcDirectionCount(last, index - 1);
int rightCount = calcDirectionCount(last, n - index + 1);
if(leftCount > -1 && rightCount > -1){
return leftCount + rightCount;
}
// 继续向左边、向右传递
leftCount = calcCount(n, index > 1 ? index - 1 : n, last - 1);
rightCount = calcCount(n, index < n ? index + 1 : 1, last - 1);
return leftCount + rightCount;
}
/**
* 计算 从第一个人传递m次后回到第一个的情况数
* @param n 总人数
* @param m 传递次数
* @return 从第一个人传递m次后回到第一个的情况数
* @throws Exception
*/
private static int calcCount(int n, int m) throws Exception {
if(n < 1 || m < 0){
throw new Exception("数据错误!");
}
if(m > 0 && n <= 1){
throw new Exception("单节点无法传递!");
}
int count = -1;
if(n == 2){
// 2的情况比较特殊,向左向右都一样
count = m % 2 == 1 ? 0 : 1;
}else{
count = calcCount(n, 1, m);
}
return count;
}
public static void main(String[] args) throws Exception {
Scanner cin = new Scanner(System.in);
while(cin.hasNextInt()) {
int n = cin.nextInt();
int m = cin.nextInt();
int count = calcCount(n, m);
System.out.println(count);
}
}
}
优秀答案
import java.util.*;
import java.io.*;
public class Main2 {
public static void main(String[]args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt(),m=sc.nextInt();
int[][]dp=new int[m+1][n];
dp[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=0;j<n;j++){
dp[i][j]=dp[i-1][(j-1+n)%n]+dp[i-1][(j+1)%n];
}
}
System.out.println(dp[m][0]);
}
// public static void main(String[] args) {
// try {
// InputReader in;
// PrintWriter out;
// boolean useOutput = false;
// // if (System.getProperty("ONLINE_JUDGE") == null) useOutput = true;
// if (useOutput) {
// FileInputStream fin = new FileInputStream(new File("src/testdata.in"));
// in = new InputReader(fin);
// FileOutputStream fout = new FileOutputStream(new File("src/testData.out"));
// out = new PrintWriter(fout);
// } else {
// InputStream inputStream = System.in;
// in = new InputReader(inputStream);
// OutputStream outputStream = System.out;
// out = new PrintWriter(outputStream);
// }
// Solver solver = new Solver();
// solver.solve(in, out);
// out.close();
// } catch (Exception e) {
// e.printStackTrace();
// }
// }
//
// static class Solver
// {
//
// public void solve (InputReader cin, PrintWriter cout)
// {
// try {
// int n, m;
// n = cin.nextInt(); m = cin.nextInt();
// int dp[][] = new int[m + 1][n];
// // 第0次传递,到达第0位置的次数为2,即从0开始传递
// dp[0][0] = 1;
// // i: 第1、2、3...次传递
// for (int i = 1; i <= m; ++i) {
// // j: 第i次传递,到达j的位置的次数
// for (int j = 0; j < n; ++j) {
// dp[i][j] = dp[i - 1][(j + 1) % n] + dp[i - 1][(j - 1 + n) % n];
// }
// }
// cout.println(dp[m][0]);
// } catch (RuntimeException e) {
// return;
// } catch (Exception e) {
// e.printStackTrace();
// return;
// }
//
// }
// }
//
// static class InputReader {
// public BufferedReader reader;
// public StringTokenizer tokenizer;
//
// public InputReader(InputStream stream) {
// reader = new BufferedReader(new InputStreamReader(stream));
// tokenizer = null;
// }
//
// public String next() {
// while (tokenizer == null || !tokenizer.hasMoreTokens()) {
// try {
// tokenizer = new StringTokenizer(reader.readLine());
// } catch (IOException e) {
// throw new RuntimeException(e);
// }
// }
// return tokenizer.nextToken();
// }
//
// public int nextInt() {
// return Integer.parseInt(next());
// }
//
// public long nextLong () {
// return Long.parseLong(next());
// }
//
// public double nextDouble () {
// return Double.parseDouble(next());
// }
//
// }
}