第七次上机实验

最新推荐文章于 2021-08-30 07:44:16 发布

super ability

最新推荐文章于 2021-08-30 07:44:16 发布

阅读量146

点赞数

本文链接：https://blog.csdn.net/weixin_51541277/article/details/118161116

版权

7-1 序列调度 (100 分)

有一个N个数的序列A：1，2，……，N。有一个后进先出容器D，容器的容量为C。如果给出一个由1到N组成的序列，那么可否由A使用容器D的插入和删除操作得到。

输入格式:

第1行，2个整数T和C，空格分隔，分别表示询问的组数和容器的容量，1≤T≤10，1≤C≤N。

第2到T+1行，每行的第1个整数N，表示序列的元素数，1≤N≤10000。接下来N个整数，表示询问的序列。

输出格式:

T行。若第i组的序列能得到，第i行输出Yes；否则，第i行输出No,1≤i≤T。

输入样例:

在这里给出一组输入。例如：

2 2
5 1 2 5 4 3
4 1 3 2 4

输出样例:

在这里给出相应的输出。例如：

No
Yes

思路：

模拟栈，当栈顶元素为我们所求的数则出栈，然后继续判断，否则进行下一个数字，一直到最后可以实现跟已知序列一样

#include<bits/stdc++.h>
using namespace std;
stack<int> s;
int a[10001];
int b, c;
int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	int num, m;
	bool flag = true;
	cin >> b >> c;
	for (m = 0; m < b; m++) {
		cin >> num;
		for (int i = 0; i < num; i++) {
			cin >> a[i];
		}
		int i = 0;
		for (int j = 1; j <= num; j++) {
			while (!s.empty() && s.top() == a[i]) {
				i++;
				s.pop();
			}
			s.push(j);
			if (s.size() > c) {
				flag = false;
				break;
			}
			while (!s.empty() && s.top() == a[i]) {
				i++;
				s.pop();
			}
		}
		while (i < num) {
			if (s.top() == a[i]) {
				i++;
				s.pop();
			}
			else {
				break;
			}
		}
		if (i == num && flag == true) {
			cout << "Yes" << endl;
		}
		else {
			cout << "No" << endl;
		}
		flag = true;
	}
}

7-2 最大最小差 (100 分)

对n 个正整数，进行如下操作：每一次删去其中两个数 a 和 b，然后加入一个新数：a*b+1，如此下去直到只剩下一个数。所有按这种操作方式最后得到的数中，最大的为max，最小的为min，计算max-min。

输入格式:

第1行：n，数列元素的个数，1<=n<=16。

第2行：n 个用空格隔开的数x，x<=10。

输出格式:

1行，所求max-min。

输入样例:

在这里给出一组输入。例如：

3
2 4 3

输出样例:

在这里给出相应的输出。例如：

思路：

这道题可以通过样例发现，max即为已知数字中最小的两个数相乘再加一，再一直这样循环，min即为最大的两个数相乘再加一，循环。这里要用long long，才能在oj上也通过

#include<bits/stdc++.h>
using namespace std;
int n;
priority_queue<long long, vector<long long>, less<long long>> large;
priority_queue<long long, vector<long long>, greater<long long>> little;
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    int t = 0;
    cin >> n;
    for (int i = 0; i < n; i++){
        cin >> t;
        large.push(t);
        little.push(t);
    }
    while (large.size() != 1){
        long long a = large.top();
        large.pop();
        long long b = large.top();
        large.pop();
        large.push(a * b + 1);
    }
    while (little.size() != 1){
        long long a = little.top();
        little.pop();
        long long b = little.top();
        little.pop();
        little.push(a * b + 1);
    }
    cout << little.top() - large.top() << endl;
    return 0;
}

7-3 二叉树最短路径长度 (100 分)

给定一棵二叉树T，每个结点赋一个权值。计算从根结点到所有结点的最短路径长度。路径长度定义为：路径上的每个顶点的权值和。

输入格式:

第1行，1个整数n，表示二叉树T的结点数，结点编号1..n，1≤n≤20000。

第2行，n个整数，空格分隔，表示T的先根序列，序列中结点用编号表示。

第3行，n个整数，空格分隔，表示T的中根序列，序列中结点用编号表示。

第4行，n个整数Wi，空格分隔，表示T中结点的权值，-10000≤Wi≤10000，1≤i≤n。

输出格式:

1行，n个整数，表示根结点到其它所有结点的最短路径长度。

输入样例:

在这里给出一组输入。例如：

输出样例:

在这里给出相应的输出。例如：

1 0 3 3

思路：

这道题难点在于如何根据先根遍历和中根遍历来建树：先序序列的每个元素代表一个根节点，这个元素在中序序列中左边的部分就是它的左子树，右边部分就是它的右子树。然后求根节点到其它所有结点的最短路径，因为是二叉树，所以最短路径都只有一条，这里用先根遍历来实现

#include<bits/stdc++.h>
using namespace std;
struct tree {
	int data;
	tree* left;
	tree* right;
};
tree* root;
int xian[20001];
int zhong[20001];
int cost[20001];
int n, p = 0;
int sum[20001];
void build(int l, int r, tree*& rt)
{
    if (l > r) {
        rt = NULL;
        return;
    }
    rt = new tree;
    rt->data = xian[p];
    int m;
    for (m = l; m <= r; ++m)
        if (zhong[m] == xian[p])
            break;
    ++p;
    build(l, m - 1, rt->left);
    build(m + 1, r, rt->right);
}
void dfs(tree* t, int num) {
    if (t == NULL) {
        return;
    }
    else {
        sum[t->data-1] = num + cost[t->data-1];
        num = sum[t->data-1];
        dfs(t->left, num);
        dfs(t->right, num);
    }
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> n;
    int i;
    for (i = 0; i < n; i++) {
        cin >> xian[i];
    }
    for (i = 0; i < n; i++) {
        cin >> zhong[i];
    }
    for (i = 0; i < n; i++) {
        cin >> cost[i];
    }
    build(0, n -1, root);
    dfs(root, 0);
    for (i = 0; i < n-1; i++) {
        cout << sum[i] << " ";
    }
    cout << sum[n-1] << endl;
}

7-4 方案计数 (100 分)

组装一个产品需要 n 个零件。生产每个零件都需花费一定的时间。零件的生产可以并行进行。有些零件的生产有先后关系，只有一个零件的之前的所有零件都生产完毕，才能开始生产这个零件。如何合理安排工序，才能在最少的时间内完成所有零件的生产。在保证最少时间情况下，关键方案有多少种，关键方案是指从生产开始时间到结束时间的一个零件生产序列，序列中相邻两个零件的关系属于事先给出的零件间先后关系的集合，序列中的每一个零件的生产都不能延期。

输入格式:

第1行，2个整数n和m，用空格分隔，分别表示零件数和关系数，零件编号1..n，1≤n≤10000, 0≤m≤100000 。

第2行，n个整数Ti，用空格分隔，表示零件i的生产时间，1≤i≤n，1≤Ti≤100 。

第3到m+2行，每行两个整数i和j，用空格分隔，表示零件i要在零件j之前生产。

输出格式:

第1行，1个整数，完成生产的最少时间。

第2行，1个整数，关键方案数，最多100位。

如果生产不能完成，只输出1行，包含1个整数0.

输入样例:

在这里给出一组输入。例如：

输出样例:

在这里给出相应的输出。例如：

4
2

思路：

这道题就是求关键路径上各点的权值和并输出关键路径的条数，确定关键活动，利用乘法求出关键方案总数，题目中提示最终的关键路径的条数不多于100位，所以要用高精度计算

#include<bits/stdc++.h>
using namespace std;
int e[10010], f[10010], num1, num[110];
void gao(int x) {
    int i;
    for (i = 1; i <= num[0]; i++)
        num[i] *= x;
    for (i = 1; i <= num[0]; i++) {
        num[i + 1] += num[i] / 10;
        num[i] %= 10;
    }
    while (num[num[0] + 1] > 0) {
        num[0]++;
        num[num[0] + 1] = num[num[0]] / 10;
        num[num[0]] %= 10;
    }
}
vector<vector<int> > a, b;
vector<int> c, d;
queue<int> q, fq;
vector<int> len;
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    num[0] = 1;
    num[1] = 1;
    int final = 0;
    int n, m;
    cin >> n >> m;
    a = vector<vector<int> >(n + 1); 
    b = vector<vector<int> >(n + 1);
    c = vector<int>(n + 1);
    d = vector<int>(n + 1);
    len = vector<int>(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> len[i];
    }
    for (int i = 1; i <= m; i++) {
        int x, y;
        cin >> x >> y;
        a[y].push_back(x); 
        b[x].push_back(y); 
        c[x]++; 
        d[y]++;
    }
    for (int i = 1; i <= n; i++)
        if (!c[i]) {
            q.push(i);
            f[i] = len[i];
        }
    while (!q.empty()) {
        int num2 = q.front();
        q.pop();
        num1++;
        for (int i = 0; i < a[num2].size(); i++) {
            int nex = a[num2][i];
            f[nex] = max(f[nex], f[num2] + len[nex]);
            c[nex]--;
            if (c[nex] == 0)
                q.push(nex);
        }
    }
    for (int i = 1; i <= n; i++) {
        final = max(final, f[i]);
    }
    int flag = -1, mul = 0;
    for (int i = 1; i <= n; i++) {
        if (!d[i]) {
            fq.push(i);
            e[i] = len[i];
        }
    }
    while (!fq.empty()) {
        int num2 = fq.front();
        if (num2 == flag) {
            gao(mul);
            mul = 0;
            flag = -1;
        }
        mul++;
        fq.pop();
        for (int i = 0; i < b[num2].size(); i++) {
            int nex = b[num2][i];
            e[nex] = max(e[nex], e[num2] + len[nex]);
            d[nex]--;
            if (d[nex] == 0 && f[nex] + e[nex] - len[nex] == final)
                fq.push(nex);
            if (flag == -1)
                flag = nex;
        }
    }
    if (m == 0) {
        num[1]--;
        for (int i = 1; i <= n; i++) {
            if (f[i] + e[i] - len[i] == final)
                num[1]++;
        }
    }
    if (num1 == n) {
        cout << final << endl;
        for (int i = num[0]; i >= 1; i--)
            cout << num[i];
    }
    else {
        cout << "0";
    }
}