15级算法第三次上机解题报告

最新推荐文章于 2025-05-28 01:48:10 发布

modricwang

最新推荐文章于 2025-05-28 01:48:10 发布

阅读量1.7k

点赞数 1

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/modricwang/article/details/52972983

这篇博客包含多个算法题目的解题报告，涉及Nintendo Switch生产车间问题，数字三角形的马甲版，01背包问题，最长公共子序列，双调旅行商问题，以及猎奇省钱策略，涵盖了动态规划、图论和背包问题等多个算法领域。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

A Nintendo Switch生产车间

解题思路：

一眼看上去以为是流水线问题，其实不然，切换流水线不需要时间，因此对于每个工序，只要找到消耗时间最短的一条流水线去完成即可。使用线性查找或第k大数求最小值的时间复杂度都是线性的，因此总的时间复杂度为O(mn)，空间复杂度为O(mn).

代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int MaxN = 1023, MaxM = 1023;
long long ans;
int T, n, m;
int t[MaxM][MaxN];

int main() {
    ios::sync_with_stdio(false);
    cin >> T;
    for (int K = 1; K <= T; K++) {
        cin >> n >> m;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                cin >> t[j][i];     
                   //以工序为第一维，同一工序的数据都是相邻的，方便使用STL
        ans = 0;
        for (int i = 0; i < m; i++) {
            nth_element(t[i], t[i], t[i] + n);  //求每个工序耗时最小值
            ans += t[i][0];
        }
        cout << "Case #" << K << ": " << ans << "\n";
    }
}

B I have atree

解题思路：

非常明显就是“数字三角形”的马甲版，经典的DP题目。

遍历一遍三角形，对于每个位置，记录的是从起点到这个位置的分值的和的最大值。

边缘位置的到达路径是唯一的，只要依次累加即可得到这个位置的分值。除边缘位置外，每个数字都只能由上一行的两个固定数字走到，由上向下遍历，每次都选择两个局部和中较大的一个，遍历结束后，最后一行中最大的一个数即为答案。

时间复杂度：O(n^2)，空间复杂度：O(n^2)

代码：

#include <iostream>
#include <cstring>
using namespace std;
const int MaxN = 1023;
int n;
long long ans;
long long num[MaxN][MaxN];
#define Max(a, b) (((a)>(b))?(a):(b))
int main() {
    ios::sync_with_stdio(false);
    while (cin >> n) {
        memset(num, 0, sizeof(num));
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= i; j++)
                cin >> num[i][j];
        for (int i = 2; i <= n; i++)
            for (int j = 1; j <= i; j++)
                num[i][j] += Max(num[i - 1][j - 1], num[i - 1][j]);
                   //边界以外的数已经置0，因此边界的数不需要额外考虑
        ans = -1;
        for (int i = 1; i <= n; i++) ans = Max(ans, num[n][i]);
        cout << ans << "\n";
    }
}

C Magry的朋友很多 - 零食篇

解题思路：

加了马甲的01背包问题。把好吃程度小于等于0的物品先去掉，剩下的物品中，价格视为weight，好吃程度视为value，手中钱数视为容量，就是一个标准的01背包模型了。

时间复杂度：O(nk)，空间复杂度：O(k)

代码：

#include <iostream>
#include <cstring>

using namespace std;

typedef long long ll;
#define Max(a, b) (((a)>(b))?(a):(b))
const int MAX_W = 100000 + 7;
const int MAX_N = 10000 + 7;
ll dp[MAX_W], w[MAX_N], v[MAX_N];
ll n, W, cnt, x, _w, t;

//01背包模型
void solve() {
    memset(dp, 0, sizeof(dp));
    for (ll i = 0; i < n; i++)
        for (ll j = W; j >= w[i]; j--)
            dp[j] = Max(dp[j], dp[j - w[i]] + v[i]);
}

int main() {
    ios::sync_with_stdio(false);
    while (cin >> n) {
        cnt = 0;
        for (int i = 0; i < n; i++) {
            cin >> x >> _w >> t;
            //太难吃的直接不看了
            if (t > 0) {
                w[cnt] = x;
                v[cnt] = _w;
                cnt++;
            }
        }
        n = cnt;
        cin >> W;
        solve();
        cout << dp[W] << "\n";
    }
}

D LongestCommon Subsequence

解题思路：

如果是求最公共长子序列的长度，或是求一个最长公共子序列，做法非常简单，用dp[i][j]表示匹配到a[i]和b[j]时最长子序列的长度，有:

dp[i][j] = Max(dp[i - 1][j],

dp[i][j -1],

dp[i-1][j-1]|a[j]==b[j]);

DP过程完成后，dp[len1][len2]即为最长公共子序列的长度。

要求出所有最长公共子序列，可以对得到的dp数组进行溯源，反向找到由dp[0][0]通向dp[len1][len2]的路径，过程中每个值发生变化的点就是子序列的一个元素。事实上，在最坏情况下，每个结点都会引出两条路径，复杂度非常高，为O（2^n）。例如，对于数据：

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

除了边界之外，回溯过程中每个点都会引出两条路径。我使用了几种在OJ能通过的代码，在Intel Core i7 6700K@4.4GHz+双通道DDR4 2800MHz的平台进行测试，均未能在1min内给出结果。多谢助教高抬贵手，数据方面没有太为难我们。

在宫洁卿的论文《利用矩阵搜索求所有最长公共子序列的算法》（链接为CNKI地址）中，提出了一个（能将传统算法的指数级复杂度降低到max{O(mn),O(ck)},k为最大公共子序列的个数）的算法，使用了双栈来存储部分匹配的串的内容，但是实现较为复杂，不适合在分秒必争的上机环境内使用。

时间复杂度：O(2^n)，空间复杂度：O(len1*len2)

代码：

#include <iostream>
#include <cstring>
#include <set>
#include <algorithm>

using namespace std;

const int MaxN = 100 + 7;
int len1, len2, len;
int dp[MaxN][MaxN];
set<string> ans;
char s1[MaxN] = " ", s2[MaxN] = " ";

#define Max(a,b) (((a)>(b))?(a):(b))
//DP求LCS长度
void LCS(char A[],char B[]) {
    memset(dp, 0, sizeof(dp));
    len1 = (int)strlen(A), len2 = (int)strlen(B);
    for (int i = 1; i <= len1; i++)
        for (int j = 1; j <= len2; j++) {
            dp[i][j] = Max(dp[i - 1][j],dp[i][j - 1]);
            if (A[i] == B[j]) dp[i][j] = Max(dp[i][j],dp[i - 1][j - 1] + 1);
        }
    len = dp[len1][len2];
}
//类似DFS求出所有串
void go(int i, int j, string s) {
    if (i <= 0 || j <= 0) return;
    if (s1[i] == s2[j]) {
        s.push_back(s1[i]);
        if (s.length() == len) reverse(s.begin(), s.end()), ans.insert(s);
        else go(i - 1, j - 1, s);
    } else {
        if (dp[i - 1][j] >= dp[i][j - 1]) go(i - 1, j, s);
        if (dp[i][j - 1] >= dp[i - 1][j]) go(i, j - 1, s);
    }
}

int main() {
    while (cin >> s1 + 1 >> s2 + 1) {
        LCS(s1, s2);
        ans.clear();
        go(len1, len2, "");
        for (auto s:ans)
            cout<<s<<"\n";
    }
}

E 身可死，武士之名不可弃

解题思路：

此题的原型为双调旅行商问题。

单调地从左到右一次，再从右到左一次形成一条回路，可以看作是单调地从最左点向右引出两条路线，最后在最右边的点汇合。

由于三角形两边长之和一定大于第三边，如果两条路线有重合，或者有交叉，这样形成的回路一定不是最短的。因此，两条路线除了源点和汇点外，应该是严格不重合不交叉的。

先对所有点进行从左到右的排序，定义dist[i][j]为点i到点j的几何距离，定义dp[i][j]为第一条路线走到i点，第二条路线走到j点的总路程长度，由于两条路线是相互独立的，因此可以假设一条路线总是领先另一条。此处设j<=i.

状态转移方程为：

dp[i][j] = dp[i - 1][j] + dist[i -1][i] | j < i – 1

Min(dp[i - 1][u] + dist[u][i]), 0<=u<i– 1 | j==i – 1

Min(dp[i - 1][u] + dist[u][i]+dist[i-1][i]), 0<=u<i– 1 | j==i

后两种转移方式最多只会触发2*n次，因此总的时间复杂度：O(n^2)，空间复杂度：O(n^2)

代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <iomanip>

using namespace std;

#define x first
#define y second
#define sqr(a) ((a)*(a))
#define Min(a, b) (((a)<(b))?(a):(b))
typedef long long ll;
typedef pair<ll, ll> pll;   //存点

const int MaxN = 107;
int n;
pll p[MaxN];
double dist[MaxN][MaxN];
double dp[MaxN][MaxN];

//两点间距离
inline double Dist(pll &a, pll &b) {
    return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    while (cin >> n) {
        //读入，并按照x为第一关键字排序
        for (int i = 0; i < n; i++)
            cin >> p[i].x >> p[i].y;
        sort(p, p + n);
        
        //预处理出所有距离
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                dist[i][j] = Dist(p[i], p[j]);
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 0;
        dp[1][0] = dist[1][0];
        
        //状态转移
        for (int i = 2; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                dp[i][j] = 1e20;
                if (j < i - 1)
                    dp[i][j] = dp[i - 1][j] + dist[i - 1][i];
                if (j == i - 1)
                    for (int u = 0; u < i - 1; u++)
                        dp[i][j] = Min(dp[i][j], dp[i - 1][u] + dist[u][i]);
                if (j == i)
                    for (int u = 0; u < i - 1; u++)
                        dp[i][j] = Min(dp[i][j], dp[i - 1][u] + dist[u][i] + dist[i - 1][i]);
            }
        }
        cout << fixed << setprecision(2) << dp[n - 1][n - 1] << "\n";
    }
}

F Magry猎奇的省钱策略

解题思路：

此题需要一定的思考量，其实也不是很难。可以把这题套到背包模型里，将价格视为value，时间+1（不是时间本身）视为weight，要求为(总时间>=总件数)的情况下，付出的价值尽量少，可以转化为，总weight>=n的情况下，总value最小，用01背包模型求解即可。

时间复杂度：O(n^2)，空间复杂度：O(n^2)

代码：

#include <iostream>

using namespace std;
#define Min(a, b)  (((a)<(b))?(a):(b))
typedef long long ll;
const ll MaxC = (ll)1e11, MaxN = 2047, INF = MaxC * MaxN;
ll n, ans, w[MaxN], v[MaxN], arr[MaxN * 2];

int main() {
    ios::sync_with_stdio(false);
    while (cin >> n) {
        //先用INF填充dp数组
        for (ll i = 1; i <= n + MaxN; i++)
            arr[i] = INF;
        arr[0] = 0LL;
        for (ll i = 0; i < n; i++)
            cin >> w[i] >> v[i], v[i]++;    //时间+1
        for (ll i = 0; i < n; i++)
            for (ll j = n + 2000; j >= v[i]; j--)
                arr[j] = Min(arr[j], arr[j - v[i]] + w[i]); //01背包模型
        ans = INF;
        for (ll i = n; i <= n + 2000; i++)
            ans = Min(ans, arr[i]);
        cout << ans << "\n";
    }
}