dp复习

最新推荐文章于 2025-01-09 14:07:35 发布
最新推荐文章于 2025-01-09 14:07:35 发布
阅读量167 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44351585/article/details/89074210

#1: 【dp开始】数字三角形

题目描述

观察下面的数字金字塔。

写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。

 　　　　 7 
　　　　3   8 
　　   8   1   0 
　　2   7   4   4 
   4   5   2   6   5

在上面的样例中,从7 到 3 到 8 到 7 到 5 的路径产生了最大

输入格式

第一个行包含 R(1<= R<=1000) ,表示行的数目。

后面每行为这个数字金字塔特定行包含的整数。

所有的被供应的整数是非负的且不大于100。

输出格式

单独的一行,包含那个可能得到的最大的和。

样例数据

input

5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

output

30

数据规模与约定

usaco1.5.1

时间限制：1s1 \text {s}1s

空间限制：256MB256 \text {MB}256MB
这题呢有种非常暴力的解法，就是两重循环，每次a[i][j]都由上面两个与其接近的数的最大值。最后再对a[r][i]取max。
Code：

#include<bits/stdc++.h>
using namespace std;
#define f(a,b,c)  for(int c=a;c<=b;c++)
const int twx=1000+10;
int a[twx][twx];
int r;
int sum;
void init()
{
    cin>>r;
    f(1,r,i)
    {
        f(1,i,j)
        {
            cin>>a[i][j];
        }
    }
}
void work()
{
    f(1,r,i)
    {
        f(1,i,j)
        {
            a[i][j]=a[i][j]+max(a[i-1][j],a[i-1][j-1]);
        }
    }
}
void print()
{
    f(1,r,i)
    {
        sum=max(a[r][i],sum);
    }
    cout<<sum;
}
int main()
{
    //freopen("numtri.in","r",stdin);
    //freopen("numtri.out","w",stdout);
    init();
    work();
    print();
}

#2: 导弹拦截

题目描述

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

输入导弹的枚数和导弹依次飞来的高度（雷达给出的高度数据是不大于30000的正整数，每个数据之间有一个空格），计算这套系统最多能拦截多少导弹？

如果要拦截所有导弹最少要配备多少套这种导弹拦截系统？

输入格式

第一行数字n表示n个导弹(n<=200)
第二行n个数字，表示n个导弹的高度

输出格式

一个整数，表示最多能拦截的导弹数

一个整数，表示要拦截所有导弹最少要配备的系统数

样例数据

input

8
389  207  155  300  299  170  158  65

output

6
2

数据规模与约定

时间限制：1s1 \text {s}1s

空间限制：256MB256 \text {MB}256MB
本题第一问是最长不下降子序列问题，十分经典。第二问是贪心，每颗导弹来袭时，使用能拦截这颗导弹的防御系统中上一次拦截导弹高度最低的那一套来拦截。若不存在符合这一条件的系统，则使用一套新的系统。
Code：

#include<bits/stdc++.h>
using namespace std;
#define f(a,b,c) for(int c=a;c<=b;c++)
#define so1(a,n,mycmp) sort(a+1,a+n+1,mycmp);
#define so2(a,n) sort(a+1,a+n+1);
#define ll long long
#define in cin
#define out cout
const int twx=10000+100;
int n;
int a[twx]={};
int f[twx]={};
int h[twx]={};
int ans1=-1e5;
int ans2=1;
void init()
{
    in>>n;
    f(1,n,i)
    {
        in>>a[i];
    }
}
void work()
{
    f[1]=1;
    f(2,n,i)
    {
        f(1,i-1,j)
        {
            if(a[i]<=a[j]&&f[j]>f[i])
            {
                f[i]=f[j];
            }
        }
        f[i]++;
        if(f[i]>ans1)
        {
            ans1=f[i];
        }
    }
    h[1]=a[1];
    f(2,n,i)
    {
        f(1,ans2,j)
        {
            so2(h,ans2)
            if(h[ans2]<a[i])
            {
                ans2++;
                h[ans2]=a[i];
                break;
            }
            if(h[j]>=a[i])
            {
                h[j]=a[i];
                break;
            }
        }
    }
}
void print()
{
    out<<ans1<<endl<<ans2;
}
int main()
{
    //freopen("missile.in","r",stdin);
    //freopen("missile.out","w",stdout);
    init();
    work();
    print();
    return 0;
}

#3: lis模板题

题目描述

有NNN个整数，输出这NNN个整数的最长上升序列、最长下降序列、最长不上升序列和最长不下降序列。

输入格式

第一行，仅有一个数NNN。 N&lt;=700000N&lt;=700000N<=700000
第二行，有NNN个整数。 $-109<=每个数<=109 $

输出格式

第一行，输出最长上升序列长度。

第二行，输出最长下降序列长度。

第三行，输出最长不上升序列长度。

第四行，输出最长不下降序列长度。

样例数据

input

10
1 3 0 8 6 2 3 1 4 2

output

4
4
4
4

数据规模与约定

数据生成由 zqc，heaonan，zhouhang 等人对拍而成

时间限制：1s1 \text {s}1s

空间限制：256MB256 \text {MB}256MB
本题呢最主要的是使用log级的算法（二分吧 毕竟700000 O(n^2)的算法也会超），四个操作有着极大打相似度，请自行注意。
Code:

#include<bits/stdc++.h>
using namespace std;
#define f(a,b,c) for(int c=a;c<=b;c++)
#define so1(a,n,mycmp) sort(a+1,a+n+1,mycmp);
#define so2(a,n) sort(a+1,a+n+1);
#define ll long long
#define in cin
#define out cout
const int twx=700000+100;
int n;
ll a[twx];
ll b[twx]; 
ll s1,s2,s3,s4;
void clean()
{
    memset(b,0,sizeof(b));
}
void init()
{
    in>>n;
    f(1,n,i)
    {
        scanf("%lld",&a[i]);
    }
}
void work_1()//最长上升序列长度
{
    clean();
    s1=0;
    ll pos;
    b[0]=-1e10;
    f(1,n,i)
    {
        if(a[i]>b[s1])
        {
            b[++s1]=a[i];
        }
        else
        {
            ll Left=1;
            ll Right=s1;
            ll Mid;
            while(Left+1<Right)
            {
                Mid=(Left+Right)/2;
                if(a[i]>b[Mid])
                {
                    Left=Mid;
                }
                else
                {
                    Right=Mid;
                }
            }
            if(a[i]>b[Left])
            {
                pos=Right;
            }
            else
            {
                pos=Left;
            }
            b[pos]=min(b[pos],a[i]);
        }
    }
}
void work_2()//最长下降序列
{
    clean();
    s2=0;
    ll pos;
    b[0]=1e10;
    f(1,n,i)
    {
        if(a[i]<b[s2])
        {
            b[++s2]=a[i];
        }
        else
        {
            ll Left=1;
            ll Right=s2;
            ll Mid;
            while(Left+1<Right)
            {
                Mid=(Left+Right)/2;
                if(a[i]<b[Mid])
                {
                    Left=Mid;
                }
                else
                {
                    Right=Mid;
                }
            }
            if(a[i]<b[Left])
            {
                pos=Right;
            }
            else
            {
                pos=Left;
            }
            b[pos]=max(b[pos],a[i]);
        }
    }
}
void work_3()//最长不上升序列
{
    clean();
    s3=0;
    ll pos;
    b[0]=1e10;
    f(1,n,i)
    {
        if(a[i]<=b[s3])
        {
            b[++s3]=a[i];
        }
        else
        {
            ll Left=1;
            ll Right=s3;
            ll Mid;
            while(Left+1<Right)
            {
                Mid=(Left+Right)/2;
                if(a[i]<=b[Mid])
                {
                    Left=Mid;
                }
                else
                {
                    Right=Mid;
                }
            }
            if(a[i]<=b[Left])
            {
                pos=Right;
            }
            else
            {
                pos=Left;
            }
            b[pos]=max(b[pos],a[i]);
        }
    }
}
void work_4()// 最长不下降序列
{
    clean();
    s4=0;
    ll pos;
    b[0]=-1e10;
    f(1,n,i)
    {
        if(a[i]>=b[s4])
        {
            b[++s4]=a[i];
        }
        else
        {
            ll Left=1;
            ll Right=s4;
            ll Mid;
            while(Left+1<Right)
            {
                Mid=(Left+Right)/2;
                if(a[i]>=b[Mid])
                {
                    Left=Mid;
                }
                else
                {
                    Right=Mid;
                }
            }
            if(a[i]>=b[Left])
            {
                pos=Right;
            }
            else
            {
                pos=Left;
            }
            b[pos]=min(b[pos],a[i]);
        }
    }
}
void print()
{
    out<<s1<<endl<<s2<<endl<<s3<<endl<<s4;
}
int main()
{
    //freopen("data.in","r",stdin);
    //freopen("data.out","w",stdout);
    init();
    work_1();
    work_2();
    work_3();
    work_4();
    print();
    return 0;
}

#4: 【背包】采药

题目描述

宁智贤是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。

医师为了判断他的资质，给他出了一个难题。

医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。

如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是宁智贤，你能完成这个任务吗？

输入格式

输入的第一行有两个整数T（1 <= T <= 1000）和M（1 <= M <= 100），用一个空格隔开，T代表总共能够用来采药的时间，M代表山洞里的草药的数目。接下来的M行每行包括两个在1到100之间（包括1和100）的整数，分别表示采摘某株草药的时间和这株草药的价值。

输出格式

输出包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。

样例数据

input

70 3
71 100
69 1
1 2

output

3

数据规模与约定

时间限制：1s1 \text {s}1s

空间限制：256MB256 \text {MB}256MB
这是一道很裸的0/1背包的题目，核心代码就是asd[j]=max(asd[j],asd[j-a[i].shijian]+a[i].jiazhi) 这不就是0/1背包吗？？？
Code：

#include<bits/stdc++.h>
using namespace std;
#define f(a,b,c) for(int c=a;c<=b;c++)
#define so1(a,n,mycmp) sort(a+1,a+n+1,mycmp);
#define so2(a,n) sort(a+1,a+n+1);
#define ll long long
#define in cin
#define out cout
const int twx=10000+100;
int t,m;
struct LV
{
    int shijian;
    int jiazhi;
}a[twx];
int asd[twx];
void init()
{
    in>>t>>m;
    f(1,m,i)
    {
        in>>a[i].shijian>>a[i].jiazhi;
    }
}
void work()
{
    f(1,m,i)
    {
        for(int j=t;j>=a[i].shijian;j--)
        {
            asd[j]=max(asd[j],asd[j-a[i].shijian]+a[i].jiazhi);
        }
    }
}
void print()
{
    out<<asd[t];
}
int main()
{
    //freopen("input.in","r",stdin);
    //freopen("output.out","w",stdout);
    init();
    work();
    print();
    return 0;
}

#5: 背包的第k优解

题目描述

DD 和好朋友们要去爬山啦！他们一共有 K 个人，每个人都会背一个包。这些包的容量是相同的，都是 V。可以装进背包里的一共有 N 种物品，每种物品都有给定的体积和价值。

在 DD 看来，合理的背包安排方案是这样的：

  1. 每个人背包里装的物品的总体积恰等于包的容量。

  2. 每个包里的每种物品最多只有一件，但两个不同的包中可以存在相同的物品。

  3. 任意两个人，他们包里的物品清单不能完全相同。

在满足以上要求的前提下，所有包里的所有物品的总价值最大是多少呢？

输入格式

第一行有三个整数：K、V、N。

第二行开始的 N 行，每行有两个整数，分别代表这件物品的体积和价值。

输出格式

只需输出一个整数，即在满足以上要求的前提下所有物品的总价值的最大值。

样例数据

input

2 10 5
3 12
7 20
2 4
5 6
1 1

output

57

样例说明

一种可以得到最优解的方案是：第一个人背体积为 7、2、1 的三种物品，价值为 25。第二个人背体积为 3、7 的两种物品，价值为 32。总价值 57。

数据规模与约定

保证总人数 K<=50。 每个背包的容量 V<=5000。 物品种类数 N<=200。

其它正整数都不超过 5000。 输入数据保证存在满足要求的方案。

时间限制：1s1 \text {s}1s

空间限制：256MB256 \text {MB}256MB
本题一开始先将初值设为负无穷，代表不存在解，在原先完全背包的基础上加上一维，设asd[j][k]表示体积为j是第k优解的值。先令asd[0][1]=0。让t往上加，这个t是否增加取决于当前的最优值的决定取值，设yusuan1和yusuan2如果要这个物品就是yusuan2++，不要就是yusuan1++
Code：

///                   _ooOoo_
///                  o8888888o
///                  88" . "88
///                  (| -_- |)
///                  O\  =  /O
///               ____/`---'\____
///             .'  \\|     |//  `.
///            /  \\|||  :  |||//  \
///           /  _||||| -:- |||||-  \
///           |   | \\\  -  /// |   |
///           | \_|  ''\---/''  |   |
///           \  .-\__  `-`  ___/-. /
///         ___`. .'  /--.--\  `. . __
///      ."" '<  `.___\_<|>_/___.'  >'"".
///     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
///     \  \ `-.   \_ __\ /__ _/   .-` /  /
///======`-.____`-.___\_____/___.-`____.-'======
///                   `=---='
///^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
///
///         佛祖保佑       永无BUG
///
///  本模块已经经过ycy开光处理，绝无可能再产生bug
///
///=============================================
///     へ　　　　　／|
///　　/＼7　　　 ∠＿/
///　 /　│　　 ／　／
///　│　Z ＿,＜　／　　 /`ヽ
///　│　　　　　ヽ　　 /　　〉
///　 Y　　　　　`　 /　　/
///　?●　?　●　　??〈　　/
///　()　 へ　　　　|　＼〈
///　　>? ?_　 ィ　 │ ／／
///　 / へ　　 /　?＜| ＼＼
///　 ヽ_?　　(_／　 │／／
///　　7　　　　　　　|／
///　　＞―r￣￣`?―＿
#include<bits/stdc++.h>
using namespace std;
#define f(a,b,c) for(int c=a;c<=b;c++)
#define so1(a,n,mycmp) sort(a+1,a+n+1,mycmp);
#define so2(a,n) sort(a+1,a+n+1);
#define ll long long
#define in cin
#define out cout
const int twx=200+100;
int k,v,n;
int weight[twx],value[twx];
int a[twx*20],b[twx*20],asd[twx*20][twx*20];
int ans=0;
int yusuan1,yusuan2;
int t;
void init()
{
    in>>k>>v>>n;
    f(1,n,i)
    {
        in>>weight[i]>>value[i];
    }
}
void work()
{
    memset(asd,-10,sizeof(asd));
    asd[0][1]=0;
    for(int i=n;i>=1;i--)
    {
        for(int j=v;j>=weight[i];j--)
        {
            yusuan1=1;
            yusuan2=1;
            f(1,k,l)
            {
                a[l]=asd[j][l];
                b[l]=asd[j-weight[i]][l]+value[i];
            }
            t=0;
            while(t<k)
            {
                if(a[yusuan1]>b[yusuan2]) 
                {
                    t++;
                    asd[j][t]=a[yusuan1];
                    yusuan1++;
                }
                else 
                {
                    t++; 
                    asd[j][t]=b[yusuan2]; 
                    yusuan2++;
                }
            }
        }
    }
    f(1,k,i)
    {
        ans+=asd[v][i];
    }
}
void print()
{
    out<<ans;
}
int main()
{
    //freopen("bags.in","r",stdin);
    //freopen("bags.out","w",stdout);
    init();
    work();
    print();
    return 0;
}
LV24twx
关注
2.7复习算法（数学，dp ）
weixin_73636261的博客
02-25 823
数学1.先分析2.打表找规律，即暴力找前面的一部分，总结公式，规律需要多总结一些公式n和m最大不能组成的数字：nm-n-m蚂蚁相撞会掉头，相当于一直向一个方向走，不掉头动态规划和递推很像，从实际意义出发，比如斐波那契数列列状态转移；然后确定初始化01背包问题。
python算法复习(八)----树形dp、位运算
weixin_46253576的博客
05-07 721
# 本章的内容是树形dp，非常重要，熟练掌握后可以解决大部分二叉树问题。 # 以及大数据问题的补充点，以及之前学习过程中没有完成的二进制运算(感谢Golang) class TreeNode(object): def __init__(self, value): self.value = value self.left = None self.right = None def __repr__(self): return s.
DP复习
fyfcauc的专栏
06-04 509
重新复习了算法导论的DP一章： 以前也看过， 不过那时候就是看， 基本没怎么用， 现在回过头来再看，还是很多发现。 根据求解子问题顺序的不同， 程序也会变为递归和迭代两种， 比如 a[i, k](k == 1 || k ==2, k依赖于每一步的选择空间有几个) 的结果依赖于 a[i-1, 1] 和 a[i-1, 2]。 如果是顺序的从 i = 0 开始求， 那么就是迭代。 如果是逆序的
DP复习1
qq_40474867的博客
05-30 172
反正是复习，就直接写例题了。 1.Mr. Youngs Picture Permutations 要求每组数据输出一个可行的方案数。 样例数据 input 1 30 5 1 1 1 1 1 3 3 2 1 4 5 3 3 1 5 6 5 4 3 2 2 15 15 0 output 1 1 16 4158 141892608 9694845 可以用一个数组（a1...
dp专题复习
weixin_30883271的博客
03-07 130
背包： 1、bzoj2287:【POJ Challenge】消失之物 2、bzoj2748:[HAOI2012]音量调节 3、bzoj2794:[Poi2012]Cloakroom 4、bzoj1190:[HNOI2007]梦幻岛宝珠 树形dp： 1、bzoj1864:[Zjoi2006]三色二叉树 2、bzoj4472:[Jsoi2015]salesman 3、bzoj4033:[HAOI201...
dp复习【第一章】
m0_51678367的博客
04-06 515
import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String string = new String(); string = scanner.next(); char[] st = new char[string.length()]; st = string.toChar..
DP-600微软MCP ET.pdf
04-29
- **复习功能**：完成案例后，有一个审查页面允许考生回顾并修改答案。 #### Contoso公司概述 - **公司结构**： - 销售部门（Online Sales和Retail Sales） - 研究部门（负责内部产品线开发） - **现有环境**：...
DP-900中文.pdf
12-07
DP-900 微软 Azure 数据 Fundamentals 考试复习笔记 本文档总结了 DP-900 考试的重要知识点，涵盖了数据处理、数据仓库、数据分析、数据可视化、数据存储等方面的知识点。 一、数据处理 * 规范化数据库可以减少...
Azure DP-900完全指南(一) 介绍
最新发布
海棠AI实验室
01-09 834
MicrosoftAzureDP-900认证是微软为数据领域从业人员提供的一项基础认证，旨在帮助您建立扎实的数据基础知识，并将这些知识应用到Azure平台中的实际数据处理和分析工作中。对于初学者而言，DP-900是进入Azure云平台和数据科学领域的起点，适合那些希望了解数据在Azure平台上如何存储、管理和分析的人员。
DP复习——完全背包
蒟蒻柴犬首相的博客
03-07 318
完全背包 完全背包，就是有nnn种物品，每种物品每个都有一个重量wiwiw_i和一个价值viviv_i，每种物品都有足够多个，还有一个mmm容量的背包。我们的任务就是取若干个物品，在∑所取的w[i]&lt;=m∑所取的w[i]&lt;=m\sum_{所取的}w[i]∑所取的v[i]∑所取的v[i]\sum_{所取的}v[i]。 例题 题目描述 有一个负重能力为m(m&lt;=300)的...
【NOIp复习】dp复习列表
尽吾之力，以达天际
11-02 650
1、背包问题 01背包 完全背包 多重背包 混合背包 二维花费（包括限制物品件数的变式） 分组背包（dp方程为第k组花费为c选或者不选） 有依赖背包问题——树形dp 2、树状dp 没有上司的舞会（练习多叉树转左儿子右兄弟树，处理有依赖的背包问题） 皇宫看守（还没有ac，有时间尝试以下把状态表示换成dp[i][0/1/2]代表当前有看守、父节点有看守、子节点有看守？） 3、区间dp 石子归并（线性）
HLOJ434 关灯
蒟蒻柴犬首相的博客
04-17 449
题目 题目描述 宁智贤得到了一份有趣而高薪的工作。每天早晨她必须关掉她所在村庄的街灯。所有的街灯都被设置在一条直路的同一侧。 宁智贤每晚到早晨5点钟都在晚会上，然后她开始关灯。开始时，她站在某一盏路灯的旁边。 每盏灯都有一个给定功率的电灯泡，因为宁智贤有着自觉的节能意识，她希望在耗能总数最少的情况下将所有的灯关掉。 宁智贤因为太累了，所以只能以1m/s的速度行走。关灯不需要花费额外的时间，因为...
单调栈
zjh_2017的博客
10-27 470
先放一道题目： #211. 乱头发节 题目描述 宁智贤的某 N 头奶牛 (1 每一头牛 i有一个高度 h[i] (1 例如样例: 让 c[i] 表示第i头牛可以看到发型的牛的数量；请输出 c[1] 至 c[N]的和。 如上面的这个例子，正确解是3 + 0 + 1 + 0 + 1 + 0 = 5。 输入格式 Line 1: 牛的数量 N。 Lines 2..N+1: 第 i
JZOJ 青铜莲花池（bfs-广度优先搜索）
Admin-zx 的博客
05-29 707
目录DescriptionInputOutputDataSolutionCode Description Farmer John为了满足宁智贤对美的享受而安装了人工湖。矩形的人工湖分成M行NNN 列 (1<=M<=30;1<=N<=30)(1 <= M <= 30; 1 <= N <= 30)(1<=M<=30;1<=N<=30) 的方形小格子。有些格子有美丽的荷叶，有些有岩石，剩下的格子有的只是美丽的蓝色湖水。 宁智贤通过从一片荷叶跳
见贤思齐焉，见不贤而内自省也
weixin_30613727的博客
08-03 852
　　孟子曰："舜发于畎亩之中，傅说举于版筑之间，胶鬲举于鱼盐之中，管夷吾举于士，孙叔敖举于海，百里奚举于市。故天将降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行拂乱其所为，所以动心忍性，曾益其所不能。人恒过，然后能改。困于心，衡于虑，而后作。徵于色，发于声，而后喻。入则无法家拂士，出则无敌国外患者，国恒亡。然后知生于忧患，而死于安乐也。" 　　 转载于:https://www.c...
【洛谷】P1616 疯狂的采药
2302_80216196的博客
04-04 1239
医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同种类的草药，采每一种都需要一些时间，每一种也有它自身的价值。如果各个子问题不是独立的(即重复的)，且不同子问题的个数是有限的，那么如果我们可以保存已经解决的子问题的答案，而在需要时再找出已经求得的答案，这样就可以避免大量的重复计算，以此减少时间复杂度。第 2 到第 (m+1) 行，每行两个整数，第 (i+1) 行的整数ai​,bi​ 分别表示采摘第 i 种草药的时间和该草药的价值。1.最优子结构：即大问题的最优解包含子问题的最优解。
CH5302 金字塔（区间DP）
A_Bright_CH的博客
09-18 992
题目 虽然探索金字塔是极其老套的剧情，但是有一队探险家还是到了某金字塔脚下。经过多年的研究，科学家对这座金字塔的内部结构已经有所了解。首先，金字塔由若干房间组成，房间之间连有通道。如果把房间看作节点，通道看作边的话，整个金字塔呈现一个有根树结构，节点的子树之间有序，金字塔有唯一的一个入口通向树根。并且，每个房间的墙壁都涂有若干种颜色的一种。 探险队员打算进一步了解金字塔的结构，为此，他们使用了一...
Microsoft DP-201: 设计Azure数据解决方案模拟试题
"DP-201是微软的Designing an Azure Data Solution考试的复习资料，包含74个问题，涵盖了Trey Research案例研究、案例研究1、案例研究2和其他混合问题。这份资料旨在帮助考生熟悉考试结构和内容，特别是与设计Azure...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值