OJ每日刷题

最新推荐文章于 2022-12-07 20:01:18 发布
最新推荐文章于 2022-12-07 20:01:18 发布
阅读量1.1k 收藏 11
点赞数 1
分类专栏： 算法 文章标签： 算法 c++ oj系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43466788/article/details/118616366
版权

每日一题，持续更新！
题目来源：PIPIOJ

7月9日

  1. 题目描述： PIPI给你一个合法的括号序列，希望跟你按左括号下标递增顺序给出每对括号在序列中的下标。（下标从1开始）
  2. 输入： 多组数据，请处理到EOF。对于每组数据，第一行包括一个只包含’(’,’)'的字符串，保证输入的括号匹配序列合法，长度不超过100000
  3. 输出： 按左括号下标递增顺序给出每对括号在序列中的下标。
  4. 样例输入： (())()()
  5. 样例输出：
    1 4
    2 3
    5 6
    7 8

思考：显然是需要用到栈的知识，遇到左括号入栈，遇到右括号，栈里面的左括号出栈匹配。

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

//定义栈
#define MAXSIZE 100100
typedef struct Stack{
    int data[MAXSIZE];
    int top = -1;
}Stack;

int main(){
    Stack s;//声明一个栈
    int index[MAXSIZE];
    char k[MAXSIZE];
    while (scanf("%s",&k)!=EOF){
        int l = strlen(k);//计算字符串的长度
        for (int i = 0; i < l; ++i){
            if (k[i] == '('){ //遇到左括号，下标入栈
                s.data[++s.top]= i+1;
            } else { //遇到右括号，出栈，记录下标
                int j = s.data[s.top--];//匹配左括号的下标
                index[j] = i+1;
            }
        }

        for (int i = 0; i < l; ++i){
            if (index[i] !=0){
                printf("%d %d\n",i,index[i]);
                index[i] = 0;
            }
        }
    }
    return 0;
}

7月10日

  1. 题目描述
    从顺序表L中删除具有最小值的元素(假设唯一)并友函数返回被删元素的值。空出的元素由最后一个元素填补。
  2. 输入
    输入包含一个整数n代表顺序表L长度。
    接下来包含n个整数，代表顺序表L中的元素。
  3. 输出
    若顺序表为空，输出 “error”.
    若不为空，输出最小元素的值并输出删除最小值之后的顺序表。
  4. 样例输入
    3
    1 2 3
  5. 样例输出
    1
    3 2
#include<bits/stdc++.h>

using namespace std;

//定义顺序表
typedef struct SqList{
    int *data;
    int length;
}SqList;

int main(){
    SqList s;
    int min = 0;
    scanf("%d",&s.length);
    if (s.length <= 0){
        printf("error\n");
        return 0;
    }
    s.data = (int *)malloc(sizeof(int)*s.length);
    for (int i = 0; i < s.length; ++i){
        scanf("%d",&s.data[i]);
        if (s.data[i] < s.data[min]){
            min = i;
        }
    }
    int m = s.data[min];
    s.data[min] = s.data[s.length-1];
    s.length--;
    printf("%d\n",m);
    for (int i = 0; i < s.length; ++i){
        printf("%d ",s.data[i]);
    }
    printf("\n");

    return 0;
}
  1. 题目描述
    PIPI现在由一个顺序表L,他想把顺序表所有元素逆置，要求除了存储L的空间外，辅助的空间复杂度为O(1).
  2. 输入
    输入包含一个整数n代表顺序表L长度。
    接下来包含n个整数，代表顺序表L中的元素。
  3. 输出
    输出逆置后的顺序表
  4. 样例输入
    3
    1 2 3
  5. 样例输出
    3 2 1
#include<bits/stdc++.h>
using namespace std;

typedef struct SqList{
    int *data;
    int length;
}SqList;


int main(){
    SqList s;
    scanf("%d",&s.length);
    s.data = (int *) malloc(sizeof(int)*s.length);
    for (int i = 0; i < s.length; ++i){
        scanf("%d",&s.data[i]);
    }
    //逆置
    int l=0,r=s.length-1;
    int temp;
    while (r>l){
        temp = s.data[l];
        s.data[l] = s.data[r];
        s.data[r] = temp;
        l++;
        r--;
    }
    for (int i = 0; i < s.length; ++i){
        printf("%d ",s.data[i]);
    }
    printf("\n");
    free(s.data);
    return 0;
}

7月11日

  1. 题目描述
    长度为n的顺序表L，编写一个时间复杂度为O(n),空间复杂度为O(1)的算法，删除线性表中所有值为x的数据元素。
  2. 输入
    输入包含一个整数n代表顺序表L长度,一个x代表要删除的元素。
    接下来包含n个整数，代表顺序表L中的元素。
  3. 输出
    输出删除元素x后的顺序表。
  4. 样例输入
    5 2
    1 3 2 5 2
  5. 样例输出
    1 3 5

思考：只需定义一个变量k统计不等于x的个数，并把这个不等于x的数放在第k个的位置。

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

typedef struct SqList{
    int *data;
    int length;
}SqList;

int main(){
    SqList s;
    int d;
    scanf("%d",&s.length);
    scanf("%d",&d);
    s.data = (int *) malloc(sizeof(int) * s.length);
    for (int i = 0; i < s.length; ++i){
        scanf("%d",&s.data[i]);
    }
    //用k记录线性表L中 不等于 x的个数，边扫描，便统计k，不等于 x的元素移动到第k个位置上
    int k = 0;
    for (int i = 0; i < s.length; ++i){
        if (s.data[i] != d){
            s.data[k++] = s.data[i];
        }
    }
    s.length = k;
    for (int i = 0; i < s.length; ++i){
        printf("%d ",s.data[i]);
    }
    printf("\n");
    free(s.data);

    return 0;
}
  1. 题目描述
    假设一个算术表达式中包含圆括号，方括号，花括号3种类型的括号，编写算法来判别表达式中括号是否配对。
  2. 输入
    输入包含多组测试用例。
    对于每组测试样例，包括一个仅由 ‘(’，’)’,’[’,’]’,’{’,’}'组成的字符串s。
  3. 输出
    若s是合法的括号串，输出"yes",否则，输出"no"。
  4. 样例输入

    {()}(]
  5. 样例输出
    yes
    no
#include<bits/stdc++.h>
using namespace std;

//定义一个顺序栈
#define MAXSIZE 100100
typedef struct Stack{
    int data[MAXSIZE];
    int top;
}Stack;

int main(){
    Stack s;
    s.top = -1;
    char str[MAXSIZE];
    while(scanf("%s",&str)!=EOF){
        int len = strlen(str);
        for (int i = 0; i < len; ++i){
            //左括号入栈，右括号出栈
            if (str[i] == '(' || str[i] == '[' || str[i] == '{'){
                s.data[++s.top] = str[i];
            } else {
                char pop = s.data[s.top--];
                if (pop == '(' && str[i] == ')'){
                    continue;
                } else if (pop == '[' && str[i] == ']'){
                    continue;
                } else if (pop == '{' && str[i] == '}'){
                    continue;
                } else{
                    printf("no\n");
                    s.top = -3;
                    break;
                }
            }
        }

        if (s.top == -1){
            printf("yes\n");
        } else {
            if (s.top !=-3){
                printf("no\n");
            }
            s.top = -1;
        }

    }

    return 0;
}

7月12日

  1. 题目描述
    PIPI现在有一段由小写字母组成的文本s，他每天的工作就是找到文本中两个相邻并且相同的字母，然后删除它们。注意这个过程是递归的，比如:
    “abbac”->“aac”->“c”。
    返回PIPI删除的文本。
  2. 输入
    输入一行，代表文本s。(1<=|s|<=1e5).
  3. 输出
    输出一行，代表PIPI经过上述操作之后得到的文本。
  4. 样例输入
    abbbac
  5. 样例输出
    abac
#include<bits/stdc++.h>
using namespace std;

#define MaxSize 100000

int main(){
    char s[MaxSize];
    scanf("%s",&s);
    int len = strlen(s);
    int sum = 0;//记录相邻位置不相等的个数
    int sum2 = 0; // 上一次相邻位置不相等的个数
    while (true){
        int i = 1;
        for (i = 1; i < len; ++i){
            if(s[i-1] != s[i]){
                s[sum++] = s[i-1];
            } else {
                i++;
            }
        }
        if (i == len){
            s[sum++] = s[i-1];
        }
        if (sum==len ||sum == sum2 || sum == 1){
            break;
        } else {
            sum2 = sum;
            len = sum;
            sum = 0;
        }
    }
    len = sum;
    for (int i = 0; i < len; ++i){
        printf("%c",s[i]);
    }
    printf("\n");

    return 0;
}

7月13日

  1. 题目描述
    给定一个长度为n的单链表，删除倒数第K的节点，然后从头到尾输出每个节点的值。
  2. 输入
    第一行包含两个整数N，k，k<=N.
    第二行包含N个整数，代表从表头到表尾每个节点的值。
    你需要建立单链表把这N个数串起来~
  3. 输出
    按顺序输出删除了倒数第K个节点后每个节点的值。
  4. 样例输入
    5 2
    1 2 3 4 5
  5. 样例输出
    1 2 3 5
#include<bits/stdc++.h>
using namespace std;


//单链表
typedef struct ListNode{
    int data;
    struct ListNode *next;
}ListNode, *LinkedList;


int main(){
    //尾插法构造单链表
    LinkedList list;
    list = (ListNode *) malloc(sizeof(ListNode));
    list->next = NULL;
    ListNode *r = list;
    int n;
    int k;
    scanf("%d",&n);
    scanf("%d",&k);
    ListNode *p;//要插入的结点
    list->next = p;
    for (int i = 0; i < n; ++i){
        p = (ListNode *) malloc(sizeof(ListNode));
        scanf("%d",&p->data);
        r->next = p;
        r = p;
    }
    //最后一个结点指向NULL
    r->next = NULL;

    //删除

    //找到第n-k个
    ListNode *q = list;
    for (int i = 0; i < n-k; ++i){
        q = q->next;
    }
    //删除第n-k+1个
    ListNode *m = q->next;
    q->next= q->next->next;
    free(m);
    n--;
    q = list;
    for (int i = 0; i < n; ++i){
        q = q->next;
        printf("%d ",q->data);
    }

    printf("\n");
    return 0;
}

7月14日

  1. 题目描述
    反转长度为N的单链表从位置 L 到 R 的子段。请在常数空间复杂度下使用一趟扫描完成反转。
  2. 输入
    第一行三个整数N,L,R,1<=L<=R<=N
    接下来N个数表示N个节点的值
  3. 输出
    输出反转后的单链表节点值
  4. 样例输入
    5 2 4
    1 2 3 4 5
  5. 样例输出
    1 4 3 2 5

这题有代码有15%的错误，找了半天没找到，先保存一下代码，有时间再修改：

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

//单链表
typedef struct ListNode{
    int data;
    struct ListNode *next;
}ListNode,*LinkedList;


int main(){
    int n,l,r;
    scanf("%d",&n);
    scanf("%d",&l);
    scanf("%d",&r);

    LinkedList list = (ListNode *) malloc(sizeof(ListNode));
    ListNode *t = list; //t指向尾结点,尾插法

    ListNode *s;
    for (int i = 0; i < n; ++i){
        s = (ListNode *) malloc(sizeof(ListNode));
        scanf("%d",&s->data);
        t->next = s;
        t = s;
    }
    t->next = NULL;

    //逆置链表

    //找到第l-1个结点
    ListNode *a = list;
    ListNode *p;
    for (int i = 0; i < l-1; ++i){
        a = a->next;
    }
    //第l个结点
    p = a->next;
    //保留第l个结点
    ListNode *b = p;
    ListNode *q = p->next,*m;
    for (int i = l; i < r; ++i){
        m = q->next;
        q->next = p;
        p = q;
        q = m;
    }
    b->next = m;
    a->next = p;

    ListNode *w= list->next;
    while (w != NULL){
        printf("%d ",w->data);
        w = w->next;
    }

    printf("\n");
    return 0;
}

7月15日

  1. 题目描述
    给定带头结点的单链表L，假设L存储了n个元素(n为奇数，是未知的)。设计算法返回该链表中间的那个元素。要求仅对链表进行一次遍历。
  2. 输入
    输入N个数字，不用关心N是多少，使用while循环读入链表中元素，直至EOF。(0<N≤1e5)
  3. 输出
    输出链表最中间的元素。
  4. 样例输入
    1 2 3 4 5
  5. 样例输出
    3
#include<bits/stdc++.h>
using namespace std;

//单链表
typedef struct ListNode{
    int data;
    struct ListNode *next;
}ListNode,*LinkedList;


int main(){
    LinkedList list = (ListNode *) malloc(sizeof(ListNode));
    int n;
    ListNode *r = list;
    ListNode *s;
    while (scanf("%d",&n)!=EOF){
        s = (ListNode *) malloc(sizeof(ListNode));
        s->data = n;
        r->next = s;
        r = s;
    }
    r->next = NULL;
    ListNode *p = list;
    ListNode *q = list;
    while (q && q->next){
        p = p->next;
        q = q->next->next;
    }

    printf("%d\n",p->data);

    return 0;
}

7月20日

  1. 题目描述
    给定一个二叉树，找出其最大深度。
    最大深度是从根节点到最远叶子节点的最长路径上的节点数量。
  2. 输入
    输入一行，按照先序输入一棵二叉树，其中空节点用 -1 表示。
  3. 输出
    输出一行代表二叉树的最大深度。
  4. 样例输入
    1 2 -1 -1 3 4 -1 -1 -1
  5. 样例输出
    3
#include<bits/stdc++.h>
using namespace std;

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

void CreateTree(BiTree &T){
    //按照先序序列创建一棵二叉树
    int data;
    scanf("%d",&data);
    if(cin.get()!='\n'){
        if(data==-1){
            T=NULL;
        }else{
            T=(BiTree)malloc(sizeof(BiNode));
            T->data=data;
            CreateTree(T->lchild);
            CreateTree(T->rchild);
        }
    }
}

// 通过后序递归遍历二叉树T求二叉树高度：LRN
int HeithByPostOrder(BiTree T){
    if(T==NULL) return 0;	// 空树
    int lh=HeithByPostOrder(T->lchild);	// 递归访问左子树
    int rh=HeithByPostOrder(T->rchild); 	// 递归访问右子树
    return (lh>rh?lh:rh) + 1; 				// 自己的高度等于子树中最大高度加1
}
int main(){
    BiTree T;
    CreateTree(T);
    printf("%d",HeithByPostOrder(T));
    return 0;
}

7月21日

  1. 题目描述
    已知线性表中的元素以递增序列排列，并以单链表作存储结构。设计算法删除表中所有值相同的多余元素（使得操作后的线性表中所有的值均不相同），同时释放被删结点空间，并分析算法的时间复杂度。
  2. 输入
    第一行输入一个正整数n，表示元素个数，n<=100。
    第二行输入n个正整数元素，保证元素以递增排列，元素的值<=100。
  3. 输出
    输出删除相同元素后的链表。
  4. 样例输入
    5
    1 1 3 4 4
  5. 样例输出
    1 3 4
#include<bits/stdc++.h>
using namespace std;

//单链表
typedef struct ListNode{
    int data;
    struct ListNode *next;
}ListNode,*LinkedList;

int main(){
    LinkedList L = (ListNode *) malloc(sizeof(ListNode));

    int n;
    cin>>n;

    //尾插法构造单链表
    ListNode *r = L;
    //要插入的结点
    ListNode *s;
    for (int i = 0; i < n; ++i){
        s = (ListNode *) malloc(sizeof(ListNode));
        cin>>s->data;
        r->next = s;
        r = s;
    }
    r->next = NULL;

    //第一个结点
    ListNode *p = L->next;
    //要删除的结点
    ListNode *m;
    while (p->next){
        if (p->data == p->next->data){
            //删除结点 p->next
            m = p->next;
            p->next = m->next;
            free(m);
        } else {
            p = p->next;
        }
    }
    ListNode *q = L->next;
    while (q){
        cout<<q->data<<" ";
        q = q->next;
    }
    cout<<endl;

    return 0;
}
高 朗
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
7-156 最小支撑树
燕朝铭的博客
05-19 152
给定一个包含n个顶点的正权无向图，编号为1至n。请编写程序求出其最小支撑树，并计算其边权之和。
oj刷题 西安理工大学学生在线实验系统编程题答案（超级详细）
03-30
西安理工大学学生在线实验系统编程题答案（超级详细）
数据结构刷题-----1036: 括号匹配
weixin_44646058的博客
08-02 465
题目描述 PIPI给你一个合法的括号序列，希望跟你按左括号下标递增顺序给出每对括号在序列中的下标。（下标从1开始） 输入 多组数据，请处理到EOF。 对于每组数据，第一行包括一个只包含'(',')'的字符串，保证输入的括号匹配序列合法，长度不超过100000 输出 按左括号下标递增顺序给出每对括号在序列中的下标。 样例输入 (())()() 样例输出 1 4 2 3 5 6 7 8 思路： 从字符串后往前遍历，遍历到“)”时，将“)”位置push...
数据结构个人总结系列--栈与队列
weixin_68966886的博客
08-19 411
数据结构考研中栈系列算法的总结
Java 括号匹配，输出每一对括号的位置
All in
06-11 1960
场景：给出一段字符串：fun(a();b(a(),c(a())))，输出每一对括号的位置。 解决：栈 Stack，特点就是先进后出（FILO，First In Last Out） public void test(String text) { Stack<Integer> stack = new Stack<>(); for (int i = 0; i < text.length(); i++) { char c = text.charAt(i)
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。 在 S 上反复执行重复项删除操作，直到无法继续删除。如下实例。 输入：“abbaca“ 输出：“ca“
你是最胖的
12-22 2406
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。 在 S 上反复执行重复项删除操作，直到无法继续删除。如下实例。 输入："abbaca" 输出："ca"
OJ 刷题总结1
08-08
以下是对OJ刷题的一些关键点的总结： 1. **理解题目**: 首先，确保你完全理解题目的要求。题目描述是理解问题的关键，它会告诉你输入是什么，输出应为何物。输入格式可能包括数据的类型、数量和顺序。评测用例用来...
可供各学校计算机上机复试及各OJ平台刷题使用算法笔记.rar
01-27
算法笔记 可供各学校计算机上机复试及各OJ平台刷题使用算法笔记 可供各学校计算机上机复试及各OJ平台刷题使用算法笔记 可供各学校计算机上机复试及各OJ平台刷题使用算法笔记 可供各学校计算机上机复试及各OJ平台刷题...
leetcodeoj和leetcode-OJOnline:在线Oj项目，模仿牛客、Leecode等在线oj的刷题网站
07-07
仿照Leetcode实现一个简单的刷题的项目，用户可以在浏览器访问到题目列表页面，并点击题目进入题目详情页面，并在这里进行代码的编写、编译和运行，并返回结果到浏览器页面 2.项目实现的功能 1.可以显示所有的题目...
适合小白上手的华为OJ刷题.zip
最新发布
05-18
适合小白上手的华为OJ刷题.zip 适合小白上手的华为OJ刷题.zip 适合小白上手的华为OJ刷题.zip 适合小白上手的华为OJ刷题.zip 适合小白上手的华为OJ刷题.zip 适合小白上手的华为OJ刷题.zip 适合小白上手的华为OJ...
括号的所有合法组合
weixin_39304739的博客
03-15 564
关键点： 左括号的个数必须大于右括号的个数，才能加右括号 左括号和右括号的个数都<= n 回溯终止条件为左右括号都为0，其中当左括号被用完时，不能再使用左括号，但右括号剩余个数更多时还可以使用右括号。 class Solution { List<String> list; public List<String> generateParenthesis(int n) { list = new ArrayList<String>().
括号匹配问题（并给出括号的位置）
mlm5678的博客
12-20 1488
在纸上写了一个串，只包含'('和')'。一个'('能唯一匹配一个')'，但是一个匹配的'('必须出现在')'之前。请判断蒜头君写的字符串能否括号完全匹配，如果能，输出配对的括号的位置（匹配的括号不可以交叉，只能嵌套）。 输入格式 一行输入一个字符串只含有'('和')'，输入的字符串长度不大于 50000。 输出格式 如果输入括号不能匹配，输出一行"No"，否则输出一行"Yes"，接下里若干行每行...
（栈的应用）括号匹配
weixin_45525142的博客
08-24 391
题目来源：PIPIOJ 1036 括号匹配 【问题描述】 PIPI给你一个合法的括号序列，希望跟你按左括号下标递增顺序给出每对括号在序列中的下标。（下标从1开始） 【输入输出】 **1.输入：** 多组数据，请处理到EOF。 对于每组数据，第一行包括一个只包含'(',')'的字符串，保证输入的括号匹配序列合法，长度不超过100000 **2.输出：** 按左括号下标递增顺序给出每对括号在序列中的下标。 【样例】 样例输入：(())()() 样例输出： 1 4 2 3 5 6
1036 扩号匹配2
qq_43633434的博客
08-07 141
1036 扩号匹配2 描述： PIPI给你一个合法的括号序列，希望跟你按左括号下标递增顺序给出每对括号在序列中的下标。（下标从1开始） 输入：多组数据，请处理到EOF。对于每组数据，第一行包括一个只包含’(’,’)'的字符串，保证输入的括号匹配序列合法，长度不超过100000 输出：按左括号下标递增顺序给出每对括号在序列中的下标 输入示例 (())()() 输出示例 1 4 2 3 5 6 7 8 代码块 #include <bits/stdc++.h>
合法括号序列判断
代码
09-06 253
//一个合法的括号串定义为：1.只包括括号字符；2.左括号和右括号一一对应 //方法一： public class Main{ public static void main(String[] args) { Scanner in=new Scanner(System.in); while(in.hasNextLine()){ String s=in.nextLine(); String[] s1=s.split(" "
PIPIOJ 1036: 括号匹配
已归档
03-28 975
题目描述: PIPI给你一个合法的括号序列，希望跟你按左括号下标递增顺序给出每对括号在序列中的下标。（下标从1开始） 输入: 多组数据 第一行包括一个只包含’(’,’)'的字符串，保证输入的括号匹配序列合法，长度不超过100000。 输出: 按左括号下标递增顺序给出每对括号在序列中的下标。 样例输入: (())()() 样例输出: 1 4 2 3 5 6 7 8 提示： 注意输出时的顺序哦~ c++参考代码： #include <cstdio> #include <stack> #i
PIPIOJ-1036: 括号匹配
mongchu的博客
06-01 497
PIPIOJ-1036: 括号匹配 又是一个很迷的题目，明明很简单，但总是错误33%…????????） 1036: 括号匹配 题目描述： PIPI给你一个合法的括号序列，希望跟你按左括号下标递增顺序给出每对括号在序列中的下标。（下标从1开始） 输入： 多组数据 第一行包括一个只包含’(’,’)'的字符串，保证输入的括号匹配序列合法，长度不超过100000 输出： 按左括号下标递增顺序给出每对括号在序列中的下标。 样例输入 (())()() 样例输出 1 4 2 3 5 6 7 8 我的
你想知道刷题的秘密吗？一篇博客让你明白什么是OJ题，如何刷OJ题，并深入浅出的带你刷遍顺序表的OJ题（小白必看）
qq_63992711的博客
12-07 5385
本文首先会讲解什么是OJ，以及如何在刷题网站上刷OJ题。然后我们以数据结构顺序表为例，刷几道典型的OJ题，使得我们熟悉接口型OJ的实现。
各大OJ刷题平台汇总
热门推荐
沧海一粟
01-18 9万+
前言 想成为一名高级工程师，算法还是要有的，至少在入门编程和进入公司之前都是必备的。刷题也可以很好的锻炼动手能力和逻辑思维，今天就给大家介绍一些知名的在线刷题平台,都是干货哦！ 力扣(leetcode) 江湖人尽皆知的站点，全球知名的编程平台！总部在美国旧金山的硅谷，创办与2011年，2018年进入中国，并推出付费服务，19年推出力扣App。力扣为全球程序员提供了专业的IT技术职业化提升平台，有效帮助程序员实现快速进步和长期成长(度说)。 特点：支持c++,c,java,python,Rust,kot
最少刷题数蓝桥杯oj
09-16
蓝桥杯oj是一个有着许多题目的在线刷题平台，比赛中选手需要在规定时间内解决尽可能多的题目。所以在准备蓝桥杯时，不同的人会有不同的观点和建议，关于最少刷题数的提问无法简单回答，因为这取决于每个人的能力和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值