当前位置：首页 > news >正文

week11

news 来源：原创 2024/11/17 0:02:34

T1汤姆斯的天堂梦

题目描述

汤姆斯生活在一个等级为 $0$ 的星球上。那里的环境极其恶劣，每天 $12$ 小时的工作和成堆的垃圾让人忍无可忍。他向往着等级为 $N$ 的星球上天堂般的生活。

有一些航班将人从低等级的星球送上高一级的星球，有时需要向驾驶员支付一定金额的费用，有时却又可以得到一定的金钱。

汤姆斯预先知道了从 $0$ 等级星球去 $N$ 等级星球所有的航线和需要支付（或者可以得到）的金钱，他想寻找一条价格最低（甚至获得金钱最多）的航线。

输入格式

第一行一个正整数 $N$ （ $\le 100$ ），接下来的数据可分为 $N$ 个段落，每段的第一行一个整数 $K_i$ （ $K_i \le 100$ ），表示等级为 $i$ 的星球有 $K_i$ 个。

接下来的 $K_i$ 行中第 $j$ 行依次表示与等级为 $i$ ，编号为 $j$ 的星球相连的等级为 $i - 1$ 的星球的编号和此航线需要的费用（正数表示支出，负数表示收益，费用的绝对值不超过 $1000$ ）。

每行以 $0$ 结束，每行的航线数 $\le 100$ 。

输出格式

输出所需（或所得）费用。正数表示支出，负数表示收益。

样例 #1

样例输入 #1

3
2
1 15 0
1 5 0
3
1 -5 2 10 0
1 3 0
2 40 0
2
1 1 2 5 3 -5 0
2 -19 3 -20 0

样例输出 #1

-1

提示

对于 $\%$ 的数据， $\le N \le 100$ ， $\le K_i \le 100$ 。

样例解释：

思路：从起点能够到达的所有点，将其中路径最短的点记录，然后尝试从新的点能够到达的所有点，再次把已尝试过所有路径中路径最短的点记录，一直重复即可

代码：

#include<bits/stdc++.h>
using namespace std;
int f[1005][1005] = {};
int main()
{
	int n, k;
	cin >> n;
	for (int i = 1;i <= n;++i)
	{
		cin >> k;
		for (int j = 1;j <= k;++j)
		{
			f[i][j] = 999998;
			int x, y;
			cin >> x;
			while (x != 0)
			{
				cin >> y;
				f[i][j] = f[i - 1][x] + y < f[i][j] ? f[i - 1][x] + y : f[i][j];
				cin >> x;
			}
		}
	}
	int Min = 999999;
	for (int i = 1;i <= k;++i)
	{
		Min = min(f[n][i], Min);
	}
	cout << Min;
	return 0;
}

T2跑步

题目描述

路人甲准备跑 $n$ 圈来锻炼自己的身体，他准备分多次（ $\gt1$ ）跑完，每次都跑正整数圈，然后休息下再继续跑。

为了有效地提高自己的体能，他决定每次跑的圈数都必须比上次跑的多。

可以假设他刚开始跑了 $0$ 圈，那么请问他可以有多少种跑完这 $n$ 圈的方案？

输入格式

一行一个整数，代表 $n$ 。

输出格式

一个整数表示跑完这 $n$ 圈的方案数。

样例 #1

样例输入 #1

样例输出 #1

995645335

提示

数据规模与约定

对于 $100\%$ 的数据，保证 $5\le n\le 500$ 。

思路：使用动态规划解决，相当于解决01背包问题

代码：

#include <bits/stdc++.h>
using namespace std;
long long res[1005] = {}, n;
int main()
{
	cin >> n;
	res[0] = 1;
	for (int i = 1; i <= n; i++)     
	{
		for (int j = n; j >= i; j--)    
		{
			res[j] += res[j - i];
		}
	}
	cout << res[n] - 1;
	return 0;
}

T3[蓝桥杯 2021 省 AB] 砝码称重

题目描述

你有一架天平和 $N$ 个砝码, 这 $N$ 个砝码重量依次是 $W_{1}, W_{2}, \cdots, W_{N}$ 。请你计算一共可以称出多少种不同的重量?

注意砝码可以放在天平两边。

输入格式

输入的第一行包含一个整数 $N$ 。

第二行包含 $N$ 个整数: $W_{1}, W_{2}, W_{3}, \cdots, W_{N}$ 。

输出格式

输出一个整数代表答案。

样例 #1

样例输入 #1

3
1 4 6

样例输出 #1

提示

【样例说明】

能称出的 10 种重量是: $1 、 2 、 3 、 4 、 5 、 6 、 7 、 9 、 10 、 11$ 。

$\begin{aligned} &1=1 \\ &2=6-4(\text { 天平一边放 } 6, \text { 另一边放 4) } \\ &3=4-1 \\ &4=4 \\ &5=6-1 \\ &6=6 \\ &7=1+6 \\ &9=4+6-1 \\ &10=4+6 \\ &11=1+4+6 \end{aligned}$

思路：动态规划问题，有3种情况
1、通过前i-1个砝码称出j和第i个砝码重量是j可以称出d[i][j]
2、通过前i-1个砝码称出来了j-a[i]的重量从而能称出故d[i][j]
3、通过前i-1个砝码称出来了j+a[i]的重量，j+a[i]=j+a[i]，故能称出d[i][j]

代码：

#include<bits/stdc++.h>
using namespace std;
int dp[1005][100005] = {};
int n, arr[1005] = {}, sum = 0, ans = 0;
int main()
{
	cin >> n;
	for (int i = 1;i <= n;i++)
	{
		cin >> arr[i];
		sum += arr[i];
	}
	for (int i = 1;i <= n;i++)
	{
		for (int j = sum;j > 0;j--)
		{
			dp[i][j] = dp[i - 1][j];
			if (!dp[i][j])
			{
				if (j == arr[i]|| dp[i - 1][abs(j - arr[i])]|| dp[i - 1][j + arr[i]])
					dp[i][j] = 1;
			}
		}
	}
	for (int i = 1;i <= sum;i++) 
	{
		if (dp[n][i])
			ans++;
	}
	cout << ans;
	return 0;
}

T4遗址

题目描述

很久很久以前有一座寺庙，从上往下看寺庙的形状正好是一个正方形，由 $4$ 个角上竖立的圆柱搭建而成。现在圆柱都倒塌了，只在地上留下圆形的痕迹，可是现在地上有很多这样的痕迹，专家说一定是最大的那个。

写一个程序，给出圆柱的坐标，找出由 $4$ 个圆柱构成的最大的正方形，因为这就是寺庙的位置，要求计算出最大的面积。注意正方形的边不一定平行于坐标轴。

例如图有 $10$ 根柱子，其中 $(4, 2), (5, 2), (5, 3), (4, 3)$ 可以形成一个正方形， $(1, 1), (4, 0), (5, 3), (2, 4)$ 也可以，后者是其中最大的，面积为 $10$ 。

输入格式

第一行包含一个 $N(1\leq N\leq 3000)$ ，表示柱子的数量。

接下来 $N$ 行，每行有两个空格隔开的整数表示柱子的坐标（坐标值在 $0$ 到 $5000$ 之间），柱子的位置互不相同。

输出格式

如果存在正方形，输出最大的面积，否则输出 $0$ 。

样例 #1

样例输入 #1

样例输出 #1

提示

【数据范围】

$30\%$ 满足： $1\leq N \leq100$ 。

$60\%$ 满足： $1\leq N \leq500$ 。

$100\%$ 满足： $1\leq N \leq3000$ 。

思路：可以把正方形分割成4个直角三角形(全等)和一个小的正方形，先定两个起始点，让其他两个点分别用这两个点表示，然后通过这种方法求面积最大值

代码：

#include <bits/stdc++.h>
using namespace std;
bool res[10005][10005] = { false };
int n, ans = 0;
pair<int, int> arr[10005] = {};

bool Pan_duan(int a, int b)
{
	if (a > 5000 || a < 1 || b>5000 || b < 1)
		return false;
	return true;
}

int main()
{
	cin >> n;
	for (int i = 1;i <= n;i++)
	{
		cin >> arr[i].first >> arr[i].second;
		res[arr[i].first][arr[i].second] = true;
	}
	sort(arr + 1, arr + 1 + n);
	for (int i = 1;i <= n - 1;i++)
		for (int j = i + 1;j <= n;j++)
		{
			int a1 = arr[j].first - arr[i].first;
			int a2 = arr[j].second - arr[i].second;
			int a3 = arr[i].second + a1;
			int a4 = arr[j].second + a1;
			int b1 = arr[i].first - a2;
			int b2 = arr[j].first - a2;
			if (Pan_duan(b1, a3) && Pan_duan(b2, a4) && res[b1][a3] && res[b2][a4])
				ans = max(ans, (arr[j].first - arr[i].first) * (arr[j].first - arr[i].first) + (arr[j].second - arr[i].second) * (arr[j].second - arr[i].second));
		}
	cout << ans;
	return 0;
}

T5[蓝桥杯 2022 国 A] 环境治理

题目描述

LQ 国拥有 $n$ 个城市，从 $0$ 到 $n - 1$ 编号，这 $n$ 个城市两两之间都有且仅有一条双向道路连接，这意味着任意两个城市之间都是可达的。每条道路都有一个属性 $D$ ，表示这条道路的灰尘度。当从一个城市 A 前往另一个城市 B 时，可能存在多条路线，每条路线的灰尘度定义为这条路线所经过的所有道路的灰尘度之和，LQ 国的人都很讨厌灰尘，所以他们总会优先选择灰尘度最小的路线。

LQ 国很看重居民的出行环境，他们用一个指标 $P$ 来衡量 LQ 国的出行环境， $P$ 定义为：

$P=\sum \limits_{i=0}^{n-1} \sum \limits_{j=0}^{n-1} d(i,j)$

其中 $d (i, j)$ 表示城市 $i$ 到城市 $j$ 之间灰尘度最小的路线对应的灰尘度的值。

为了改善出行环境，每个城市都要有所作为，当某个城市进行道路改善时，会将与这个城市直接相连的所有道路的灰尘度都减少 $1$ ，但每条道路都有一个灰尘度的下限值 $L$ ，当灰尘度达到道路的下限值时，无论再怎么改善，道路的灰尘度也不会再减小了。

具体的计划是这样的：

第 $1$ 天， $0$ 号城市对与其直接相连的道路环境进行改善；
第 $2$ 天， $1$ 号城市对与其直接相连的道路环境进行改善；

……

第 $n$ 天， $n - 1$ 号城市对与其直接相连的道路环境进行改善；
第 $n + 1$ 天， $0$ 号城市对与其直接相连的道路环境进行改善；
第 $n + 2$ 天， $1$ 号城市对与其直接相连的道路环境进行改善；

……

LQ 国想要使得 $P$ 指标满足 $\leq Q$ 。请问最少要经过多少天之后， $P$ 指标可以满足 $\leq Q$ 。如果在初始时就已经满足条件，则输出 $0$ ；如果永远不可能满足，则输出 $- 1$ 。

输入格式

输入的第一行包含两个整数 $n, Q$ ，用一个空格分隔，分别表示城市个数和期望达到的 $P$ 指标。

接下来 $n$ 行，每行包含 $n$ 个整数，相邻两个整数之间用一个空格分隔，其中第 $i$ 行第 $j$ 列的值 $D_{i,j} (D_{i,j}=D_{j,i},D_{i,i} = 0)$ 表示城市 $i$ 与城市 $j$ 之间直接相连的那条道路的灰尘度。

接下来 $n$ 行，每行包含 $n$ 个整数，相邻两个整数之间用一个空格分隔，其中第 $i$ 行第 $j$ 列的值 $L_{i,j} (L_{i,j} = L_{j,i}, L_{i,i} = 0)$ 表示城市 $i$ 与城市 $j$ 之间直接相连的那条道路的灰尘度的下限值。

输出格式

输出一行包含一个整数表示答案。

样例 #1

样例输入 #1

样例输出 #1

提示

【样例说明】

初始时的图如下所示，每条边上的数字表示这条道路的灰尘度：

此时每对顶点之间的灰尘度最小的路线对应的灰尘度为：

$d (0, 0) = 0, d (0, 1) = 2, d (0, 2) = 3$ ；
$d (1, 0) = 2, d (1, 1) = 0, d (1, 2) = 1$ ；
$d (2, 0) = 3, d (2, 1) = 1, d (2, 2) = 0$ 。

初始时的 $P$ 指标为 $\times 2 = 12$ ，不满足 $\leq Q = 10$ ;

第一天， $0$ 号城市进行道路改善，改善后的图示如下：

注意到边 $(0, 2)$ 的值减小了 $1$ ，但 $(0, 1)$ 并没有减小，因为 $L_{0,1} = 2$ ，所以 $(0, 1)$ 的值不可以再减小了。此时每对顶点之间的灰尘度最小的路线对应的灰尘度为：

$d (0, 0) = 0, d (0, 1) = 2, d (0, 2) = 3$ ，
$d (1, 0) = 2, d (1, 1) = 0, d (1, 2) = 1$ ，
$d (2, 0) = 3, d (2, 1) = 1, d (2, 2) = 0$ 。

此时 $P$ 仍为 $12$ 。

第二天，1 号城市进行道路改善，改善后的图示如下：

此时每对顶点之间的灰尘度最小的路线对应的灰尘度为：

$d (0, 0) = 0, d (0, 1) = 2, d (0, 2) = 2$ ，
$d (1, 0) = 2, d (1, 1) = 0, d (1, 2) = 0$ ，
$d (2, 0) = 2, d (2, 1) = 0, d (2, 2) = 0$ 。

此时的 $P$ 指标为 $\times 2 = 8 < Q$ ，此时已经满足条件。

所以答案是 $2$ 。

思路：本题用floyd算法来求最短路径，用二分查找来求答案

代码：

#include <bits/stdc++.h>
using namespace std;
long long f[1005][1005] = {}, f_min[1005][1005] = {}, fd[1005] = {}, fe[1005][1005] = {}, n, m;
bool check(long long k)
{
    long long v = 0;
	long long num = k / n;
	k -= (n * num);
	for (int i = 0;i < n;i = i + 1)
	{
		if (k - 1 >= i)
			fd[i] = num + 1;
		else
			fd[i] = num;
	}
	for (int k = 0;k <= n - 1;k = k + 1)      //floyd算法
	{
		for (int i = 0;i <= n - 1;i = i + 1)
		{
			for (int j = 0;j <= n - 1;j = j + 1)
			{
				fe[i][j] = min(max(f[i][j] - fd[i] - fd[j], f_min[i][j]), max(f[i][k] - fd[i] - fd[k], f_min[i][k]) + max(f[k][j] - fd[k] - fd[j], f_min[k][j]));
			}
		}
	}
	for (int i = 0;i <= n - 1;i = i + 1)
	{
		for (int j = 0;j <= n - 1;j = j + 1)
		{
			v = v + fe[i][j];
		}
	}
	if (v <= m)
		return true;
	else
		return false;
}

int main()
{
	cin >> n >> m;
	for (int i = 0;i <= n - 1;i = i + 1)
	{
		for (int j = 0;j < n;j = j + 1)
			cin >> f[i][j];
	}
	for (int i = 0;i <= n - 1;i = i + 1)
	{
		for (int j = 0;j < n;j = j + 1)
			cin >> f_min[i][j];
	}
	long long L = 0, R = 1e14;        //二分查找
	long long ans = R;
	while (L <= R)
	{
		long long mid = (L + R) / 2;
		if (check(mid))
		{
			R = mid - 1;
			ans = min(ans, mid);
		}
		else
			L = mid + 1;
	}
	if (L >= 1e14)
		cout << "-1" << endl;
	else
		cout << ans << endl;
	return 0;
}