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">1div>
        <div class = "box">2div>
        <div class = "box">3div>
        
    div>
body>
html>

GDPU 小试牛刀_第1张图片
GDPU 小试牛刀_第2张图片


算法

1. 排序

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


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

2. A+B

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

输入格式

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

输出格式

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

数据范围

0 ≤ A , B ≤ 1 0 8 0 \le A, B \le 10 ^ 8 0A,B108

样例输入:

3 4

样例输出:

7

✨ 参考代码

#include 
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 1^3 +5^3+3^3=153 13+53+33=153,所以153是十进制中的自幂数。1634是一个四位数,各个数位的4次幂之和为 1 4 + 6 4 + 3 4 + 4 4 = 1634 1^4+6^4+3^4+4^4 = 1634 14+64+34+44=1634,所以1643也是十进制中的自幂数。

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

输入格式

输入包含多组测试数据。

每组数据占一行,包含两个整数 m m m n n n

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

输出格式

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

数据范围

0 < m ≤ n ≤ 1 0 10 0 \lt m \le n \le 10^{10} 0<mn1010

输入样例:

100 120 
8 10000
-1

输出样例:

no
8 9 153 370 371 407 1634 8208 9474

✨ 朴素版

#include 
#include 
#include 

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
#include
#include
#include
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 b b。每秒钟,计时器都会减少 1 1 1。当计时器达到 0 0 0时,炸弹就会爆炸!为了让斯诺丁的居民有足够的时间撤离,你需要尽可能延长炸弹爆炸的时间。

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

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

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

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

输入

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

每个测试用例的第一行包含三个整数 a a a b b b n n n 1 ≤ b ≤ a ≤ 1 0 9 1 \leq b \leq a \leq 10^9 1ba109 1 ≤ n ≤ 100 1 \leq n \leq 100 1n100),分别为炸弹计时器的最大值、炸弹计时器的初始值和工具数量。

每个测试的第二行包含 n n n 个整数 x 1 , x 2 , … , x n x_1, x_2, \dots, x_n x1,x2,,xn 1 ≤ x i ≤ 1 0 9 1 \leq x_i \leq 10^9 1xi109),分别为通过使用 i i i-th 工具,计时器可以增加的数量。

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

输出

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

样例输入:

2
5 3 3
1 1 7
7 1 5
1 2 5 6 8

样例输出:

9
21

提示

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

  • 第二个 1 1 1:在这一秒选择工具 1 1 1 2 2 2,然后是 c = 5 c=5 c=5;计时器减少 1 1 1,然后是 c = 4 c=4 c=4
  • 第二个 2 2 2:计时器依次递减 1 1 1 c = 3 c=3 c=3
  • 第二次 3 3 3:计时器依次递减 1 1 1 c = 2 c=2 c=2
  • 第二次 4 4 4:计时器依次递减 1 1 1 c = 1 c=1 c=1
  • 第二个 5 5 5:选择工具 3 3 3,然后 c = 5 c=5 c=5;计时器依次减少 1 1 1,然后 c = 4 c=4 c=4
  • 第二次 6 6 6:计时器依次递减 1 1 1 c = 3 c=3 c=3
  • 第二个 7 7 7:计时器依次递减 1 1 1 c = 2 c=2 c=2
  • 第二次 8 8 8:计时器依次递减 1 1 1 c = 1 c=1 c=1
  • 第二次 9 9 9:计时器减少 1 1 1,然后 c = 0 c=0 c=0。炸弹爆炸。

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

✨ 参考代码

#include
#include

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;
}

GDPU 小试牛刀_第3张图片

你可能感兴趣的:(c++)