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

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