期末算法分析程序填空题

目录

[5-1 最小生成树(普里姆算法)](#5-1 最小生成树(普里姆算法))

[5-2 快速排序(分治法)](#5-2 快速排序(分治法))

输入样例:

输出样例:

[5-3 归并排序(递归法)](#5-3 归并排序(递归法))

输入样例:

输出样例:

[5-4 求解编辑距离问题(动态规划法)](#5-4 求解编辑距离问题(动态规划法))

输入格式:

输出格式:

输入样例1:

输出样例1:

[5-5 求解会议安排问题(动态规划)](#5-5 求解会议安排问题(动态规划))

输入格式:

输出格式:

输入样例1:

输出样例1:

[5-6 求解n皇后问题(递归回溯法)](#5-6 求解n皇后问题(递归回溯法))

输入格式:

输出格式:

输入样例1:

输出样例1:

[5-7 0/1背包问题(回溯法)](#5-7 0/1背包问题(回溯法))

输入格式:

输出格式:

输入样例1:

输出样例1:

[5-8 0/1背包问题(分支限界法)](#5-8 0/1背包问题(分支限界法))

输入格式:

输出格式:

输入样例1:

输出样例1:

输入样例2:

输出样例2:

[5-9 部分背包问题(贪心法)](#5-9 部分背包问题(贪心法))

输入格式:

输出格式:

输入样例1:

输出样例1:

[5-10 两个字符串的最长公共子序列长度](#5-10 两个字符串的最长公共子序列长度)


5-1 最小生成树(普里姆算法)

最小生成树(普里姆算法)。

cpp 复制代码
#include <iostream>
#define MVNum 100
#define MaxInt 32767 
using namespace std;

struct edge{
    char adjvex;
    int lowcost;
}closedge[MVNum];

typedef struct{ 
    char vexs[MVNum];   
    int arcs[MVNum][MVNum]; 
    int vexnum,arcnum;
}AMGraph;

int LocateVex(AMGraph G , char v);//实现细节隐藏
int CreateUDN(AMGraph &G);//实现细节隐藏

int Min(AMGraph G){
    int i;
    int index = -1;
    int min = MaxInt;
    for(i = 0 ; i < G.vexnum ; ++i){
        if(){
            min = closedge[i].lowcost;
            index = i;
        }
    }
    return index;
}

void MiniSpanTree_Prim(AMGraph G, char u){ 
    int k , j , i;
    char u0 , v0;
    k =LocateVex(G, u);
    for(j = 0; j < G.vexnum; ++j){ 
        if(j != k){  
            closedge[j].adjvex = ;
            closedge[j].lowcost = ;
        }
    }
    closedge[k].lowcost = ;
    for(i = 1; i < G.vexnum; ++i){
        k = ;  
        u0 = closedge[k].adjvex;
        v0 = G.vexs[k]; 
        cout << u0 << "->" << v0 << endl;
        closedge[k].lowcost = ; 
        for(j = 0; j < G.vexnum; ++j) 
            if(G.arcs[k][j] < closedge[j].lowcost){
                closedge[j].adjvex = ;
                closedge[j].lowcost = ;
            }
    }
}

int main(){
    AMGraph G;
    CreateUDN(G);
    char u;
    cin >> u;
    MiniSpanTree_Prim(G , u);
    return 0;
}

第一空:min > closedge[i].lowcost && closedge[i].lowcost != 0

第二空:u

第三空:G.arcs[k][j]

第四空:0

第五空:Min(G)

第六空:0

第七空:G.vexs[k]

第八空:G.arcs[k][j]

5-2 快速排序(分治法)

快速排序。

cpp 复制代码
#include <iostream>
#define MAXSIZE 1000
using namespace std;

typedef struct
{
 int key;
 char *otherinfo;
}ElemType;
                    
typedef struct
{
 ElemType *r;
 int  length;
}SqList;

int Partition(SqList &L,int low,int high)
{ 
  int pivotkey;
  L.r[0]=L.r[low]; 
  pivotkey=L.r[low].key;
  while()
  {
    while() --high;
    L.r[low]=L.r[high];    
    while() ++low;
    L.r[high]=L.r[low];
  }
  L.r[low]=L.r[0];
  return  low;
}

void QSort(SqList &L,int low,int high)
{
  int pivotloc;
  if(low<high)
   {                                        
    pivotloc=;
    ;
    ;
   }
}

void QuickSort(SqList &L)
{
   QSort(L,1,L.length);
}
                                
void Create_Sq(SqList &L)
{
 int i,n;
 cin>>n;    //输入的值不大于 MAXSIZE
 for(i=1;i<=n;i++)
 {
  cin>>L.r[i].key;
  L.length++;
 }
}
void show(SqList L)
{
 int i;
 for(i=1;i<=L.length;i++)
  if(i==1) 
   cout<<L.r[i].key;
  else
   cout<<" "<<L.r[i].key;
}

int main()
{
 SqList L;
 L.r=new ElemType[MAXSIZE+1];
 L.length=0;
 Create_Sq(L);
 QuickSort(L);
 show(L);
 return 0;
}
输入样例:

第一行输入一个数n(输入的值不大于 MAXSIZE),接下来输入n个数。

7
24 53 45 45 12 24 90
输出样例:

输出按升序排序的结果。

12 24 24 45 45 53 90

第一空:low < high

第二空:low < high && L.r[high].key >= pivotkey

第三空:low < high && L.r[low].key <= pivotkey

第四空:Partition(L,low,high)

第五空:QSort(L,low,pivotloc-1)

第六空:QSort(L,pivotloc+1,high)

5-3 归并排序(递归法)

归并排序(递归法)。

cpp 复制代码
#include <iostream>
#define MAXSIZE 1000
using namespace std;

typedef struct
{
 int key;
 char *otherinfo;
}ElemType;
                    
typedef struct
{
 ElemType *r;
 int  length;
}SqList;
                                                                        
void Create_Sq(SqList &L)
{
 int i,n;
 cin>>n;    //输入的值不大于 MAXSIZE
 for(i=1;i<=n;i++)
 {
  cin>>L.r[i].key;
  L.length++;
 }
}
void show(SqList L)
{
 int i;
 for(i=1;i<=L.length;i++)
  if(i==1) 
   cout<<L.r[i].key;
  else
   cout<<" "<<L.r[i].key;
}

void Merge(ElemType R[],ElemType T[],int low,int mid,int high)
{ 
 int i,j,k;
 i=low; j=mid+1;k=low; 
 while(i<=mid&&j<=high)
 {                     
   if(R[i].key<=R[j].key) T[k++]=R[i++]; 
   else T[k++]=R[j++]; 
 } 
 while(i<=mid)
   T[k++]=R[i++];                 
 while(j<=high)
   T[k++]=R[j++];                       
} 

void MSort(ElemType R[],ElemType T[],int low,int high)
{ 
  int mid;
  ElemType *S=new ElemType[MAXSIZE];
  if(low==high) 
    ; 
  else
  { 
    mid=(low+high)/2;
    ;
    ; 
    ;
  } 
} 
 
void MergeSort(SqList &L)
{ 
   MSort(L.r,L.r,1,L.length); 
} 

int main()
{
  SqList R;
  R.r=new ElemType[MAXSIZE+1];
  R.length=0;
  Create_Sq(R);
  MergeSort(R);
  show(R);
  return 0;
}
输入样例:

第一行输入一个数n,接下来输入n个数。

7
24 53 45 45 12 24 90
输出样例:

输出排序结果。

12 24 24 45 45 53 90

第一空:T[low]=R[low]

第二空:MSort(R,S,low,mid)

第三空:MSort(R,S,mid+1,high)

第四空:Merge(S,T,low,mid,high)

5-4 求解编辑距离问题(动态规划法)

设A和B是两个字符串。现在要用最少的字符操作次数,将字符串A转换为字符串B。这里所说的字符操作共有3种:

(1)删除一个字符。

(2)插入一个字符。

(3)将一个字符替换另一个字符。

cpp 复制代码
#include<stdio.h>
#include<string>
#include<iostream>
#include<algorithm> 
using namespace std;
#define MAX 201
//问题表示
string a;
string b;
//求解结果表示
int dp[MAX][MAX];
void solve()                    //求dp
{
    int i,j;
    for (i=1;i<=a.length();i++) 
        dp[i][0]=i;            //把a的i个字符全部删除转换为b
    for (j=1; j<=b.length(); j++)
        dp[0][j]=j;            //在a中插入b的全部字符转换为b
    for (i=1; i<=a.length(); i++)
           for (j=1; j<=b.length(); j++)
        {
            if (a[i-1]==b[j-1])
                ;
            else
                dp[i][j]=;
        }
}
int main()
{    cin>>a>>b;
    solve();
    printf("%d",dp[a.length()][b.length()]);
    return 0;
}
输入格式:

第一行输入A字符串,第二行输入B字符串。

输出格式:

输出最少的字符操作次数。

输入样例1:
sfdqxbw
gfdgw
输出样例1:
4 

第一空:dp[i][j]=dp[i-1][j-1]

第二空: min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1])) + 1

5-5 求解会议安排问题(动态规划)

陈老师是一个比赛队的主教练。有一天,他想与团队成员开会,应该为这次会议安排教室。教室非常缺乏,所以教室管理员必须接受订单和拒绝订单以优化教室的利用率。如果接受一个订单,该订单的开始时间和结束时间成为一个活动。每个时间段只能安排一个订单(即假设只有一个教室)。请你找出一个最大化的总活动时间的方法。你的任务是这样的:读入订单,计算所有活动(接受的订单)占用时间的最大值。

cpp 复制代码
#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
#define MAX 101
//问题表示
struct NodeType
{
    int b;                            //开始时间
    int e;                            //结束时间
    int length;                        //订单的执行时间
};

 bool cmp(const NodeType &a,const NodeType &b)
{    //用于排序的运算符重载函数
        return a.e<b.e;                //按结束时间递增排序
}
  
int n;                            //订单个数
NodeType A[MAX];    //存放订单
//求解结果表示
int dp[MAX];                    //动态规划数组
int pre[MAX];                    //pre[i]存放前驱订单编号
void solve();

int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
      cin>>A[i].b>>A[i].e;
    for (int i=0; i<n; i++)
        A[i].length=A[i].e-A[i].b;
    solve();
    cout<<dp[n-1]; 
    return 0;
}

void solve()                    //求dp和pre
{
    memset(dp,0,sizeof(dp));    //dp数组初始化
    stable_sort(A,A+n,cmp);        //采用稳定的排序算法
    dp[0]=A[0].length;
    pre[0]=-1;
    for (int i=1;i<n;i++)
    {
        int low=0, high=i-1;
        while(low<=high)        //在A[0..i-1]中查找结束时间早于A[i]开始时间的最晚订单A[low-1]
        {
            int mid=(low+high)/2;
            if(A[mid].e<=A[i].b)
                low=mid+1;
            else
                high=mid-1;
        }
        if (low==0)                //特殊情况
        {
            if(dp[i-1]>=A[i].length)
            {
                dp[i]=;
                pre[i]=-2;        //不选中订单i
            }
            else
            {
                dp[i]=;
                pre[i]=-1;        //没有前驱订单
            }
        }
        else                    //A[i]前面最晚有兼容订单A[low-1]
        {
            if (dp[i-1]>=dp[low-1]+A[i].length)
            {
                dp[i]=;
                pre[i]=-2;        //不选中订单i
            }
            else
            {
                dp[i]=;
                pre[i]=low-1;    //选中订单i
            }
        }
    }
}
输入格式:

第一行是一个整数n,接着的n行中每一行包括两个整数b和e,其中b是一个订单开始时间,e是的结束时间。。

输出格式:

输出一行包括所有活动占用时间的最大值。

输入样例1:
11
1 4
3 5
0 6
5 7
3 8
5 9
6 10
8 11
8 12
2 13
12 15
输出样例1:
13

第一空:dp[i-1]

第二空:A[i].length

第三空:dp[i-1]

第四空:dp[low-1]+A[i].length

5-6 求解n皇后问题(递归回溯法)

在n×n的方格棋盘上,放置n个皇后,要求每个皇后不同行、不同列、不同左右对角线。如下图所示是6皇后问题的一个解。

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>
#define N 20                    //最多皇后个数
int q[N];                        //存放各皇后所在的列号,即(i,q[i])为一个皇后位置

void dispasolution(int n)        //输出n皇后问题的一个解
{
    for (int i=1;i<=n;i++)
        printf("(%d,%d)",i,q[i]);
    printf("\n");
}

bool place(int i,int j)            //测试(i,j)位置能否摆放皇后
{
    if (i==1) return true;        //第一个皇后总是可以放置
    int k=1;
    while (k<i)            //k=1~i-1是已放置了皇后的行
    {    if ((q[k]==j) || (abs(q[k]-j)==abs(i-k)))
            ;
        k++;
    }
    ;
}

void queen(int i,int n)            //放置1~i的皇后
{    if (i>n) 
        dispasolution(n);        //所有皇后放置结束
    else
    {
        for (int j=1;j<=n;j++)        //在第i行上试探每一个列j
            if ()            //在第i行上找到一个合适位置(i,j)
            {    q[i]=j;
                ;
            }
    }
}

int main()
{    int n;                    //n为存放实际皇后个数
    scanf("%d",&n);
    if (n<=20)
        queen(1,n);                //放置1~i的皇后
    return 0;
}
输入格式:

输入n。

输出格式:

按行输出每组解。

输入样例1:
6
输出样例1:
(1,2)(2,4)(3,6)(4,1)(5,3)(6,5)
(1,3)(2,6)(3,2)(4,5)(5,1)(6,4)
(1,4)(2,1)(3,5)(4,2)(5,6)(6,3)
(1,5)(2,3)(3,1)(4,6)(5,4)(6,2)

第一空:return false

第二空:return true

第三空:place(i,j)

第四空:queen(i+1,n)

5-7 0/1背包问题(回溯法)

0/1背包问题。给定一载重量为W的背包及n个重量为wi、价值为vi的物体,1≤i≤n,要求而且重量和恰好为W具有最大的价值。

cpp 复制代码
#include <stdio.h>
#include <string.h>
#include <iostream>
#define MAXN 20                //最多物品数
using namespace std;
int n;                        //物品数
int W;                        //限制重量
int w[MAXN]={0};            //存放物品重量,不用下标0元素
int v[MAXN]={0};            //存放物品价值,不用下标0元素
int x[MAXN];                    //存放最终解
int maxv;                         //存放最优解的总价值
void dfs(int i,int tw,int tv,int rw,int op[]) //求解0/1背包问题
{
    int j;
    if (i>n)                    //找到一个叶子结点
    {    if ()     //找到一个满足条件的更优解,保存它
        {    maxv=tv;
            for ()    //复制最优解
                x[j]=op[j];
        }
    }
    else                        //尚未找完所有物品
    {    if ()          //左孩子结点剪枝:满足条件时才放入第i个物品
        {
            op[i]=1;            //选取第i个物品
            dfs();
        }
        op[i]=0;                //不选取第i个物品,回溯
        if ()            //右孩子结点剪枝
            dfs();
    }
}
void dispasolution()            //输出最优解
{    int i;
    for (i=1;i<=n;i++)
        if (x[i]==1)
            printf("%d ",i);
    printf("\n%d %d",W,maxv);
}
int main()
{
    int i;
    cin>>n>>W; //输入物体个数及背包载重量 
    for(int i=1;i<=n;i++)//输入各物体重量及价值 
        cin>>w[i]>>v[i];
    int op[MAXN];                //存放临时解
    memset(op,0,sizeof(op));
    int rw=0;
    for (int i=1;i<=n;i++)
        rw+=w[i];
    dfs(1,0,0,rw,op);
    dispasolution();
    return 0;
}
输入格式:

第一行输入背包载重量W及背包个数n,再依次输入n行,每行为背包重量wi和价值vi。

输出格式:

第一行输出输出装入背包内的物体编号(末尾有空格),第二行输出背包内的物体总重量和总价值。

输入样例1:
5 10
2 6
2 3
6 5
5 4
4 6
输出样例1:
1 2 3 
10 14 

第一空:tw==W && tv>maxv

第二空:j=1;j<=n;j++

第三空:tw+w[i]<=W

第四空:i+1,tw+w[i],tv+v[i],rw-w[i],op

第五空:tw+rw>W

第六空:i+1,tw,tv,rw-w[i],op

5-8 0/1背包问题(分支限界法)

0/1背包问题。给定一载重量为m的背包及n个重量为wi、价值为vi的物体,1≤i≤n,要求把物体装入背包,使背包的物体价值最大。

输入格式:

第一行输入背包载重量m及背包个数n,再依次输入n行,每行为背包重量wi和价值vi。

输出格式:

第一行输出输出所求X[n]数组,第二行输出装入背包内的物体的最大价值。

输入样例1:
5 10
2 6
2 3
6 5
5 4
4 6
输出样例1:
11001
15
输入样例2:
5 10
11 2
13 10
12 5
13 3
11 6
输出样例2:
00
0
cpp 复制代码
#include <stdio.h>
#include <queue>
#include <iostream>
using namespace std;
#define MAXN 20                        //最多可能物品数
//问题表示
int n,W;
int w[MAXN+1];                //重量,下标0不用
int v[MAXN+1];                  //价值,下标0不用
//求解结果表示
int maxv=-9999;                        //存放最大价值,初始为最小值
int bestx[MAXN+1];                    //存放最优解,全局变量
int total=1;                        //解空间中结点数累计,全局变量
struct NodeType                        //队列中的结点类型
{    int no;                            //结点编号
    int i;                            //当前结点在搜索空间中的层次
    int w;                            //当前结点的总重量
    int v;                            //当前结点的总价值
    int x[MAXN+1];                    //当前结点包含的解向量
    double ub;                        //上界
};

void bound(NodeType &e)            //计算分枝结点e的上界
{
    int i=e.i+1;
    int sumw=e.w;
    double sumv=e.v;
    while ()
    {    sumw+=w[i];                //计算背包已装入载重
        sumv+=v[i];                //计算背包已装入价值
        i++;
    }
    if (i<=n)    
        e.ub=;
    else
        e.ub=sumv;
}

void EnQueue(NodeType e,queue<NodeType> &qu)    //结点e进队qu
{
    if (e.i==n)                    //到达叶子结点
    {
        if (e.v>maxv)            //找到更大价值的解
        {
            ;
            for (int j=1;j<=n;j++)
                ;
        }
    }
    else qu.push(e);            //非叶子结点进队
}
void bfs()                            //求0/1背包的最优解
{
    int j;
    NodeType e,e1,e2;                //定义3个结点
    queue<NodeType> qu;                //定义一个队列
    e.i=0;                            //根结点置初值,其层次计为0
    e.w=0; e.v=0;
    e.no=total++; 
    for (j=1;j<=n;j++)
        e.x[j]=0;
    bound(e);                        //求根结点的上界
    qu.push(e);                        //根结点进队
    while (!qu.empty())                //队不空循环
    {
        e=qu.front(); qu.pop();        //出队结点e
        e1.no=total++; 
        e1.i=e.i+1;                //建立左孩子结点
        e1.w=e.w+w[e1.i];
        e1.v=e.v+v[e1.i];
        for (j=1;j<=n;j++)        //复制解向量
            e1.x[j]=e.x[j];
        e1.x[e1.i]=1;
        bound(e1);                //求左孩子结点的上界        
        if  ()        //剪枝:检查左孩子结点
        {
            EnQueue(e1,qu);            //左孩子结点进队操作
        }
        e2.no=total++;                //建立右孩子结点
        e2.i=e.i+1;
        e2.w=; 
        e2.v=;
        for (j=1;j<=n;j++)            //复制解向量
            e2.x[j]=e.x[j];
        e2.x[e2.i]=;
        bound(e2);                    //求右孩子结点的上界
        if ()                //若右孩子结点可行,则进队,否则被剪枝
            EnQueue(e2,qu);
    }
}
int main()
{
    cin>>n>>W; //输入物体个数及背包载重量 
    for(int i=1;i<=n;i++)//输入各物体重量及价值 
        cin>>w[i]>>v[i];    
    bfs();                    //调用队列式分枝限界法求0/1背包问题

    for(int i=1;i<=n;i++)
        printf("%d",bestx[i]);
    printf("\n%d",maxv);
    return 0;
}

第一空:(sumw+w[i]<=W) && i<=n

第二空:sumv+(W-sumw)*v[i]/w[i]

第三空:maxv=e.v

第四空:bestx[j]=e.x[j]

第五空:e.w+w[e.i+1]<=W&&e1.ub>maxv

第六空:e.w

第七空:e.v

第八空:0

第九空:e2.ub>maxv

5-9 部分背包问题(贪心法)

设有编号为1、2、...、n的n个物品,它们的重量分别为w1、w2、...、wn,价值分别为v1、v2、...、vn,其中wi、vi(1≤i≤n)均为正数。

有一个背包可以携带的最大重量不超过W。求解目标:在不超过背包负重的前提下,使背包装入的总价值最大。

cpp 复制代码
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
#define MAXN 51
//问题表示
int n;
double W;                    //限重
struct NodeType
{   int no;
    double w;
    double v;
    double p;                    //p=v/w
    float x;
    bool operator<(const NodeType &s) const
    {
        return p>s.p;            //按p递减排序
    }
};
NodeType A[MAXN]={{0}};    //下标0不用
//求解结果表示
double V;                        //最大价值
bool cmp(const NodeType &a,const NodeType &b)
{
    return a.no<b.no;
}

void Knap()                        //求解背包问题并返回总价值
{
    V=0;                        //V初始化为0
    double weight=W;            //背包中能装入的余下重量
    int i=1;
    while ()    
    {    A[i].x=1;                    //装入物品i
        ;            
        V+=A[i].v;                //累计总价值
        ;    
    }
    if (weight>0)                //当余下重量大于0
    {    A[i].x=;
        V+=A[i].x*A[i].v;            //累计总价值
    }
}

int main()
{   cin>>n>>W;
    for(int i=1;i<=n;i++)
    {
        cin>>A[i].no>>A[i].w>>A[i].v;A[i].x=0;
    }
    for (int i=1;i<=n;i++)            //求v/w
        A[i].p=A[i].v/A[i].w;
    sort(A+1,A+n+1);                //排序
    Knap();
    sort(A+1,A+n+1,cmp);
    for(int j=1;j<=n;j++)
        cout<<A[j].no<<" "<<A[j].x*A[j].v<<endl;
    cout<<V;
    return 0;
}
输入格式:

第一行物品数n和背包容量W,接着的n行中输入每个物品的编号,重量和价值。

输出格式:

输出装入背包的物品信息,共n行,按物品编号递增排序的物品编号及重量(物品编号从1开始)。最后一行输出总价值。

输入样例1:
5 100
1 10 20
2 20 30
3 30 66
4 40 40
5 50 60
输出样例1:
1 20
2 30
3 66
4 0
5 48
164

第一空:A[i].w<=weight

第二空:weight-=A[i].w

第三空:i++

第四空:weight/A[i].w

5-10 两个字符串的最长公共子序列长度

下面程序完成最长公共子序列的长度计算。

cpp 复制代码
#include<stdio.h>
#include<string.h>
#define N 80
int C[N][N];   // 记录最长公共子序列 
int rec[N][N]; // 记录轨迹 

int LCSLength(char *X, char *Y) 
{   int i,j,m=strlen(X),n=strlen(Y);
    for(i = 1; i <=m ; i++) {
    for(j = 1; j <= n; j++) {
       if() {
          C[i][j] = C[i-1][j-1] + 1;
          rec[i][j] = 1; //LU
       }else if() {
          C[i][j] = C[i-1][j]; 
          rec[i][j] = 2; //U
       }else {
          C[i][j] = ;
          rec[i][j] = 3; //L
       }
    }
    }
    return C[m][n];
}

第一空:X[i]==Y[j]

第二空:C[i-1][j]>=C[i][j-1]

第三空:C[i][j-1]

相关推荐
呆呆的猫40 分钟前
【LeetCode】803、打砖块
算法·leetcode·职场和发展
jazz_bin4 小时前
人工智能安全——大语言模型遗忘学习(LLM unlearning)与多目标优化算法
人工智能·算法·语言模型·unlearning·多目标优化·人工智能安全
生信碱移4 小时前
使用大语言模型的生物嵌入,后续应该会有很多类似文章出来!
人工智能·算法·语言模型·自然语言处理·chatgpt·数据分析
玉带湖水位记录员4 小时前
外观模式——C++实现
c++·外观模式
高 朗6 小时前
【算法刷题】链表
数据结构·算法·链表
zhonguncle6 小时前
「C++笔记」vector:C++中的新式“数组”
c++
2401_858286116 小时前
L27.【LeetCode笔记】2 的幂(五种解法)
c语言·开发语言·笔记·算法·leetcode
chenziang16 小时前
leetcode hot 100 不同路径
算法·leetcode·职场和发展
走在考研路上6 小时前
力扣459 重复的字符串
数据结构·算法·leetcode
❦丿多像灬笑话、℡6 小时前
leetcode热题100(763. 划分字母区间) c++
c++·算法·leetcode