第十一周
本周题目主要涉及到动态规划和最短路的问题
第一题
题目1
有很多不同等级的星球和一些航线从低等级星球飞到高等级星球。航线需要支付（或获得）金钱。问从最低等级到最高等级星球最少支付（或最多获得）多少钱。（详情参考链接）
思路1
这道题中航线只从低等级飞到高等级，所以到达高等级花费的钱只依赖于到达前面等级花的钱，可以使用动态规划。
状态转移方程：f(i, j) = min{f(i - 1, b) + a}（状态为到达等级i的第j个星球花费，b是到达这个星球的起点星球，a是航线花费）
此外还能使用最短路的方法来求解。
代码1
#include<iostream>
#include<cstring>
using namespace std;
//记录每一个子问题答案
int ans[101][101];
int main()
{
memset(ans, 0x3f, sizeof(ans));
//起始条件，前往第0级的星球花费都是0
memset(ans, 0, sizeof(ans) / 101);
int n, k, a, b;
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> k;
for (int j = 1; j <= k; j++)
{
//输入航线
cin >> a;
while (a != 0)
{
cin >> b;
//状态转移方程
ans[i][j] = min(ans[i][j], ans[i - 1][a] + b);
cin >> a;
}
}
}
//答案为ans[n]中所有数最小的一个
//初始化最小值为无穷大
int minw = 0x3f3f3f3f;
for (int i = 1; i <= k; i++)
{
minw = min(minw, ans[n][i]);
}
cout << minw << endl;
return 0;
}
第二题
题目2
分多次跑n圈，每次跑的圈数比上次多，问方案数。
思路2
跑第i圈时的方案数依赖于跑前几圈的方案数，依然是动态规划问题。
状态：跑的圈数i，最后一次跑的圈数j
状态转移方程：f(i, j) = sum{f(i - j, k)} (i - k > 0 && k < j)
代码2
#include<iostream>
using namespace std;
int n;
//存放答案
//long long 防止超出int
long long ans[501][501];
//最终答案
long long lans = 0;
int main()
{
cin >> n;
//初始条件，跑i圈，最后一次跑i圈，只有一个方案
for (int i = 1; i <= n; i++)
{
ans[i][i] = 1;
}
//状态转移方程
//外层循环为圈数
for (int i = 2; i <= n; i++)
{
//中层循环为最后一次跑的次数
for (int j = 1; j < i; j++)
{
//内层循环为上次跑的次数
for (int k = 1; k < j; k++)
{
ans[i][j] += ans[i - j][k];
}
}
}
//答案时ans[n]所有数都加起来
for (int i = 1; i < n; i++)
{
lans += ans[n][i];
}
cout << lans << endl;
return 0;
}
第三题
题目3
有多个砝码，问能称出多少种重量（可以两端放砝码）
思路3
前i个砝码能称出的重量取决于前i - 1个砝码能称出的重量，所以又是动态规划题。
动态转移方程f(i, j) = f(i, abs(j - w)) = f(i, j + w) = f(i - 1, j)（前i个砝码，能否称出j重量，w为第i个砝码的重）
代码3
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
//前(i + 1)个砝码，能否称出j重量
bool weight[105][100005];
//砝码重
int weights[105];
int n;
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> weights[i];
}
//起始条件，一个砝码可以称weights[0]的重量
weight[0][weights[0]] = true;
for (int i = 1; i < n; i++)
{
//只有第i个砝码
weight[i][weights[i]] = true;
for (int j = 1; j < 100005; j++)
{
//状态转移方程
if (weight[i - 1][j])
{
weight[i][j] = true;
weight[i][j + weights[i]] = true;
weight[i][abs(j - weights[i])] = true;
}
}
}
int ans = 0;
//计数
for (int i = 1; i < 100005; i++)
{
if (weight[n - 1][i])
{
ans++;
}
}
cout << ans << endl;
return 0;
}
第四题
题目4
有很多点，问这些点组成的最大的正方形的面积。
思路4
这道题是枚举。但如果枚举4个点，时间复杂度O(n4)，肯定不能完成任务。如果枚举3个点，推算剩下一个点的坐标，就是O(n3)，也不能完成任务。
枚举两个点，剩下两个点的位置只有两种情况，再分情况推算剩下的点的坐标，如果推算出的坐标上是有点的，就说明可行。这样O(n^2)就能完成任务了。
代码4
#include<iostream>
using namespace std;
//n、坐标x、坐标y、答案
int n, cx[3001], cy[3001], ans = 0;
//存放哪些坐标有点
bool map[5001][5001];
int main()
{
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> cx[i] >> cy[i];
map[cx[i]][cy[i]] = true;
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
//避免重复选点
if (i == j)
{
continue;
}
//(x1, y1)第一种情况的第一个坐标
//(x2, y2)第一种情况的第二个坐标
//(x3, y3)第二种情况的第一个坐标
//(x4, y4)第二种情况的第二个坐标
int x1, x2, y1, y2, x3, x4, y3, y4;
//数学方法推算
x1 = (cy[j] - cy[i]) + cx[i];
x2 = (cy[j] - cy[i]) + cx[j];
y1 = (cx[i] - cx[j]) + cy[i];
y2 = (cx[i] - cx[j]) + cy[j];
x3 = (-cy[j] + cy[i]) + cx[i];
x4 = (-cy[j] + cy[i]) + cx[j];
y3 = (-cx[i] + cx[j]) + cy[i];
y4 = (-cx[i] + cx[j]) + cy[j];
//保证坐标在范围内，并且坐标上有点
//第一种情况
if (x1 >= 0 && x1 <= 5000 && x2 >= 0 && x2 <= 5000 && y1 >= 0 && y1 <= 5000 && y2 >= 0 && y2 <= 5000 && map[x1][y1] && map[x2][y2])
{
ans = max(ans, (cy[j] - cy[i]) * (cy[j] - cy[i]) + (cx[i] - cx[j]) * (cx[i] - cx[j]));
}
//第二种情况
else if (x3 >= 0 && x3 <= 5000 && x4 >= 0 && x4 <= 5000 && y3 >= 0 && y3 <= 5000 && y4 >= 0 && y4 <= 5000 && map[x3][y3] && map[x4][y4])
{
ans = max(ans, (cy[j] - cy[i]) * (cy[j] - cy[i]) + (cx[i] - cx[j]) * (cx[i] - cx[j]));
}
}
}
cout << ans << endl;
return 0;
}
第五题
题目5
有n个城市，每两个城市之间都有路。用指标P衡量出行环境，
P
=
∑
i
=
0
n
−
1
∑
j
=
0
n
−
1
d
(
i
,
j
)
P=\sum \limits_{i = 0}^{n - 1} \sum \limits_{j = 0}^{n -1 } d(i, j)
P=i=0∑n−1j=0∑n−1d(i,j)
d(i, j) 表示城市 ii 到城市 jj 之间灰尘度最小的路线对应的灰尘度的值。
接着每天对一个城市进行道路改善，与这个城市直接相连的所有道路的灰尘度都减少1，但有一个下限值。
给出一个指标Q，问什么时候P能小于Q
思路5
这是一个求解最短路径的问题。由于需要知道所有点之间的最短距离，并且题目给出的数据范围较小，选择Floyd算法。
根据时间推进，每天计算一次最短路，就能找到答案。
然后就TLE了…
可以看到，P随着天数t的增加而单调减小，所以可以通过二分答案的方法，来减少Floyd算法的频率，这样就不容易超时了。
代码5
#include<iostream>
#include<cstring>
using namespace std;
//n、Q、原始的灰尘度、最低灰尘度、当前的指标p、答案、临时存放Floyd答案的数组
int n, q, dis[101][101], l[101][101], p, ans = -1, tempdis[101][101];
//Floyd算法
void floyd()
{
for (int k = 1; k <= n; k++)
{
for (int i = 1; i <= n; i++)
{
for (int j =1; j <= n; j++)
{
tempdis[i][j] = min(tempdis[i][j], tempdis[i][k] + tempdis[k][j]);
}
}
}
}
//求解指标P的值
int getp()
{
int sum = 0;
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
sum += tempdis[i][j];
}
}
return sum;
}
//设置当前的天数（把当前天数已经改善的道路都更新一遍）
void setd(int d)
{
//将原始灰尘度复制到临时数组
memcpy(tempdis, dis, sizeof(dis));
//更新灰尘度
for (int i = 1; i <= d; i++)
{
for (int j = 1; j <= n; j++)
{
tempdis[j][i] = max(l[j][i], tempdis[j][i] - 1);
tempdis[i][j] = max(l[i][j], tempdis[i][j] - 1);
}
}
}
int main()
{
cin >> n >> q;
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
cin >> dis[i][j];
}
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
cin >> l[i][j];
}
}
//二分
int l = 0, r = n;
while (l <= r)
{
int mid = (l + r ) / 2;
//设置天数
setd(mid);
//计算最短路径
floyd();
//判断p是否小于等于q
if (getp() <= q)
{
r = mid - 1;
//更新答案
ans = mid;
}
else
{
l = mid + 1;
}
}
//没有答案时是默认-1，有答案就是最新的（也就是最小的）天数
cout << ans << endl;
return 0;
}
709
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
