第六次上机实验解题报告

最新推荐文章于 2023-01-27 08:13:21 发布
最新推荐文章于 2023-01-27 08:13:21 发布
阅读量180 收藏
点赞数 1
分类专栏： 算法导论 数据结构 C++语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ggn_2015/article/details/116992657
版权

前言

欢迎讨论，欢迎纠错，本次报告，证明从简。

7 - 1 高精度加法

解题思路

简而言之，使用数组模拟列竖式的过程，例如我们可以用 A [ i ] A[i] A[i] 表示某个数的 1 0 i 10^i 10i 位上的值。

代码实现

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 210 + 5;

char buff[maxn];
struct bigInt {
	int mem[maxn];
	int len;
	int flag;
	void input() {
		scanf("%s", buff);
		len = strlen(buff);
		memset(mem, 0x00, sizeof(mem));
		if(buff[0] == '-') {
			flag = 1; /// < 0
			for(int i = 0; i < len-1; i ++) {
				mem[i] = buff[len - i - 1] - '0';
			}
			len --;
		}else {
			flag = 0; /// > = 0
			for(int i = 0; i < len; i ++) {
				mem[i] = buff[len - i - 1] - '0';
			}
			if(len == 1 && mem[0] == 0) {
				len --;
			}
		}
	}
	void output() {
		//if(flag) putchar('-');
		if(len == 0) {
			printf("0");
		}else {
			for(int i = len - 1 ; i >= 0; i --) {
				printf("%d", mem[i]);
			}
		}
	}
};

bigInt& operator +=(bigInt& A, bigInt& B) {
	A.len = max(A.len, B.len);
	for(int i = 0; i < A.len; i ++) {
		A.mem[i] += B.mem[i];
		A.mem[i+1] += A.mem[i] / 10;
		A.mem[i] %= 10;
	}
	if(A.mem[A.len] != 0) {
		A.len ++;
	}
	return A;
}

bool operator>=(bigInt& A, bigInt& B) {
	if(A.len != B.len) return A.len > B.len;
	for(int i = A.len-1; i >= 0; i --) {
		if(A.mem[i] != B.mem[i]) {
			return A.mem[i] > B.mem[i]; 
		} 
	}
	return true; /// same
}

bigInt operator -=(bigInt& A, bigInt& B) {
	for(int i = 0; i < B.len; i ++) {
		A.mem[i] -= B.mem[i];
		while(A.mem[i] < 0) {
			A.mem[i] += 10;
			A.mem[i + 1] --;
		}
	}
	while(A.len > 0 && A.mem[A.len - 1] == 0) {
		A.len --;
	}
	return A;
}

bigInt Ans, Bns, Tmp;
int main() {
	int n; scanf("%d", &n);
	for(int i = 0; i < n; i ++) {
		Tmp.input();
		//Tmp.output(); putchar('\n');
		if(Tmp.flag) {
			/// Tmp < 0
			Bns += Tmp;
		}else {
			Ans += Tmp; 
		}
	}
	//Ans.output(); putchar('\n');
	//Bns.output(); putchar('\n');
	if(Ans >= Bns) { /// ans not net
		Ans -= Bns;
		Ans.output();
	}else {
		putchar('-');
		Bns -= Ans;
		Bns.output(); 
	}
	return 0;
}

7 - 2 二叉树加权距离

解题思路

先通过一次 dfs 找到每个节点在二叉树中的深度，为了编程简单我们记根节点的深度为 1 1 1。

代码实现

#include <cstdio>
//#include <vector>
#include <algorithm>
using namespace std;

const int maxn = 100000 + 5;

struct vector {
	int mem[3], cnt;
	void push_back(int x) {
		mem[cnt ++] = x;
	}
	int size() {
		return cnt;
	}
	int& operator[](int index) {
		return mem[index];
	}
};

vector nxt[maxn];
void addedge(int f, int t) {
	nxt[f].push_back(t);
	nxt[t].push_back(f);
}

int fa[maxn], dep[maxn];
void dfs(int x, int f) {
	fa[x] = f;
	dep[x] = dep[f] + 1;
	for(int i = 0; i < nxt[x].size(); i ++) {
		int t = nxt[x][i];
		if(t == f) continue;
		dfs(t, x);
	}
}

int lca(int x, int y) {
	if(dep[x] < dep[y]) {
		swap(x, y); /// dep[x] >= dep[y]
	}
	while(dep[x] > dep[y]) {
		x = fa[x];
	}
	while(x != y) {
		x = fa[x];
		y = fa[y];
	}
	return x;
}

int main() {
	int n; scanf("%d", &n);
	for(int i = 1; i < n; i ++) {
		int a, b; scanf("%d%d", &a, &b);
		addedge(a, b);
	}
	dfs(1, 0);
	int u, v; scanf("%d%d", &u, &v);
	int p = lca(u, v);
	printf("%d", (dep[u] - dep[p])*3 + (dep[v] - dep[p])*2);
	return 0;
}

7 - 3 修轻轨

解题思路

利用 Kruskal 的基本思想，对所有边进行排序。按照边权从小到大枚举每一条边 ( u , v ) (u,v) (u,v)，并将这条边 u u u 与 v v v 当前所在的连通块在并查集上进行合并。当 1 1 1 号节点与 n n n 号节点第一次位于同一个连通块时，此时最后一条被考虑的边就是答案。

代码实现

#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 100000 + 6;

int fa[maxn], bcnt;

void init(int n) {
	for(int i = 1; i <= n; i ++) {
		fa[i] = i;
	}
	bcnt = n;
}

int find(int x) {
	if(x == fa[x]) return x;
	else return fa[x] = find(fa[x]);
}

struct Edge {
	int f, t, c;
} es[2*maxn];

bool cmp(Edge& A, Edge& B) {
	return A.c < B.c;
}

void link(int x, int y) {
	x = find(x);
	y = find(y);
	fa[x] = y;
}

int main() {
	int n, m; scanf("%d%d", &n, &m);
	for(int i = 1; i <= m; i ++) {
		int a, b, c; scanf("%d%d%d", &a, &b, &c);
		es[i] = (Edge) {a, b, c};
	}
	sort(es + 1, es + m + 1, cmp);
	init(n);
	int ans = 0;
	for(int i = 1; i <= m; i ++) {
		int f = es[i].f, t = es[i].t, c = es[i].c;
		if(find(f) != find(t)) {
			bcnt --;
			link(f, t);
			ans = c;
		}
		if(find(1) == find(n)) break;
	}
	printf("%d\n", ans);
	return 0;
}

7 - 4 数据结构设计

解题思路 1

维护一个单调递增的单调队列以及一个单调递减的单调队列，可以 O ( 1 ) O(1) O(1) 查询当前区间的最大值和最小值。对所有数据取反可以通过一个标记实现。稍微具体解释一下“区间”的含义，将所有 I I I 操作插入到序列中的元素按照时间先后顺序排成一个数列 A A A，不难说明，每次查询最值时，“数据结构” 中的元素一定是 A A A 数列中的某个区间。

代码实现 1

#include <cstdio>
#include <algorithm>
//#include <queue>
using namespace std;

const int maxn = 400000 + 6;

struct deque {
	int mem[maxn];
	int L, R;
	void push_back(int x) {
		mem[++ R] = x;
	}
	void pop_front() {
		if(L < R) {
			L ++;
		}
	}
	void pop_back() {
		if(L < R) {
			R --;
		}
	}
	int front() {
		return mem[L + 1];
	}
	int back() {
		return mem[R];
	}
	bool empty() {
		return L >= R; 
	}
};

deque UP, DOWN;
int flag = 0, A[maxn], acnt, bcnt;

void insert(int id) {
	while(!UP.empty() && A[UP.back()] >= A[id]) UP.pop_back();
	UP.push_back(id);
	while(!DOWN.empty() && A[DOWN.back()] <= A[id]) DOWN.pop_back();
	DOWN.push_back(id);
}

int MAX() {
	return A[DOWN.front()];
}
int MIN() {
	return A[UP.front()];
}

int main() {
	int m; scanf("%d", &m);
	int first = 1;
	for(int i = 1; i <= m; i ++) {
		char op[3]; scanf("%s", op);
		if(op[0] == 'I') {
			int x; scanf("%d", &x);
			if(flag) {
				x = -x;
			}
			A[++ acnt] = x; /// acnt 指向最后一个位置 
			insert(acnt);
		}else if(op[0] == 'D') {
			if(bcnt < acnt) {
				bcnt ++; /// 已经被删除的部分的最后一个元素 
				while(!UP.empty() && UP.front() <= bcnt) UP.pop_front();
				while(!DOWN.empty() && DOWN.front() <= bcnt) DOWN.pop_front();
			}
		}else if(op[0] == 'R') {
			flag ^= 1;
		}else {
			/// MAX
			if(bcnt < acnt) {
				 /// with number
				if(!first) putchar('\n');
			    if(flag) {
			    	printf("%d", -MIN());	
			    }else {
			    	printf("%d", MAX());
			    }
			    first = 0;
			}
		}
	}
	return 0;
}

解题思路 2

使用双端队列维护当前“数据结构”中的数据序列，用一个 map 记录 “数据结构” 中每种数值的出现次数 或者 multiset 维护 “数据结构” 中的数据集合。

代码实现 2

#include <cstdio>
#include <map>
#include <queue>
#include <cstring>
using namespace std;

int flag = 0; /// positive
map<int, int> cnt;
queue<int> q;

int main() {
	int M; scanf("%d", &M);
    int nfst = 0;
	while(M --) {
		char op[3]; scanf("%s", op);
		if(op[0] == 'I') {
			int x; scanf("%d", &x);
			if(flag) {
				x = - x;
			}
			q.push(x);
			cnt[x] ++;
		}else if(op[0] == 'D') {
			if(!q.empty()) {
				/// 删除队首 
				int x = q.front(); q.pop();
				cnt[x] --;
				if(cnt[x] == 0) {
					cnt.erase(x);
				}
			}
		}else if(op[0] == 'R') {
			flag ^= 1;
		}else if(op[0] == 'M') {
			if(!q.empty()) {
                if(nfst) {
                    putchar('\n');
                }
				if(flag) {
					/// neg
					printf("%d", -cnt.begin()->first);
				}else {
					printf("%d", cnt.rbegin()->first);
				}
                nfst = 1;
			}
		}
	}
	return 0;
}
GGN_2015
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第六次上机解题报告1
08-03
这道题改编自第 7 章 PPT 的例 7.2。旨在告诉同学们，此前我们了解到函数最多只有一个返回值，传进来的参数也只在函数内部改变，函数结束后，其值不会改变。但
PCA算法上机实验报告PCA算法上机实验报告
10-19
PCA算法上机实验报告PCA算法上机实验报告PCA算法上机实验报告PCA算法上机实验报告PCA算法上机实验报告
JLU数据结构第六次上机实验解题报告
qq_24482377的博客
06-16 816
7-1 高精度数加法 (100 分) 高精度数是指大大超出了标准数据类型能表示的范围的数，例如10000位整数。很多计算问题的结果都很大，因此，高精度数极其重要。 一般使用一个数组来存储高精度数的所有数位，数组中的每个元素存储该高精度数的1位数字或多位数字。 请尝试计算：N个高精度数的加和。这个任务对于在学习数据结构的你来说应该是小菜一碟。 。 输入格式: 第1行，1个整数N，表示高精度整数的个数，(1≤N≤10000)。 第2至N+1行，每行1个高精度整数x, x最多100位。 输出格式:
数据结构第六次上机实验解题报告
qq_51252919的博客
06-13 333
数据结构第六次上机实验解题报告 7-1 高精度数加法 (100 分) 高精度数是指大大超出了标准数据类型能表示的范围的数，例如10000位整数。很多计算问题的结果都很大，因此，高精度数极其重要。 一般使用一个数组来存储高精度数的所有数位，数组中的每个元素存储该高精度数的1位数字或多位数字。 请尝试计算：N个高精度数的加和。这个任务对于在学习数据结构的你来说应该是小菜一碟。 。 输入格式: 第1行，1个整数N，表示高精度整数的个数，(1≤N≤10000)。 第2至N+1行，每行1个高精度整数x, x最多100
第一次上机实验解题报告
总理同学的编程尝试
04-15 293
感觉这次题目整体上说还算比较友好，简单整理了一下我的解题思路，希望我不太严谨的语言能被大家理解。
数据结构第七次上机实验解题报告
qq_51252919的博客
06-21 815
数据结构第七次上机实验解题报告 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；否则
FFT详解
热门推荐
总理同学的编程尝试
03-31 9万+
一直想学FFT，当时由于数学基础太差，导致啥都学不懂。请教了机房里的几位学长大神，结果还是没太明白。因此下定决心写一篇关于“FFT”的文章，一篇起码我能看得懂的“FFT”。
（初学者）素数计算法
总理同学的编程尝试
03-29 8170
前言记得我刚开始学习OI的时候接触到的最早的算法莫过于素数算法。当然了，素数这个知识小学的时候我们就已经有所学习了。当时我一直有一个疯狂的设想，就是编写一个程序把我能算出来的素数都算出来。
平面最近点对的分治做法及其证明
总理同学的编程尝试
06-23 7070
2018.6.23 好久没写博客了，做了一道有趣的分治题，写个博客。 题目传送门： P1429 平面最近点对（加强版） 题意 题目描述 给定平面上n个点，找出其中的一对点的距离，使得在这n个点的所有点对中，该距离为所有点对中最小的 输入格式 第一行：n；2≤n≤200000 接下来n行：每行两个实数：x y (0≤x,y≤10^9)，表示一个点的行坐标和列坐标，中间用一个空格...
补充——FFT中的二进制翻转问题
总理同学的编程尝试
04-07 5936
注在我之前的FFT博客中好像并没有具体地介绍FFT中的“二进制翻转是如何实现的”，在这里我们简短的讨论一下。
线性时间复杂度排序
总理同学的编程尝试
04-05 5121
前言 我的博客之所以叫做“总理同学的暴力编程尝试…”说来话长。在我无数次的暴力编程尝试中，其中有一次就是给500万个整数进行排序，快排还有归并排序显然是卡爆了。快排一直在运转没有头，而归并排序直接就RE程序崩溃了。后来我听说了一种叫做“计数排序”的排序方式，得到了令我十分惊讶的成果，我用了4秒钟生成了500万个随机数，而给这些随机数排序却只用了3秒钟。因此怀着对“线性时间发杂度排序”的敬仰之情，
使用 TELNET 发送 SMTP 邮件详解
总理同学的编程尝试
01-27 3675
telnet 大法好...
几种常用的最短路的求法
总理同学的编程尝试
07-20 3429
我的图论学得一直不怎么样，所以今天决定写一发关于最短路的几种算法。
斐波那契数列通项公式
总理同学的编程尝试
12-27 3247
如果您没学过矩阵的特征值，建议您先自学一波。
神奇的KMP——线性时间匹配算法（初学者请进）
总理同学的编程尝试
03-27 2429
这个算法很抽象、很难理解，看了很多博客也没看懂。所以，我决心写一篇博客，一篇算法初学者也能看得懂的博客。
位运算优化数独
总理同学的编程尝试
03-31 1989
闲得无聊，写个数独玩玩，结果调试了半天。
Pollard-Rho算法证明
总理同学的编程尝试
12-12 1498
我觉得我写得挺模糊的，里面由一些没给出证明的东西，我不会证，欢迎同学们联系我。
约瑟夫问题概述
总理同学的编程尝试
12-08 1371
我在很久之前就已经接触了约瑟夫问题了，但是最近终于找到了时间效率比较优秀的解决办法，写一篇博客以纪念一下。
数据结构与算法第五版上机实验指导
最新发布
09-13
对于《数据结构与算法第五版》的上机实验指导，我很抱歉我不能提供具体的指导内容。但是，我可以给你一些关于数据结构与算法实验的一般指导，希望对你有所帮助。 1. 确定实验目标：首先，你需要明确每个实验的目标...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值