数据结构作业2

最新推荐文章于 2025-06-06 17:23:33 发布

千声

最新推荐文章于 2025-06-06 17:23:33 发布

阅读量1.3k

点赞数 5

分类专栏：数据结构文章标签：数据结构算法图论

本文链接：https://blog.youkuaiyun.com/m0_73724020/article/details/131435175

版权

数据结构专栏收录该内容

7 篇文章

订阅专栏

A统计回文子串

#include <iostream>  
#include <vector>  
using namespace std;  
   
int countPalindromicSubstrings(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++;  
    }  
   
    for (int len = 2; len <= n; len++) {  
        for (int i = 0; i <= n - len; i++) {  
            int j = i + len - 1;  
            if (s[i] == s[j]) {  
                if (len == 2 || dp[i + 1][j - 1]) {  
                    dp[i][j] = true;  
                    count++;  
                }  
            }  
        }  
    }  
   
    return count;  
}  
   
int main() {  
    string s;  
    while (cin >> s) {  
        int count = countPalindromicSubstrings(s);  
        cout << count << endl;  
    }  
    return 0;  
}

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;  
   
void buildMatrix(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);  
        }  
    }  
     
    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;  
        buildMatrix(N);  
    }  
    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<iostream>
#include<algorithm>
using namespace std;
int main(){
    float a[15];
    while(1){
 
    int dc=1,db=1,fb=1;
  //int a[15];
  for(int i = 0;i < 5;i++){
      cin>>a[i];
  }
  if(a[0]==0&&a[4]==a[0]&&a[3]==0&&a[2]==0&&a[1]==0){
      break;
  }
  float d;
  float q;
  for(int i = 1;i < 5;i++){
       
          if(dc==1)     
         { if(i==1){
            d=a[i]-a[i-1];      
          }
          else if(d!=a[i]-a[i-1]){
            dc=0;
          }
      }
       
      if(db==1){
          if(i==1){
              q=a[i]/a[i-1];
          }
          else if((q!=a[i]/a[i-1])){
              db=0;
          }
      }
      if(fb==1){
          if(i>=2&&i<5){
           if(a[i]!=(a[i-1]+a[i-2])){
            fb=0;
           }
          }
      }
   
  }
  int num;
  if(dc==1){
      num=a[4];
     for(int i = 0;i < 5;i++){
         num=num+d;
         cout<<num;
         if(i!=4){
             cout<<" ";
         }
     } 
     cout<<endl;
     //continue;
  }
  else if(db==1){
      num=a[4];
      for(int i = 0;i < 5;i++){
        num=num*q;
          cout<<num;
          if(i!=4){
              cout<<" ";
          }
      }
      cout<<endl;
      //continue;
  }
  else if(fb==1){
      
     // cout<<a[5]<<" ";
      for(int i = 5;i < 10;i++){
           
          a[i]=a[i-1]+a[i-2];
          cout<<a[i];
          if(i!=9)
          cout<<" ";
      }
      cout<<endl;
     // continue;
  }
     
}
return 0;
}

D复原二叉树

题目描述
小明在做数据结构的作业，其中一题是给你一棵二叉树的前序遍历和中序遍历结果，要求你写出这棵二叉树的后序遍历结果。
输入
输入包含多组测试数据。每组输入包含两个字符串，分别表示二叉树的前序遍历和中序遍历结果。每个字符串由不重复的大写字母组成。
输出
对于每组输入，输出对应的二叉树的后续遍历结果。
样例输入复制
DBACEGF ABCDEFG
BCAD CBAD
样例输出复制
ACBFGED
CDAB

#include <iostream>  
#include <string>  
#include <vector>  
using namespace std;  
   
struct BTNode {  
    char data;  
    BTNode *lchild;  
    BTNode *rchild;  
    BTNode(char x) {  
        data = x;  
        lchild = rchild = NULL;  
    }  
};  
   
// 根据先序和中序还原树  
BTNode* buildTree(string pre, int i, string mid, int j, int n) {  
    if (n <= 0) return NULL;  
    char root_data = pre[i];  
    BTNode *root = new BTNode(root_data);  
    int p = j;  
    while (mid[p] != root_data) p++;  
    int num = p - j;  
    root->lchild = buildTree(pre, i+1, mid, j, num);  
    root->rchild = buildTree(pre, i+num+1, mid, p+1, n-num-1);  
    return root;  
}  
   
void display(BTNode *root) {  
    if (root == NULL) return;  
    display(root->lchild);  
    display(root->rchild);  
    cout << root->data;  
}  
   
int main() {  
    string pre, mid;  
    BTNode *root;  
    while (cin >> pre >> mid) {  
        root = buildTree(pre, 0, mid, 0, pre.size());  
        display(root);  
        cout << endl;  
    }  
    system("pause");  
    return 0;  
}

E 子树的后序遍历

题目描述
给你一颗二叉树的中序和后序遍历序列，请编程输出该二叉树左子树或右子树的后序遍历序列。
输入
占三行，第一行表示二叉树的中序遍历序列，第二行表示后序遍历序列。用大写字母标识结点，二叉树的结点最多26个。
第三行是单个字母，L表示要求输出该二叉树的左子树的后序遍历序列，R表示要求输出该二叉树的右子树的后序遍历序列。
输出
按要求输出该二叉树左子树或右子树的后序遍历序列。
样例输入复制
BDCEAFHG
DECBHGFA
R

#include<iostream>
#include<string>
using namespace std;
struct BTNode{
    char data;
    BTNode *lchild,*rchild;
    BTNode(char x):data(x),lchild(NULL),rchild(NULL){}
};
BTNode *build(string &in,int i,string &post,int j,int n){
    if(n<=0)return NULL;
    char data = post[j+n-1];
    int p=i;
    while(in[p]!=data)p++;
    int num = p-i;
    BTNode *root = new BTNode(data);
    root->lchild = build(in,i,post,j,num);
    root->rchild = build(in,p+1,post,j+num,n-num-1);
    return root;
}
void display(BTNode *root){
    if(root==NULL)return;
    display(root->lchild);
    display(root->rchild);
    cout<<root->data;
}
int main(){
    string in,post;
    char order;
    cin>>in>>post>>order;
    BTNode *root=build(in,0,post,0,in.size());
    if(order=='L')display(root->lchild);
    else display(root->rchild);
    system("pause");
    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>
#include <climits>
 
using namespace std;
 
struct Point {
    int x, y, dist;
};
 
int bfs(vector<vector<char>>& maze, int startX, int startY, int endX, int endY) {
    int rows = maze.size();
    int cols = maze[0].size();
    vector<vector<bool>> visited(rows, vector<bool>(cols, false));
    queue<Point> q;
 
    // 定义上下左右四个方向的偏移量
    int dx[] = {-1, 1, 0, 0};
    int dy[] = {0, 0, -1, 1};
 
    // 将起点加入队列并标记为已访问
    q.push({startX, startY, 0});
    visited[startX][startY] = true;
 
    while (!q.empty()) {
        Point current = q.front();
        q.pop();
 
        int x = current.x;
        int y = current.y;
        int dist = current.dist;
        // 如果当前位置是终点，返回最短距离
        if (x == endX && y == endY) {
            return dist;
        }
 
        // 向四个方向进行探索
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
 
            // 如果新位置越界或者是障碍物或者已经访问过，则跳过
            if (nx < 0 || nx >= rows || ny < 0 || ny >= cols || maze[nx][ny] == '#' || visited[nx][ny]) {
                continue;
            }
 
            // 将新位置加入队列并标记为已访问
            q.push({nx, ny, dist + 1});
            visited[nx][ny] = true;
        }
    }
 
    // 如果无法到达终点，返回-1
    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 shortestDist = bfs(maze, startX, startY, endX, endY);
        cout << shortestDist << endl;
    }
 
    return 0;
}