数据结构作业二

原创 已于 2023-07-16 16:43:37 修改 · 794 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #算法 #c++

于 2023-06-29 21:42:25 首次发布
文章介绍了使用动态规划解决字符串中回文子串计数问题，以及构建特定矩阵的算法。同时，展示了如何判断等差、等比和斐波那契数列，以及根据前序和中序遍历重建二叉树并进行后序遍历的方法。最后，讨论了通过广度优先搜索解决迷宫问题，找到从起点到终点的最短路径。

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

问题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;
}
C++求字符串有多少个回文子串
我不是码农的博客~~~
05-17 705
class Solution { public: int countSubstrings(string s) { int n = s.size(), sum = 0; for(int i = 0; i < n*2-1; i++) { int l = i / 2, r = i/2 + i%2; while(l>=0 && r < n && s[l] == s
回文串
LightInDarkness的博客
03-22 648
题目描述 现在给你一个字符串S，请你计算S中有多少连续子串是回文串。 输入 输入包含多组测试数据。每组输入是一个非空字符串，长度不超过5000. 输出 对于每组输入，输出回文子串的个数。 样例输入 aba 样例输出 4 分析： 如果暴力的话，TLE应该是没跑的。为了降低时间复杂度，我们可以用空间换时间...
统计回文子串
qq_45891676的博客
07-28 825
统计回文子串 描述 现在给你一个字符串S，请你计算S中有多少连续子串是回文串。 输入 输入包含多组测试数据。每组输入是一个非空字符串，长度不超过5000。 输出 对于每组输入，输出回文子串的个数。 输入样例 1 aba aa 输出样例 1 4 3 #include <bits/stdc++.h> using namespace std; int main() { char s[5050]; int i,j,l; while(cin>>s) {
字符串的分割-回文
Charlotte的博客
09-17 501
一、题目描述 现在给你一个字符串S，请你计算S中有多少连续子串是回文串。 输入 输入包含多组测试数据。每组输入是一个非空字符串，长度不超过5000. 输出 对于每组输入，输出回文子串的个数。 样例输入 aba 样例输出 4 来源/分类 2019中南大学研究生招生夏令营机试题 二、题解 1：递归进行字符串分割 2：然后统计不重复的子串的数量 （最后内存超限，我也是无能为力了） 三、代码 #inclu...
字符串处理
qq_46118239的博客
05-22 367
字符串处理题目描述输入输出样例输入1样例输出1做法1 题目描述 在给出一个字符串 S ，计算 S中有多少连续子串是回文串。 输入 输入包含多组测试数据。每组输入是一个非空字符串，长度不超过3000 。测试数据不超过3000 行。 输出 对于每组输入，输出的回文子串的个数。 样例输入1 aba aa 样例输出1 4 3 做法1 我们可以通过“枚举回文串中心”并“不断向外扩展”的方式，来找出所有的回文子串。 注意，奇数长度和偶数长度的回文串在处理的方式上存在一些差别，因此可能需要分别统计。 #incl
647. 回文子串
一个有思想的搬运工
04-08 2198
题目链接：https://leetcode-cn.com/problems/palindromic-substrings/description/ 基于动态规划 - 1 这题基于动态规划的思想来解答的话，实现思想参考自 ：http://www.bkjia.com/Cyy/988261.html 借助一个辅助二维数组 dp[i][j]，其中 i 和 j 一起作用，表示字符串 s 中...
南邮作业数据结构作业2到4
10-10
在“南邮作业数据结构作业2到4”中，我们可以推测这是南京邮电大学B21060214班级学生李思齐提交的数据结构课程的作业，涵盖了从第二到第四次作业的内容。这些作业可能涉及到数组、链表、栈、队列、树、图等基本数据...
数据结构作业 数据结构作业.zip
最新发布
11-03
在完成“数据结构作业”时，你可能需要设计和实现这些数据结构，以及使用它们来解决具体问题。例如，你可以创建一个二叉搜索树来存储和查找数据，或者利用堆来实现优先队列。同时，理解和分析不同操作的复杂性也是...
上海交通大学数据结构作业代码
07-01
上海交通大学的数据结构作业代码集合是一份宝贵的教育资源，涵盖了多种数据结构和算法的实践应用。这份作业涉及了数据结构课程中的核心概念，包括数组、链表、树、图、栈、队列、排序和查找等。以下是对每个指定作业...
西南交通大学 数据结构作业1-10章.zip
01-10
本压缩包“西南交通大学 数据结构作业1-10章.zip”包含了该课程从第1次到第5次的作业，这将帮助我们深入了解数据结构的基本概念和应用。 首先，我们从第1次作业开始。在数据结构的初步学习阶段，通常会涉及到线性...
数据结构作业 数据结构作业
10-15
数据结构作业实验报告 本实验报告的主要内容是关于顺序表基本操作的实现，包括插入、删除、查找、合并等操作。实验的主要目的是掌握用 Visual Studio 2010 上机调试线性表的基本方法，并掌握线性表的基本操作。 一...
1016: 构建矩阵
qq_53162179的博客
09-11 574
二维数组，题目格式有要求
Codeup字符处理
李霁明的博客
03-10 1302
文章目录字符处理1008: ASCII码 字符处理 1008: ASCII码 http://codeup.cn/problem.php?id=1008 题目描述 相信大家一定都知道大名鼎鼎的ASCII码，这次给你的任务是输入数字（表示ASCII码），输出相对应的字符信息。 输入 第一行为一个整数T（1<=T<=1000）。 接下来包括T个正整数，由空白符分割。（空白符包括空格、换行、制...
字符串中有多少个回文子串。
阿牛哥的博客
04-27 2347
给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。 具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。 示例 1： 输入：“abc” 输出：3 解释：三个回文子串: “a”, “b”, “c” 示例 2： 输入：“aaa” 输出：6 解释：6个回文子串: “a”, “a”, “a”, “aa”, “aa”, “aaa” 算法思路：求一个字符串中有多少个回文子串，子串必须是连续的，子序列可以不连续，那我定义dp[i][j]：表示字符串s从下标i到j是否是回
Leetcode--Java--647. 回文子串
Sherlock的博客
02-26 535
题目描述 给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。 回文字符串 是正着读和倒过来读一样的字符串。 子字符串 是字符串中的由连续字符组成的一个序列。 具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。 样例描述 示例 1： 输入：s = "abc" 输出：3 解释：三个回文子串: "a", "b", "c" 示例 2： 输入：s = "aaa" 输出：6 解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa" 思
每日一刷题之回文数和回文字符串
qq_58397569的博客
10-16 633
回文数与字符串就是前后看起来一致
leetcode刷题(第647题)——回文子串
weixin_47450807的博客
04-05 470
一、题目 给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。 回文字符串 是正着读和倒过来读一样的字符串。 子字符串 是字符串中的由连续字符组成的一个序列。 具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的 子串。 二、示例 输入：s = "abc" 输出：3 解释：三个回文子串: "a", "b", "c" 输入：s = "aaa" 输出：6 解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa" 三、思路 1、这题还
华师数据结构作业免费汇总
2. 线性结构：线性表是最基本、最简单的数据结构之一。常见的线性结构还包括栈、队列、串等。学习线性结构时，需要掌握各种线性结构的定义、特点、操作以及它们的实现方法（如顺序存储、链式存储等）。 3. 栈和队列...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值