自定义博客皮肤VIP专享

*博客头图：

点击选择上传的图片

格式为PNG、JPG，宽度*高度大于1920*100像素，不超过2MB，主视觉建议放在右侧，请参照线上博客头图

请上传大于1920*100像素的图片！

博客底图：

点击选择上传的图片

图片格式为PNG、JPG，不超过1MB，可上下左右平铺至整个背景

栏目图：

点击选择上传的图片

图片格式为PNG、JPG，图片宽度*高度为300*38像素，不超过0.5MB

主标题颜色：

RGB颜色，例如：#AFAFAF

Hover：

RGB颜色，例如：#AFAFAF

副标题颜色：

RGB颜色，例如：#AFAFAF

预览取消提交

自定义博客皮肤

-+

上一步保存

m0_46780483的博客

原创杨辉三角的实现-Java递归

杨辉三角，是二项式系数在三角形中的一种几何排列，中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。每个数等于它上方两数之和。每行数字左右对称，由1开始逐渐变大。第n行的数字有n项。前n行共[(1+n)n]/2 个数。第n行的m个数可表示为 C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数。第n行的第m个数和第n-m+1个数相等，为组合数性质之一。每个数字等于上一行的左右两个数字之和。可用此性质写出整个杨辉三角。即第n+1行的第i个数等于第n行的第i-1个数和第i个数之和，这

2022-05-30 16:11:36 313

原创过桥问题（Java递归）

过桥问题。有N（N≥2）个人在晚上需要从X地到达Y地，中间要过一座桥，过桥需要手电筒（而他们只有1个手电筒），每次最多两个人一起过桥（否则桥会垮）。 N个人的过桥时间依次存入数组t[N]中，分别为：t[0],t[1], ……, t[N-1]。过桥的速度以慢的人为准！注意：手电筒不能丢过桥！问题是：编程求这N个人过桥所花的最短时间public class Bridge { public static void main(String[] args) { ArrayList.

2022-05-30 16:07:07 377

原创汉诺塔递归-Java实现

汉诺塔游戏规则规则1、有三根相邻的柱子，标号为A,B,C。2、A柱子上从下到上按金字塔状叠放着n个不同大小的圆盘。3、现在把所有盘子一个一个移动到柱子C上，可暂时将圆盘放置到B盘，并且每次移动同一根柱子上都不能出现大盘子在小盘子上方。...

2022-05-30 15:56:25 290 6

原创 Java学习日记 2022.05.19

Java学习日记 2022.05.19

2022-05-19 09:59:17 158

原创 Java学习日记 2022.05.11

Java学习日记2022.05.11

2022-05-19 09:34:56 70

原创 Java学习日记 2022.05.08

Java学习日记 2022.05.08

2022-05-11 09:26:44 54

转载 JAVA关键字

JAVA关键字

2022-05-08 16:24:48 103

原创 JAVA学习日记 2022.05.02

Java学习日记——2022.05.03

2022-05-03 10:16:36 94 1

空空如也

空空如也

TA创建的收藏夹 TA关注的收藏夹

TA关注的人

小猴子吃香蕉 CSDN认证博客专家 CSDN认证企业博客

码龄4年

IP 属地：上海市

IP属地以运营商信息为准，境内显示到省（区、市），境外显示到国家（地区）

7: 原创

108万+: 周排名

100万+: 总排名

1459: 访问

: 等级

82: 积分

2: 粉丝

2: 获赞

7: 评论

1: 收藏

私信

关注

热门文章

最新评论

汉诺塔递归-Java实现
2301_78476215: #include <iostream> #include <vector> #include <map> #include <algorithm> using namespace std; void postorderTraversal(map<char, vector<char>>& tree, char node) { if (tree.find(node) != tree.end()) { vector<char>& children = tree[node]; for (char child : children) { postorderTraversal(tree, child); } } cout << node << " "; } int main() { map<char, vector<char>> tree; char parent, child; // 读取输入数据 while (cin >> parent >> child) { tree[parent].push_back(child); } // 找到根节点 char root; for (const auto& pair : tree) { char node = pair.first; bool isRoot = true; for (const auto& pair : tree) { const vector<char>& children = pair.second; if (find(children.begin(), children.end(), node) != children.end()) { isRoot = false; break; } } if (isRoot) { root = node; break; } } // 后根遍历 postorderTraversal(tree, root); return 0; }
汉诺塔递归-Java实现
2301_78476215: #include <iostream> using namespace std; int step = 0; void move(int disk, char source, char target) { step++; cout << step << " " << disk << " " << source << "->" << target << endl; } void hanoi(int n, char source, char target, char auxiliary) { if (n == 1) { move(1, source, target); return; } hanoi(n - 1, source, auxiliary, target); move(n, source, target); hanoi(n - 1, auxiliary, target, source); } int main() { int n; cout << "Enter the number of disks: "; cin >> n; cout << "Steps to move the disks:" << endl; hanoi(n, 'A', 'C', 'B'); return 0; }
汉诺塔递归-Java实现
2301_78476215: #include <iostream> #include <cstdio> #include <cmath> using namespace std; void move(int id, char x, char y) { printf("%d : %c -> %c\n", id, x, y); } void hanoi(int n, char A, char B, char C) { if (n == 1) { move(n, A, C); } else { hanoi(n - 1, A, C, B); move(n, A, C); hanoi(n - 1, B, A, C); } } main() { hanoi(3, 'A', 'B', 'C'); }
汉诺塔递归-Java实现
2301_78476215: #include <iostream> #include <vector> #include <unordered_map> using namespace std; void preOrderTraversal(char root, unordered_map<char, vector<char>>& tree, vector<char>& result) { result.push_back(root); if (tree.find(root) == tree.end()) { return; } vector<char> children = tree[root]; for (char child : children) { preOrderTraversal(child, tree, result); } } int main() { unordered_map<char, vector<char>> tree; char parent, child; while (cin >> parent >> child) { tree[parent].push_back(child); } vector<char> result; preOrderTraversal('A', tree, result); for (char node : result) { cout << node << " "; } cout << endl; return 0; }
汉诺塔递归-Java实现
2301_78476215: #include <iostream> #include <vector> #include <unordered_map> #include <algorithm> using namespace std; void postorderTraversal(const string& root, const unordered_map<string, vector<string>>& childrenDict, vector<string>& result) { if (childrenDict.find(root) != childrenDict.end()) { const vector<string>& children = childrenDict.at(root); for (const string& child : children) { postorderTraversal(child, childrenDict, result); } } result.push_back(root); } string generatePostorderSequence(const vector<pair<string, string>>& pairs) { unordered_map<string, vector<string>> childrenDict; unordered_map<string, bool> allNodes; for (const auto& pair : pairs) { const string& parent = pair.first; const string& child = pair.second; allNodes[parent] = true; allNodes[child] = true; childrenDict[parent].push_back(child); } string root; for (const auto& entry : allNodes) { const string& node = entry.first; if (childrenDict.find(node) == childrenDict.end()) { root = node; break; } } vector<string> sequence; postorderTraversal(root, childrenDict, sequence); reverse(sequence.begin(), sequence.end()); string result; for (const string& node : sequence) { result += node + " "; } result.pop_back(); // Remove the trailing space return result; } int main() { vector<pair<string, string>> pairs; string line; while (getline(cin, line)) { if (line.empty()) { break; } string parent, child; istringstream iss(line); iss >> parent >> child; pairs.emplace_back(parent, child); } string postorderSequence = generatePostorderSequence(pairs); cout << postorderSequence << endl; return 0; }

最新文章

提示

确定要删除当前文章？

取消删除