GDPU 小试牛刀

`自由发挥，尽力就行，答案无标准，你就是唯一！`

`Take it easy!`

前端

1. HTML

请问HTML的全称是什么？

Hyper Text Markup Language 超文本标记语言

2. 文档流

请谈一谈你对文档流的理解？言简意赅最好

在前端开发中，文档流（Document Flow）指的是HTML文档中元素按照其在DOM（文档对象模型）中的先后顺序依次排列的方式。文档流决定了元素在页面中的位置及其相互之间的关系。
文档流分为两种类型：正常流（Normal Flow）和浮动流（Float Flow）。

在正常流中，元素按照其在DOM树中的先后顺序从上到下依次排列。在这种布局方式下，元素默认按照块级元素（block）或内联元素（inline）的特性进行排列，块级元素会占据一整行，而内联元素则会在同一行内按照从左到右的顺序排列。

而浮动流中，元素可以通过设置浮动属性（float）来脱离正常流，使得其他元素可以环绕在其周围。浮动元素会向左或向右移动，直到遇到父级元素的边界或其他浮动元素，从而改变其在页面中的位置。

3. 拓展：塌陷

请设计一个由于脱离文档流出现塌陷问题的前端页面。

✨ 参考代码

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>塌陷</title>
    <style>
        .outer {
            width: 500px;
            background-color: aliceblue;
            border: 1px solid black;
            /* 解决方式 1 */
            /* float: left; */
            /* 解决方式 2 */
            /* height: 130px; */
            /* 解决方式 3 */
            /* overflow: hidden; */
        }

        .box {
            width: 100px;
            height: 100px;
            background-color: beige;
            border: 1px solid black;
            margin: 10px;
            float: left;
        }
        /* 解决方式 4 */
        /* .mofa {
            clear: both;
        } */
        /* 解决方式 5 */
        /* .outer::after {
            content: '';
            display: block;
            clear: both;
        } */
    </style>
</head>
<body>
    <div class = "outer"> 
        <div class = "box">1</div>
        <div class = "box">2</div>
        <div class = "box">3</div>
        <!-- <div class="mofa"></div> -->
    </div>
</body>
</html>

在这里插入图片描述

算法

1. 排序

请简述你最喜欢的排序算法思想。

以下问题需编写程序，语言不限，支持 c、c++、java、python、go、js 等
~~当热，实在不会，也可以以文字的形式谈谈你的思路~~

2. A+B

输入两个整数，求这两个整数的和是多少。

输入格式

输入两个整数 $A, B$ ，用空格隔开

输出格式

输出一个整数，表示这两个数的和

数据范围

$\le A, B \le 10 ^ 8$

样例输入：

3 4

样例输出：

✨ 参考代码

#include <iostream>
using namespace std;
int main()
{
	int a,b;
	cin >> a >> b;
	cout << a + b << endl;
	return 0;
}

3. 自幂数

在十进制中，一个n位自然数等于自身各个数位上数字的n次幂之和，则称此数为自幂数。

例如：153是一个三位数，各个数位的3次幂之和为 $1^3 +5^3+3^3=153$ ，所以153是十进制中的自幂数。1634是一个四位数，各个数位的4次幂之和为 $1^4+6^4+3^4+4^4 = 1634$ ，所以1643也是十进制中的自幂数。

现在要求输出所有在 $m$ 和 $n$ 范围内的自幂数。

输入格式

输入包含多组测试数据。

每组数据占一行，包含两个整数 $m$ 和 $n$ 。

最后一行 0 0 表示输入结束。

输出格式

每组数据输出一行答案，从小到大输出所有位于 [m,n] 范围内的自幂数，数之间用空格隔开，如果没有则输出 no。

数据范围

$\lt m \le n \le 10^{10}$

输入样例：

100 120 
8 10000
-1

输出样例：

no
8 9 153 370 371 407 1634 8208 9474

✨ 朴素版

#include <iostream>
#include <algorithm>
#include <math.h>

using namespace std;
long mi[11][11];//mi[底数][指数] 初始化默认为0
long num[11];

void 初始化幂数组()
{
//	注意：0 的 0 次方是0，其他数的 0 次方是 1
	for(int i = 1; i < 11; i++) mi[i][0] = 1;
	
	for(int i= 1; i < 11 ;i++){
		for(int j = 1; j < 11; j ++)
			mi[i][j] = mi[i][j-1] * i;
	}
}

bool 是否自幂(int x)
{
	int cnt = 0;
	int t = x;
	while(t){
		t /= 10;
		cnt++;
	}
	long ans = 0;
	t = x;
	while(t){
		int xx = t % 10;
//		朴素版 运行时间：约30分钟
//		ans += pow(xx,cnt); //重复计算过多
		
//		预处理幂指数的计算结果版：约180S
		ans += mi[xx][cnt];
		t /= 10;
	}
	if(ans == x)
		return true;
	return false;
}

void cal(long m,long n)
{
	bool flag = false;
	for(long i = m; i <= n; i++)
	{
		if(是否自幂(i))
		{
			cout << i << " ";
			flag = true;
		}
	}
	if(!flag)
		cout << "no";
	cout << endl;
}


int main()
{
	long m,n;
	初始化幂数组();
	while(1){
		cin >> m >> n;
		if(!m && !n)
			break;
		cal(m,n);
	}
	return 0;
}

✨ 优化版

#include<cstdio>
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
typedef long long ll;

int n,m, a[20], f[20], cnt; // n是位数，a用来存放当前数字的各个位上的数字，f用来统计当前数字的各个位上的数字出现的次数，cnt是结果的个数
ll ans[1000]; // 存放结果

// 快速幂运算
ll poww(int a, int b) {
	ll ans = 1, base = a;
	while (b != 0) {
		if (b & 1 != 0) // 判断是否为奇数
			ans *= base;
		base *= base;
		b >>= 1; // 右移一位，相当于除以2
	}
	return ans;
}

// 计算数字的位数
int calc(ll sum) {
	ll t = sum;
	int num = 0;
	memset(f, 0, sizeof(f)); // 将数组f初始化为0
	while (t) {
		ll tmp = t % 10; // 取最低位
		t /= 10; // 右移一位，相当于除以10
		f[tmp] ++;
		num++;
	}
	return num;
}

// 深度优先搜索
void 暴搜(int ps, int hs, ll sum, double dbsum) {
	if (ps == 9) { // 已经填充到最高位
		a[ps] = hs;
		sum += (ll)hs*poww(9, n); // 计算当前数字的值
		dbsum += (double)hs*poww(9, n);
		if (dbsum <= 1e19 && sum > 0) { // 检查是否在ll类型的范围内，同时sum要大于0
			if (calc(sum) == n) { // 检查位数是否符合要求
				bool flag = 1;
				for (int i = 0; i <= 9; i++) {
					if (f[i] != a[i])flag = 0; // 检查各个位上的数字次数是否符合要求
				}
				if (flag)ans[cnt++] = sum; // 符合要求则存入结果数组
			}
		}
		return;
	}
	for (int i = 0; i <= hs; i++) {
		a[ps] = i; // 当前位填充的数字为i
		暴搜(ps + 1, hs - i, sum + (ll)i*poww(ps, n), dbsum + (double)i*poww(ps, n)); // 递归填充下一位
	}
}

void 打表()
{
	ans[cnt++] = 0;//突然发现 0 也是自幂数
//	提前计算出 1~12位的所有自幂数
	for(n = 0; n <= 12; n++)
		暴搜(0, n, 0, 0);
	sort(ans, ans + cnt);
}
int main() {
	打表();
	ll n,m;
	while(1){
		cin >> m >> n;
		if(m == 0 && n == 0)
			break;
		bool flag = false;
		for(int i = 0; i < cnt; i++)
			if(ans[i] >= m && ans[i] <= n)
			{
				flag = true;
				cout << ans[i] << " ";
			}
		if(!flag)
			cout << "no";
		cout << endl;
	}
	return 0;
}

👨‍🏫 参考题解

4. 拓展：炸弹

🍑 洛谷在线评测地址
🍑 CodeForce原题地址

弗卢伊在斯诺登埋了炸弹

炸弹的计时器初始设置为 $b$ 。每秒钟，计时器都会减少 $1$ 。当计时器达到 $0$ 时，炸弹就会爆炸！为了让斯诺丁的居民有足够的时间撤离，你需要尽可能延长炸弹爆炸的时间。

您有 $n$ 种工具。每种工具最多只能使用1次。如果你使用了第 i 个工具，计时器会增加 $x_i$ 。但是，如果将计时器更改为大于 $a$ 的整数，由于一个错误，计时器将被设置为 $a$ 。

更具体地说，以下事件将按照以下顺序每秒发生一次：

您将选择一些（可能没有）之前未使用过的工具。如果您选择了第 i 个工具，而炸弹的计时器当前设置为 $c$ ，那么计时器将变为 $min(c + x_i, a)$ 。
计时器会减少 $1$ 。
如果计时器达到 $0$ ，炸弹就会爆炸。

水母现在想知道，如果优化使用这些工具，炸弹爆炸前的最长时间（以秒为单位）是多少。

输入

每个测试包含多个测试用例。第一行包含测试用例的数量 $t$ ( $\leq t \leq 2000$ )。测试用例说明如下。

每个测试用例的第一行包含三个整数 $a$ 、 $b$ 和 $n$ （ $\leq b \leq a \leq 10^9$ 、 $\leq n \leq 100$ ），分别为炸弹计时器的最大值、炸弹计时器的初始值和工具数量。

每个测试的第二行包含 $n$ 个整数 $x_1, x_2, \dots, x_n$ （ $\leq x_i \leq 10^9$ ），分别为通过使用 $i$ -th 工具，计时器可以增加的数量。

请注意，所有测试用例的 $n$ 之和是不受约束的。

输出

对于每个测试用例，输出一个整数表示炸弹爆炸前的最长时间（以秒为单位）。

样例输入：

样例输出：

9
21

提示

让 $c$ 表示炸弹定时器的值。在第一个测试案例中

第二个 $1$ ：在这一秒选择工具 $1$ 和 $2$ ，然后是 $c = 5$ ；计时器减少 $1$ ，然后是 $c = 4$ 。
第二个 $2$ ：计时器依次递减 $1$ 、 $c = 3$ 。
第二次 $3$ ：计时器依次递减 $1$ 、 $c = 2$ 。
第二次 $4$ ：计时器依次递减 $1$ 、 $c = 1$ 。
第二个 $5$ ：选择工具 $3$ ，然后 $c = 5$ ；计时器依次减少 $1$ ，然后 $c = 4$ 。
第二次 $6$ ：计时器依次递减 $1$ 、 $c = 3$ 。
第二个 $7$ ：计时器依次递减 $1$ 、 $c = 2$ 。
第二次 $8$ ：计时器依次递减 $1$ 、 $c = 1$ 。
第二次 $9$ ：计时器减少 $1$ ，然后 $c = 0$ 。炸弹爆炸。

可以证明，没有办法使用工具使炸弹在超过 $9$ 秒后爆炸。

✨ 参考代码

#include<iostream>
#include<math.h>

using namespace std;

typedef long long ll;

int main()
{
	int T;
	cin >> T;//测试案例数
	while(T--){
		int a;//计时器的最大值
		int b;//计时器的初始值
		int n;//工具的数量
		cin >> a >> b >> n;
		ll ans = b;//炸弹爆炸前的最长时间（记得开long long）
		for(int i = 0; i < n; i++)//输入n个工具
		{
			int time;//工具可以延长的时间
			cin >> time;
			ans += min(a-1,time);
		}
		cout << ans << endl;
	}
	
	return 0;
}