2023年计科+AI数据结构平时作业-8

最新推荐文章于 2024-10-16 19:08:56 发布
最新推荐文章于 2024-10-16 19:08:56 发布
阅读量846 收藏 6
点赞数 6
分类专栏： 数据结构作业 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73558212/article/details/134194149
版权

目录

问题 A: 二叉树的层次输出

问题 B: 赫夫曼编码+解码

 问题 C: 视频合并问题

问题 D: 基础实验4-2.1：树的同构 

问题 E: 静态链表存储的二叉树的非递归遍历算法-附加代码模式

问题 A: 二叉树的层次输出

题目描述

用二叉树的带虚结点表示的前序遍历序可以唯一的确定一棵二叉树，请编程构造二叉树并按照要求输出

输入格式

每行是一棵二叉树的带虚结点（#）表示的前序遍历序串，长度不超过1000。每个结点为一个小写字母或一个数字（大于等于0，小于等于9）。

输出格式

对每行输入，按照前序输出对应二叉树。每个节点单独占一行，根节点为第0层，每i层多输出2*i个空格后再输出节点。如果一个节点只有一个子节点，则另一个空的子节点需要输出#
如果是一个空的二叉树，直接输出空行。

输入样例

ab##c##
#
ab###

输出样例

a
  b
  c

a
  b
  #

AC代码： 

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <queue>
#include <stack>
using namespace std;

struct BiNode
{
    string data;
    BiNode *lchild, *rchild;
    int count;
};
typedef BiNode *BiTree;

void InitBiTree(BiTree &t){
    t=NULL;
}

char* CreateBiTree(BiTree &t,char* str)
{
    if (*str == '#'){
        t=NULL;
        return str+1;
    }
    // 创建结点
    t=new BiNode;
    t->data = *str;
    char* left = CreateBiTree(t->lchild, str+1);
    char* right = CreateBiTree(t->rchild,left);

    // 返回剩余的字符串
    return right;
}

int PreTraverse(BiTree T){
    stack<BiTree> q;
    BiTree p=T;
    if(p==NULL){
        cout<<endl;
        return 0;
    }
    p->count=0;
    while(!q.empty()||p!=NULL){
        while(p!=NULL){
            q.push(p);
            if(p->lchild&&p->rchild){
                p->lchild->count=p->count+1;
                p->rchild->count=p->count+1;
            }else if(p->lchild){
                p->lchild->count=p->count+1;
                p->rchild=new BiNode;
                p->rchild->data='#';
                p->rchild->count=p->count+1;
                p->rchild->lchild=NULL;
                p->rchild->rchild=NULL;
            }else if(p->rchild){
                p->rchild->count=p->count+1;
                p->lchild=new BiNode;
                p->lchild->data='#';
                p->lchild->count=p->count+1;
                p->lchild->lchild=NULL;
                p->lchild->rchild=NULL;
            }
            
            for(int i=0;i<2*p->count;i++){
                cout<<" ";
            }
            cout<<p->data<<endl;

            p=p->lchild;
        }
        p=q.top();
        q.pop();
        p=p->rchild;
    }
    return 0;
}

int DestroyBiTree(BiTree &T){
    if (T == NULL) return 0;
    DestroyBiTree(T->lchild);
    DestroyBiTree(T->rchild);
    delete T;
    T = NULL;
    return 0;
}

int main(){
    char str[1005];
    while(cin >> str)
    {
        BiTree tree;
        InitBiTree(tree);
        CreateBiTree(tree,str);
        // CountBiTree(tree);
        PreTraverse(tree);
        DestroyBiTree(tree);
    }
    return 0;
}

问题 B: 赫夫曼编码+解码

题目描述

在通讯领域，经常需要将需要传送的文字转换成由二进制字符组成的字符串。在实际应用中，由于总是希望被传送的内容总长尽可能的短，如果对每个字符设计长度不等的编码，且让内容中出现次数较多的字符采用尽可能短的编码，则整个内容的总长便可以减少。另外，需要保证任何一个字符的编码都不是另一个字符的编码前缀，这种编码成为前缀编码。

而赫夫曼编码就是一种二进制前缀编码.

在本题中，读入n个字符所对应的权值，编程实现生成赫夫曼编码，并依次输出计算出的每一个赫夫曼编码。

接下来，读入一段二进制字符串，请将其解码输出对应的字母

输入格式

输入的第一行包含一个正整数n，表示共有n个字符（从a,b,c...依次类推，1<n<=26）需要编码。 第二行中有n个用空格隔开的正整数，分别表示n个字符的权值。
输入的第三行是一段长度不超过1000的二进制字符串。

输出格式

首先输出n行，每行一个字符串，表示对应字符的赫夫曼编码。
然后再输出对应二进制字符串的解码结果。

输入样例

8
5 29 7 8 14 23 3 11
0110100110101110

输出样例

0110
10
1110
1111
110
00
0111
010
ababc

数据范围与提示

满足条件的哈夫曼树不止一种。为了确保答案唯一，题目的测试数据约定，合并两个节点时，先出现的节点（也就是数组中下标小的节点）为左子；

#include<bits/stdc++.h>
using namespace std;

struct BiNode
{
    int val;
    int lchild,rchild;
    int parent=-1;
};

struct BiCode
{
    int bit[205];
    int start;
};

void CreateBiTree(struct BiNode a[205],int len)
{
    int min1,min2,index1,index2;
    for(int i=0;i<len-1;i++){
        min1=min2=1005;index1=index2=-1;
        for(int j=0;j<len+i;j++){
            if(a[j].val<min1&&a[j].parent==-1){
                min2=min1;
                index2=index1;
                min1=a[j].val;
                index1=j;
            }else if(a[j].val<min2&&a[j].parent==-1){
                min2=a[j].val;
                index2=j;
            }
        }
        a[index1].parent=len+i;
        a[index2].parent=len+i;
        a[len+i].val=min1+min2;
        a[len+i].lchild=min(index1,index2);
        a[len+i].rchild=max(index1,index2);
    }
}

int HfCode(struct BiNode a[205],struct BiCode b[205],int len){
    struct BiCode cd;
    int c,p;
    for(int i=0;i<len;i++){
        cd.start=len-1;
        c=i;
        p=a[c].parent;
        while(p!=-1){
            if(a[p].lchild==c)cd.bit[cd.start]=0;
            else cd.bit[cd.start]=1;
            cd.start--;
            c=p;
            p=a[c].parent;
        }
        for(int j=cd.start+1;j<len;j++)b[i].bit[j]=cd.bit[j];
        b[i].start=cd.start;
    }
}

int main(){
    int n;
    cin>>n;
    struct BiNode a[205];
    struct BiCode b[205];
    for(int i=0;i<n;i++)cin>>a[i].val;
    CreateBiTree(a,n);

    
    // HfCode(a,b,n);
    struct BiCode cd;
    int c,p;
    for(int i=0;i<n;i++){
        cd.start=n-1;
        c=i;
        p=a[c].parent;
        while(p!=-1){
            if(a[p].lchild==c)cd.bit[cd.start]=0;
            else cd.bit[cd.start]=1;
            cd.start--;
            c=p;
            p=a[c].parent;
        }
        for(int j=cd.start+1;j<n;j++)b[i].bit[j]=cd.bit[j];
        b[i].start=cd.start;
    }
    
    string s[n+5];
    for(int i=0;i<n;i++){
        s[i]="";
        for(int j=b[i].start+1;j<n;j++){
            s[i]+=(b[i].bit[j]+'0');
        }
    }
    for(int i=0;i<n;i++)cout<<s[i]<<endl;
    string t="",str;
    cin>>str;
    for(int i=0;i<str.size();i++){
        int flag=0;
        t+=str[i];
        for(int j=0;j<n;j++){
            if(t==s[j]){
                cout<<char(j+'a');
                flag=1;
                break;
            }
        }
        if(flag)t="";
    }
    return 0;
}

 参考：自底向上的赫夫曼编码、赫夫曼编码树（图解+完整代码）

 问题 C: 视频合并问题

题目描述

有多个视频需要合并为一个视频，假设一次只能将两个视频进行合并，合并需要的时间为该两个视频的时间之和。请计算将多个视频合并为一个视频需要的最小时间为多少？

输入格式

输入的第一行包含一个正整数n，表示共有n个视频需要合并。其中n不超过100。 第二行中有n个用空格隔开的正整数，分别表示n个视频的时间。

输出格式

输出包括一个正整数，即合并需要的最小时间。

输入样例

8
5 29 7 8 14 23 3 11

输出样例

271

AC代码： 

#include<bits/stdc++.h>
using namespace std;
 
int main(){
    int time=0,n;
    cin>>n;
    int a[n+5];
    for(int i=0;i<n;i++)cin>>a[i];
    sort(a,a+n);
    if(n==1)time+=a[0];
    else{
        while(a[n-2]!=-1){
            int i=0;
            while(a[i]==-1&&i+1<n)i++;
            a[i+1]=a[i]+a[i+1];
            //cout<<a[i+1]<<" "<<time<<endl;
            a[i]=-1;
            time+=a[i+1];
            sort(a,a+n);
        }
    }
    cout<<time;
    return 0;
}

问题 D: 基础实验4-2.1：树的同构 

题目描述

给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图2就不是同构的

图1 

图2 


现给定两棵树，请你判断它们是否是同构的。

输入格式

输入给出2棵二叉树树的信息。对于每棵树，首先在一行中给出一个非负整数N (≤10)，即该树的结点数（此时假设结点从0到N−1编号）；随后N行，第i行对应编号第i个结点，给出该结点中存储的1个英文大写字母、其左孩子结点的编号、右孩子结点的编号。如果孩子结点为空，则在相应位置上给出“-”。给出的数据间用一个空格分隔。注意：题目保证每个结点中存储的字母是不同的。

输出格式

如果两棵树是同构的，输出“Yes”，否则输出“No”。

输入样例

8
A 1 2
B 3 4
C 5 -
D - -
E 6 -
G 7 -
F - -
H - -
8
G - 4
B 7 6
F - -
A 5 1
H - -
C 0 -
D - -
E 2 -

输出样例

Yes

数据范围与提示

可以用递归算法求解，判定规则如下：
（1）如果两棵树都为空，同构；
（2）一棵树为空，另一棵树不为空，不同构；
（3）两棵树都不为空，但根节点数据不同，不同构；
（4）两棵树的左子树都为空，则判断右子树是否同构；
（5）两棵树的左子树都不为空，且左子树的根节点值相等，判断两棵树的左子树是否同构，以及两棵树的右子树是否同构；
（6）两棵树的左右子树有一个为空，或者皆不为空但根节点不相等，需要判断一棵树的左/右子树和另一棵树的右/左子树是否同构；

 AC代码：

#include<bits/stdc++.h>
using namespace std;
 
struct BiNode{
    char data;
    int lchild,rchild;
}t1[15],t2[15];
  
int CreateBiTree(struct BiNode t[])
{
    int n;
    int root=0;
    char left,right;
    cin>>n;
    if(!n)
    return -1;
    for(int i=0;i<n;i++)
    {
        cin>>t[i].data>>left>>right;
        if(left=='-')
        t[i].lchild=-1;
        else
        {
            t[i].lchild=left-'0';
            root-=t[i].lchild;
        }
        if(right=='-')
        t[i].rchild=-1;
        else
        {
            t[i].rchild=right-'0';
            root-=t[i].rchild;
        }
        root += i;
    }
    return root;
}
 
bool judge(int r1,int r2)
{
    if(r1==-1&&r2==-1)
    return true;
    if(r1==-1&&r2!=-1||r1!=-1&&r2==-1)
    return false;
    if(t1[r1].data!=t2[r2].data)
    return false;
    if((t1[r1].lchild!=-1&&t2[r2].lchild!=-1)&&t1[t1[r1].lchild].data==t2[t2[r2].lchild].data)
    return judge(t1[r1].lchild,t2[r2].lchild)&&judge(t1[r1].rchild,t2[r2].rchild);
    else
    {
        return judge(t1[r1].rchild,t2[r2].lchild)&&judge(t1[r1].lchild,t2[r2].rchild);
    }
}
 
int main(){
    int root1=CreateBiTree(t1);
    int root2=CreateBiTree(t2);
    if(judge(root1,root2))cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
}

抄的：数据结构题目-二叉树的遍历

问题 E: 静态链表存储的二叉树的非递归遍历算法-附加代码模式

题目描述

用数组模拟实现链表的功能，即静态链表，也可以用来存储二叉树。
请编写程序，用非递归遍历算法输出静态链表存储前中后三种遍历结果。
本题为附加代码模式，以下代码为自动附加在同学们提交的代码后面。在本题的提示中有代码框架（若使用在线vscode答题的同学请注意不要拷贝题目中的代码框架，自己手打，不然会被封号。），请同学们拷贝后，修改，再注释掉部分代码，最后提交。

输入格式

输入给出2棵二叉树树的信息。
对于每棵树，首先在一行中给出一个非负整数N (≤10)，即该树的结点数（此时假设结点从0到N−1编号）；
随后N行，第i行对应编号第i个结点，给出该结点中存储的1个英文大写字母、其左孩子结点的编号、右孩子结点的编号。
如果孩子结点为空，则在相应位置上给出“-”。
给出的数据间用一个空格分隔。
注意：题目保证每个结点中存储的字母是不同的。

输出格式

针对每颗二叉树，输出3行，分别是前中后三种序列的遍历结果。
如果二叉树为空，则输出3个空行。

输入样例

8
A 1 2
B 3 4
C 5 -
D - -
E 6 -
G 7 -
F - -
H - -
8
G - 4
B 7 6
F - -
A 5 1
H - -
C 0 -
D - -
E 2 -

输出样例

ABDEFCGH
DBFEAHGC
DFEBHGCA
ACGHBEFD
GHCAFEBD
HGCFEDBA

AC代码： 

#include<bits/stdc++.h>
using namespace std;
 
struct BiNode{
    string data;
    char lchild,rchild;
    int flag=0;
};
 
struct BiTree{
    int nodeNumber;
    BiNode data[10];
    int rootIndex;
};
 
void FindRootIndex(BiTree &T){
    int a[T.nodeNumber];
    memset(a,0,sizeof(a));
    for(int i=0;i<T.nodeNumber;i++){
        if(T.data[i].lchild!='-')
            a[T.data[i].lchild-'0']=1;
        if(T.data[i].rchild!='-')a[T.data[i].rchild-'0']=1;
    }
    for(int i=0;i<T.nodeNumber;i++){
        if(a[i]==0){
            T.rootIndex=i;
            break;
        }
    }
}
 
string getPreTraverseStr(const BiTree & T){
    string s="";
    if(T.nodeNumber==0)return s;
    stack<BiNode> q;
    BiNode p=T.data[T.rootIndex];
    q.push(p);
    while(!q.empty()){
        p=q.top();
        s+=p.data;
        q.pop();
        if(p.rchild!='-')q.push(T.data[p.rchild-'0']);
        if(p.lchild!='-')q.push(T.data[p.lchild-'0']);
    }
    return s;
}
 
string getInTraverseStr(const BiTree & T){
    string s="";
    if(T.nodeNumber==0)return s;
    stack<BiNode> q;
    BiNode p=T.data[T.rootIndex];
    q.push(p);
    while(!q.empty()){
        if(q.top().flag==0){
            q.top().flag++;
            if(q.top().lchild!='-')q.push(T.data[q.top().lchild-'0']);
        }else{
            p=q.top();
            q.pop();
            s+=p.data;
            if(p.rchild!='-')q.push(T.data[p.rchild-'0']);
        }
    }
    return s;
}
 
string getSucTraverseStr(const BiTree & T){
    string s="";
    if(T.nodeNumber==0)return s;
    stack<BiNode> q;
    BiNode p=T.data[T.rootIndex];
    q.push(p);
    while(!q.empty()){
        if(q.top().flag==0){
            q.top().flag++;
            if(q.top().lchild!='-')q.push(T.data[q.top().lchild-'0']);
        }else if(q.top().flag==1){
            q.top().flag++;
            if(q.top().rchild!='-')q.push(T.data[q.top().rchild-'0']);
        }else{
            p=q.top();
            q.pop();
            s+=p.data;
        }
    }
    return s;
}
 
// void InputBiTree(BiTree & T){
//     cin >> T.nodeNumber;
//     for(int i=0;i<T.nodeNumber;i++){
//         cin >> T.data[i].data >> T.data[i].lchild >> T.data[i].rchild;
//     }
// }
// int main(){
//     BiTree T;
//     InputBiTree(T);
//     FindRootIndex(T);
//     string str = getPreTraverseStr(T);
//     cout << str << endl;
//     str = getInTraverseStr(T);
//     cout << str << endl;
//     str = getSucTraverseStr(T);
//     cout << str << endl;
 
//     InputBiTree(T);
//     FindRootIndex(T);
//     str = getPreTraverseStr(T);
//     cout << str << endl;
//     str = getInTraverseStr(T);
//     cout << str << endl;
//     str = getSucTraverseStr(T);
//     cout << str << endl;
 
//     return 0;
// }

参考：数据结构题目-二叉树的遍历

Solen.&
关注
专栏目录
2023年计科+AI数据结构平时作业-6
weixin_73558212的博客
10-21 1091
多维数组的元素标识通常是用多维下标(i0, i1, i2, .., in-1)，而多维数组以顺序方式存储在内存中，内存的地址空间是一维的，要操作多维数组就需要计算从多维下标向一维下标的换算。输入的每一行为一个测试用例。每一行由一组非负整数组成，第一个数是多维数组的维数n(2~11)，从第二个数开始的n个数是从高维到低维每一维的维长(1~20)，接着的n个数是一个n维下标。下标起始从0开始。对每一个测试样例，计算给定多维下标按行优向顺序对应的一维下标，并输出这个一维下标的值。每个测试样例输出一行。65。
2023年计科+AI数据结构平时作业-14
weixin_73558212的博客
12-15 541
先这样，毕竟要手写代码，之后再改
2023年计科+AI数据结构平时作业-11
weixin_73558212的博客
11-24 766
🤯
2023年计科+AI数据结构平时作业-12
weixin_73558212的博客
12-03 609
将给定的一系列数字插入初始为空的AVL树，请你输出最后生成的AVL树的根结点的值。
2023年计科+AI数据结构平时作业-13
weixin_73558212的博客
12-07 469
大姐我啊，不会做了，开始摆了😭😭😭
2023年计科+AI数据结构平时作业-10
weixin_73558212的博客
11-19 509
下图是一个有向无环图，节点内的数字表示该节点的序号，节点之间的连接线表示节点之间的连接方式，连接线上方的黑色数字表示该连接线的权重。下图是一个有向无环图，节点内的数字表示该节点的序号，节点之间的连接线表示节点之间的连接方式，连接线上方的黑色数字表示该连接线的权重。下图是一个有向无环图，节点内的数字表示该节点的序号，节点之间的连接线表示节点之间的连接方式，连接线上方的黑色数字表示该连接线的权重。本题要求：求出有向无环图中每一个节点的最早发生时间（示例图中每一个节点的最早发生时间以节点上方的黄色数字标出）
2023年计科+AI数据结构平时作业-15
weixin_73558212的博客
12-26 309
完结撒花🎇祝大家期末顺利
2023年计科+AI数据结构平时作业-4
weixin_73558212的博客
10-07 589
计算非负整常数四则运算表达式，可用的运算符有：+ - * / ( )。一组非负整常数四则运算表达式，每个表达式输入一行，长度不超过1024个字符，每对括号内一定包含数字。每个表达式的计算结果输出一行，错误的表达式输出error。算法流程：E1：设立运算符栈和操作数栈；E2：开始运算符#入栈，向表达式串尾添加结束运算符#；E3：逐词读入表达式，并处理：E31：若读入为操作数，则入栈；
2023年计科+AI数据结构平时作业-7
weixin_73558212的博客
10-27 546
在本题的提示中有代码框架（若使用在线vscode答题的同学请注意不要拷贝题目中的代码框架，自己手打，不然会被封号。在本题的提示中有代码框架，请同学们拷贝后，修改，再注释掉部分代码，最后提交。在本题的提示中有代码框架，请同学们拷贝后，修改，再注释掉部分代码，最后提交。用二叉树的带虚结点表示的前序遍历序可以唯一的确定一棵二叉树，请用非递归算法实现二叉树的中序遍历。用二叉树的带虚结点表示的前序遍历序可以唯一的确定一棵二叉树，请用非递归算法实现二叉树的后序遍历。对每行输入，输出对应二叉树的后序遍历序后换行。
2023考研一战浙大计算机专硕总分第15名经验贴
weixin_48686926的博客
03-29 2798
备考浙大经验贴
2024华为OD机试真题目录 B+C+D+E卷，使用Java语言进行解答（560道）
KJ.JK
09-20 4万+
本文是华为OD机试真题（Java 语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
2024华为OD机试真题目录 B+C+D+E卷，使用C语言进行解答（484道）
热门推荐
KJ.JK
04-15 14万+
本文是华为OD机试真题(C语言)专栏的目录贴（持续更新中…）定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习华为OD机试真题(C语言）定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习。
2024华为OD机试真题(Python 语言) B+C+D+E卷真题目录介绍，带你了解什么是华为OD，机试真题（570道）
KJ.JK
07-07 12万+
本文是华为OD机试真题（Python 语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
2024华为OD机试真题(C++语言) 真题目录介绍，机试真题 B+C+D+E卷（530道）
KJ.JK
03-31 8万+
本文是2023华为OD机试真题(C++语言)专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 806
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 205
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
数据结构常考基础代码题-数组倒置
最新发布
qq_52291558的博客
10-16 292
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 152
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
【刷题册】2024.10.13 - 2024.10.15
yj20040627的博客
10-16 609
BC153 [NOIP2010]数字统计 NC313 两个数组的交集 AB5 点击消除 BC64牛牛的快递 DP4 最小花费爬楼梯 数组中最小两个字符串的最小距离 BC149 简写单词 dd爱框框 除2！
2023年中国AI+Art白皮书：探索人工智能与艺术的交融
"《2023中国人工智能系列白皮书 AI+Art》是由中国人工智能学会编撰的一份关于人工智能在艺术领域的应用报告。该白皮书由一系列专家和学者共同编写，旨在探讨AI与艺术的交融，特别是生成艺术的发展和相关技术。书中...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Solen.&

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值