问题A：统计回文字符串
题目描述
现在给你一个字符串S，请你计算S中有多少连续子串是回文串。
输入
输入包含多组测试数据。每组输入是一个非空字符串，长度不超过5000。
输出
对于每组输入，输出回文子串的个数。
样例输入
aba
aa
样例输出
4
3
解题思路：动态规划
首先，我们定义一个二维数组 dp，其中 dp[i][j] 表示从位置 i 到位置 j 的子串是否是回文串。初始化时，将所有的 dp[i][i] 设置为 true。
然后，我们遍历所有的子串，通过动态规划的方式填充 dp 数组。具体的填充方式如下：
1.如果 s[i] 等于 s[j]，并且子串长度小于等于2，那么 dp[i][j] 为 true。也就是说，两个相同的字符或者一个字符的子串一定是回文串。
2.如果 s[i] 等于 s[j]，并且子串的长度大于2，那么 dp[i][j] 取决于位置 i+1 到 j-1 的子串是否是回文串。即 dp[i][j] = dp[i+1][j-1]。
3.如果 s[i] 不等于 s[j]，那么 dp[i][j] 一定不是回文串。
最后，统计所有 dp[i][j] 为 true 的个数，即为回文子串的个数
代码1：
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int countPalindromicSubstring(string s) {
int n = s.length();
vector<vector<bool>> dp(n, vector<bool>(n, false));
int count = 0;
// 初始化单个字符为回文串
for (int i = 0; i < n; i++) {
dp[i][i] = true;
count++;
}
// 检查长度为2的子串是否为回文串
for (int i = 0; i < n - 1; i++) {
if (s[i] == s[i + 1]) {
dp[i][i + 1] = true;
count++;
}
}
// 检查长度大于2的子串是否为回文串
for (int len = 3; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = i + len - 1;
if (s[i] == s[j] && dp[i + 1][j - 1]) {
dp[i][j] = true;
count++;
}
}
}
return count;
}
int main() {
string s;
while (cin >> s) {
cout << countPalindromicSubstring(s) << endl;
}
return 0;
}代码2：
#include <iostream>
#include <vector>
using namespace std;
int count_palindromic_substrings(string s) {
int n = s.length();
vector<vector<bool>> dp(n, vector<bool>(n, false));
int count = 0;
for (int j = 0; j < n; j++) {
dp[j][j] = true;
count++;
for (int i = 0; i < j; i++) {
if (s[i] == s[j]) {
if (j - i <= 2) {
dp[i][j] = true;
count++;
}
else {
dp[i][j] = dp[i+1][j-1];
}
}
}
}
return count;
}
int main() {
string s;
while (getline(cin, s)) {
cout << count_palindromic_substrings(s) << endl;
}
return 0;
}注释：
动态规划(Dynamic Programming)是一种在计算机算法中常用的优化技术。它通过将一个大问题划分为一系列重叠子问题，先求解子问题并保存结果，再利用这些子问题的解来求解更大规模的问题。动态规划通常用于解决具有重叠子问题和最优子结构性质的问题。动态规划的基本思想是利用子问题的解来构建原问题的解。具体来说，动态规划将原问题划分为若干个相互重叠的子问题，并使用递归或迭代的方式求解这些子问题，将子问题的解保存在一个表格中以便后续使用。通过避免重复计算子问题，动态规划可以避免指数级的时间复杂度，大大提高算法的效率。动态规划常用于解决一些最优化问题，如最短路径问题、背包问题、最长公共子序列问题等。它有自底向上和自顶向下两种实现方式，分别对应迭代和递归的实现方式。总结来说，动态规划是一种通过将原问题划分为子问题并重复利用子问题的解来求解更大规模问题的策略，能够有效提高算法的效率。
问题B：构建矩阵
题目描述
现请你构建一个N*N的矩阵，第i行j列的元素为i与j的乘积。（i，j均从1开始）
输入
输入的第一行为一个正整数C，表示测试样例的个数。
然后是C行测试样例，每行为一个整数N（1<=N<=9），表示矩阵的行列数。
输出
对于每一组输入，输出构建的矩阵。
样例输入
2
1
4
样例输出
1
1 2 3 4
2 4 6 8
3 6 9 12
4 8 12 16
#include <iostream>
#include <vector>
using namespace std;
vector<vector<int>> generateMatrix(int N) {
vector<vector<int>> matrix(N, vector<int>(N, 0));
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
matrix[i][j] = (i + 1) * (j + 1);
}
}
return matrix;
}
void printMatrix(vector<vector<int>> matrix) {
int N = matrix.size();
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cout << matrix[i][j] << " ";
}
cout << endl;
}
}
int main() {
int C;
cin >> C;
for (int i = 0; i < C; i++) {
int N;
cin >> N;
vector<vector<int>> matrix = generateMatrix(N);
printMatrix(matrix);
}
return 0;
}问题C：找规律填数字
题目描述
小宇正在读小学，今天老师布置了几道数学题目。小宇平时上课经常不专心，这些他可发愁了，怎么办呢？看看你能不能帮帮他。
题目是给你一组有规律序列的前面5个整数，请你给出它后面跟着的5个整数，如：1,2,3,4,5,___,___,___,__,___。这是个等差数列，后面应该是6,7,8,9,10，就这么简单。而且现在小宇已经知道这串序列要么是等差数列，要么是等比数列或者是斐波那契数列。
输入
输入包含多组测试数据。每组输入5个整数，每个数字之间隔一个空格，当5个数字都为0时输入结束。
输出
对于每组输入，输出这串数列的后面5个数字，每个数字之间隔一个空格。
样例输入
1 2 3 4 5
1 2 4 8 16
1 2 3 5 8
0 0 0 0 0
样例输出
6 7 8 9 10
32 64 128 256 512
13 21 34 55 89
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
int main()
{
int a,b,c,d,e;
while(scanf("%d %d %d %d %d",&a,&b,&c,&d,&e)!=EOF)
{
if(a==0&&b==0&&c==0&&d==0&&e==0)//全0退出
{
break;
}
if((b-a) == (c-b) && (d-c)==(c-b) &&(d-c)==(e-d))//判断是等差数列
{
int t = b - a;
for(int i = 1;i<=5;i++)
{
printf("%d ",e+i*t);
}
printf("\n");
}
if((b/a) == (c/b)&&(c/b)==(d/c)&&(d/c)==(e/d)&&(b/a)!=1)//判断等比数列。把公比为1除去，当作等差数列
{
int t = b/a;
for(int i = 1;i<=5;i++)
{
printf("%d ",e*(int)pow(t,i));
}
printf("\n");
}
if(a+b==c&&b+c==d&&c+d==e)//判断斐波那契数列
{
int t1=d,t2=e,s=0;
for(int i = 6;i<11;i++)
{
s=t1+t2;
t1=t2;
t2=s;
printf("%d ",s);
}
printf("\n");
}
}
return 0;
}问题D：复原二叉树
题目描述
小明在做数据结构的作业，其中一题是给你一棵二叉树的前序遍历和中序遍历结果，要求你写出这棵二叉树的后序遍历结果。
输入
输入包含多组测试数据。每组输入包含两个字符串，分别表示二叉树的前序遍历和中序遍历结果。每个字符串由不重复的大写字母组成。
输出
对于每组输入，输出对应的二叉树的后续遍历结果。
样例输入
DBACEGF ABCDEFG
BCAD CBAD
样例输出
ACBFGED
CDAB
#include <iostream>
#include <string>
using namespace std;
struct TreeNode {
char val;
TreeNode* left;
TreeNode* right;
TreeNode(char x) : val(x), left(NULL), right(NULL) {}
};
// 根据前序遍历和中序遍历构建二叉树
TreeNode* buildTree(string preorder, string inorder) {
if (preorder.empty() || inorder.empty()) {
return NULL;
}
TreeNode* root = new TreeNode(preorder[0]);
int rootIndex = inorder.find(preorder[0]);
string leftInorder = inorder.substr(0, rootIndex);
string rightInorder = inorder.substr(rootIndex + 1);
string leftPreorder = preorder.substr(1, leftInorder.size());
string rightPreorder = preorder.substr(leftInorder.size() + 1);
root->left = buildTree(leftPreorder, leftInorder);
root->right = buildTree(rightPreorder, rightInorder);
return root;
}
// 后序遍历二叉树
void postorderTraversal(TreeNode* root) {
if (root == NULL) {
return;
}
postorderTraversal(root->left);
postorderTraversal(root->right);
cout << root->val;
}
int main() {
string preorder, inorder;
while (cin >> preorder >> inorder) {
TreeNode* root = buildTree(preorder, inorder);
postorderTraversal(root);
cout << endl;
}
return 0;
}问题E：子树的后序遍历
题目描述
给你一颗二叉树的中序和后序遍历序列，请编程输出该二叉树左子树或右子树的后序遍历序列。
输入
占三行，第一行表示二叉树的中序遍历序列，第二行表示后序遍历序列。用大写字母标识结点，二叉树的结点最多26个。
第三行是单个字母，L表示要求输出该二叉树的左子树的后序遍历序列，R表示要求输出该二叉树的右子树的后序遍历序列。
输出
按要求输出该二叉树左子树或右子树的后序遍历序列。
样例输入
BDCEAFHG
DECBHGFA
R
样例输出
HGF
#include <iostream>
#include <string>
using namespace std;
struct TreeNode {
char val;
TreeNode* left;
TreeNode* right;
TreeNode(char x) : val(x), left(NULL), right(NULL) {}
};
// 根据前序遍历和中序遍历构建二叉树
TreeNode* buildTree(string preorder, string inorder) {
if (preorder.empty() || inorder.empty()) {
return NULL;
}
TreeNode* root = new TreeNode(preorder[0]);
int rootIndex = inorder.find(preorder[0]);
string leftInorder = inorder.substr(0, rootIndex);
string rightInorder = inorder.substr(rootIndex + 1);
string leftPreorder = preorder.substr(1, leftInorder.size());
string rightPreorder = preorder.substr(leftInorder.size() + 1);
root->left = buildTree(leftPreorder, leftInorder);
root->right = buildTree(rightPreorder, rightInorder);
return root;
}
// 后序遍历二叉树
void postorderTraversal(TreeNode* root) {
if (root == NULL) {
return;
}
postorderTraversal(root->left);
postorderTraversal(root->right);
cout << root->val;
}
int main() {
string preorder, inorder;
while (cin >> preorder >> inorder) {
TreeNode* root = buildTree(preorder, inorder);
postorderTraversal(root);
cout << endl;
}
return 0;
}
问题F：迷宫问题
题目描述
小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。
小明只能向上下左右四个方向移动。
输入
输入包含多组测试数据。输入的第一行是一个整数T，表示有T组测试数据。
每组输入的第一行是两个整数N和M（1<=N,M<=100）。
接下来N行，每行输入M个字符，每个字符表示迷宫中的一个小方格。
字符的含义如下：
‘S’：起点
‘E’：终点
‘-’：空地，可以通过
‘#’：障碍，无法通过
输入数据保证有且仅有一个起点和终点。
输出
对于每组输入，输出从起点到终点的最短路程，如果不存在从起点到终点的路，则输出-1。
样例输入
1
5 5
S-###
-----
##---
E#---
---##
样例输出
9
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct Point {
int x;
int y;
int distance;
};
int bfs(vector<vector<char>>& maze, int startX, int startY, int endX, int endY) {
int n = maze.size();
int m = maze[0].size();
vector<vector<bool>> visited(n, vector<bool>(m, false));
queue<Point> q;
q.push({startX, startY, 0});
visited[startX][startY] = true;
while (!q.empty()) {
Point curr = q.front();
q.pop();
if (curr.x == endX && curr.y == endY) {
return curr.distance;
}
// 向上移动
if (curr.x - 1 >= 0 && maze[curr.x - 1][curr.y] != '#' && !visited[curr.x - 1][curr.y]) {
q.push({curr.x - 1, curr.y, curr.distance + 1});
visited[curr.x - 1][curr.y] = true;
}
// 向下移动
if (curr.x + 1 < n && maze[curr.x + 1][curr.y] != '#' && !visited[curr.x + 1][curr.y]) {
q.push({curr.x + 1, curr.y, curr.distance + 1});
visited[curr.x + 1][curr.y] = true;
}
// 向左移动
if (curr.y - 1 >= 0 && maze[curr.x][curr.y - 1] != '#' && !visited[curr.x][curr.y - 1]) {
q.push({curr.x, curr.y - 1, curr.distance + 1});
visited[curr.x][curr.y - 1] = true;
}
// 向右移动
if (curr.y + 1 < m && maze[curr.x][curr.y + 1] != '#' && !visited[curr.x][curr.y + 1]) {
q.push({curr.x, curr.y + 1, curr.distance + 1});
visited[curr.x][curr.y + 1] = true;
}
}
return -1;
}
int main() {
int T;
cin >> T;
while (T--) {
int N, M;
cin >> N >> M;
vector<vector<char>> maze(N, vector<char>(M));
int startX, startY, endX, endY;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> maze[i][j];
if (maze[i][j] == 'S') {
startX = i;
startY = j;
} else if (maze[i][j] == 'E') {
endX = i;
endY = j;
}
}
}
int shortestDistance = bfs(maze, startX, startY, endX, endY);
cout << shortestDistance << endl;
}
return 0;
}
687
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
