2022.9.27日调试笔记

已于 2023-09-01 10:31:55 修改
阅读量164 收藏
点赞数
文章标签： c++ 图论 算法
于 2022-09-28 13:00:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanglianda2007/article/details/127084590
版权

前言

前几天调了几个很离谱的bug，在此记录一下坑点。

1：P1016 [NOIP1999 提高组] 旅行家的预算

本来以为只是一道很简单的贪心，但是发现代码确实很不好写。

下面给出我的代码：

#include<iostream>
#include<cstdio>
using namespace std;
double a[10],b[10],c,k,oil,ans;
int n;
int main() {
	cin>>a[0]>>c>>k>>b[0]>>n;
	swap(a[0],a[n+1]);
	for(int i=1;i<=n;i++)
		cin>>a[i]>>b[i];
	for(int i=1;i<=n+1;i++)
		if(a[i]-a[i-1]>c*k) {
			cout<<"No Solution"<<endl;
			return 0;
		}
	for(int i=0,t;i<=n;i=t) {
		for(int j=i+1;a[j]-a[i]<=c*k&&j<=n+1;j++) 
			if(b[j]<b[i]) {
				ans+=b[i]*((a[j]-a[i])/k-min(oil,(a[j]-a[i])/k));
				oil-=min(oil,(a[j]-a[i]/k));
				t=j;
				goto flag;
			}
		{
		int mint=i+1;
		for(int j=i+2;a[j]-a[i]<=c*k&&j<=n+1;j++) 
			if(b[j]<=b[mint]) 
				mint=j;
		ans+=(c-oil)*b[i];
		oil=c-(a[mint]-a[i])/k;
		t=mint;
		}
		flag:;
	}
	printf("%.2lf",ans);
	return 0;
}

主要思路就是模拟+贪心，贪心策略如下：
在加满油可以抵达的范围内，如果存在油价比所处加油站更低的加油站，那么行驶到此加油站，所需加油的数量只需要刚好能够抵达此加油站即可。
如果不存在这种加油站，那么就加满油，行驶到后面能抵达范围内油价相对最低的加油站。加满油是为了到了后面那个加油站可以少加一点，省钱。

题解区也有很多不同的做法，但这些做法正确的原因都是遵循了以下原则：
无论什么时候行驶，都尽量使用最便宜的油。

代码中有几句不容易理解：

对于第一种情况：

ans+=b[i]*((a[j]-a[i])/k-min(oil,(a[j]-a[i])/k));
oil-=min(oil,(a[j]-a[i]/k));

如果存在油价比所处加油站更低的加油站，那么应该尽量少加油，只需要能够行驶到此加油站即可。
这两句话的语义是：
第一句话，需要花费的钱数=原来已经花的钱数+加油站的油价*行驶所需新购买的油量。
其中，新购买的油量=行驶所需油量-行驶所需以前购买的油的数量。显然应该先烧之前购买的油，这样新购买的油量会少一些，比较省。
其中，行驶所需的以前购买的油量=min(以前购买的油量，行驶所需油量)。

第二句话，抵达下一个加油站之后的油量=现有油量-行驶所需油量+新购买的油量=现有油量-(行驶所需的以前购买的油量+新购买的油量)+新购买的油量=现有油量-行驶所需的以前购买的油量。

对于第二种情况：

ans+=(c-oil)*b[i];
oil=c-(a[mint]-a[i])/k;

这两句话的语义是：
第一句话，需要花的钱数=原来已经花的钱数+加油站的油价*加满油箱所需要的购买的油量。
其中，加满油箱所需要购买的油量=油箱容量-现有油量。

第二句话，抵达指定加油站之后的油量=油箱容量（因为油箱要先加满）-行驶到此加油站所消耗的油量。

其他类型代码调试：

机房同学给我一份75分代码：

#include<bits/stdc++.h>
using namespace std;
double d[10],jg[10],cha[10],as,ans;
int f; 
double maxx(double a,double b){
	return a>b?a:b;
}
int main(){
	double sy=0,m,v,w,p;
	int n;
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	cin>>m>>v>>w>>p>>n;
	as=v*w;
	for(int i=1;i<=n;i++){
		cin>>d[i]>>jg[i];
		cha[i]=d[i]-d[i-1];
		if(cha[i]>as){
			cout<<"No Solution";
			return 0;
		}
	}
	jg[0]=p;
	d[n+1]=m;
	jg[n+1]=0;
	d[0]=0;
	if(m-d[n]>as){
    	cout<<"No Solution";
		return 0;
	}
	for(int i=0;i<=n;i++){
		if(i>=1){
			sy-=(d[i]-d[i-1])/w;
		}
		f=0;
		for(int j=i+1;j<=n+1;j++){
			if(d[j]-d[i]>as){
				break;
			}
			if(jg[j]<jg[i]){
				f=j;
				break;
			}
		}
		if(f==0){
			ans+=(v-sy)*jg[i];
			sy=v;
		}else{
			if((d[f]-d[i])/w-sy<0){
				continue;
			}
			ans+=jg[i]*((d[f]-d[i])/w-sy);
			sy+=(d[f]-d[i])/w;
		}
	}
	printf("%.2lf",ans);
	return 0;
}

接下来对这个代码进行一些分析。
首先发现源文件内声明了一个从来没有用过的maxx函数。
其次不建议使用同时使用和时关闭流同步。（事实上由于输出操作只有一次，所以可以通过本题。）

同学提供了如下hack数据：
输入：

87.75 13.03 5.75 7.29 3 
22.10 7.38 
24.21 6.81 
82.08 6.96

标准输出：

105.95

实际输出103.45。经过调试发现在i=1时进入了语句：

if(i>=1){
	sy-=(d[i]-d[i-1])/w;
	}

但是sy并没有如预期中减小。经检查变量的值均无误。
推测是精度缺失，将式中变量声明为long double，结果不变。
仍然推测是精度缺失，将上文中的赋值语句修改如下：

sy-=(d[i]-d[i-1])*100.0/w/100.0

成功通过该题。
将式中变量的类型改回double，无法通过该题。

小细节

1.对于long double类型，注意printf要对应修改为%llf。（听说有的地方不支持%llf，也可以在最后一步将ans强制类型转换为double）
2.题目中要求四舍五入，恰好printf就是四舍五入，因此不需要额外设置。

修改之后的代码

#include<bits/stdc++.h>
using namespace std;
long double d[10],jg[10],cha[10],as,ans;
int f; 
int main(){
	long double sy=0,m,v,w,p;
	int n;
	cin>>m>>v>>w>>p>>n;
	as=v*w;
	for(int i=1;i<=n;i++){
		cin>>d[i]>>jg[i];
		cha[i]=d[i]-d[i-1];
		if(cha[i]>as){
			cout<<"No Solution";
			return 0;
		}
	}
	jg[0]=p;
	d[n+1]=m;
	jg[n+1]=0;
	d[0]=0;
	if(m-d[n]>as){
    	cout<<"No Solution";
		return 0;
	}
	for(int i=0;i<=n;i++){
		if(i>=1){
			sy-=(d[i]-d[i-1])*100.0/w/100.0;
//			cout<<"***i="<<i<<":"<<(d[i]-d[i-1])/w<<"***";
		}
//		cout<<"i="<<i<<" now oil="<<sy<<" ";
		f=0;
		for(int j=i+1;j<=n+1;j++){
			if(d[j]-d[i]>as){
				break;
			}
			if(jg[j]<jg[i]){
				f=j;
				break;
			}
		}
		if(f==0){
			ans+=(v-sy)*jg[i];
			sy=v;
		}else{
			if((d[f]-d[i])/w-sy<=0){
				continue;
			}
//			cout<<"*f="<<f<<"*";
			ans+=jg[i]*((d[f]-d[i])/w-sy);
//			cout<<"sy:"<<sy<<"to";
			sy+=(d[f]-d[i])/w;
//			cout<<sy<<" ";
		}
//		cout<<"ans="<<ans<<endl;
	}
//	for(int i=0;i<=n+1;i++) {
//		cout<<i<<":"<<d[i]<<endl;
//	}
	printf("%.2llf",ans);
	return 0;
}

2.AtCoder Beginner Contest 270 ，F - Transportation

主要思路：
将飞机场、港口和桥（我将road称为桥）进行处理，飞机场和港口分别建立超级源点，桥直接连边，跑最小生成树即为答案。
但是这道题会有特殊情况，比如其实不需要建飞机场，那么就不应该向代表飞机场的超级源点连边，但是因为最小生成树算法的关系，还是不得不向其连一条边，因此需要进行特判。

实际的解决方案：
特判太麻烦了，考虑到时间限制为4s，且情况只有以下七种，考虑手动枚举这七种情况，判断图连通性后答案取最小值：

  1. 桥
  2. 飞机
  3. 港口
  4. 桥、飞机
  5. 桥、港口
  6. 飞机、港口
  7. 桥、飞机、港口

如下代码可以通过90%数据（通过36组）：

#include<iostream>
#include<queue>
#include<cstring>
#include<vector>
using namespace std;
typedef pair<long long,long long> dir;
typedef pair<long long,pair<long long,long long>> edge;
vector<vector<dir>> a;
bool vis[200005];
long long n,m;
long long Prim() {
	memset(vis,0,sizeof vis);
	priority_queue<edge,vector<edge>,greater<edge>> q;
	long long sum=0;
	q.push(edge{0,pair<long long,long long>{0,1}});
	while(!q.empty()) {
		long long fa=q.top().second.first;
		long long u=q.top().second.second;
		long long w=q.top().first;
		q.pop();
		if(vis[u]) continue;
		sum+=w;
		vis[u]=true;
		for(auto&i:a[u])
			if(!vis[i.second]) 
				q.push(edge{i.first,pair<long long,long long>{u,i.second}});
	}
	bool flag=true;
	for(long long i=1;i<=n;i++)
		flag=flag&&vis[i];
	if(!flag) return 1e18;
	return sum;
}

long long solve(vector<vector<edge>> b) {
	a.clear();
	for(auto&j:b)
		for(auto&i:j)
			a[i.second.first].push_back(dir{i.first,i.second.second});
	return Prim();
}
int main() {
	cin>>n>>m;
	for(long long i=0;i<=n+2;i++)
		a.push_back(vector<dir>{});
	vector<edge> sky;
	for(long long i=1;i<=n;i++) {
		long long w;
		cin>>w;
		sky.push_back(edge{w,pair<long long,long long>{i,n+2}});
		sky.push_back(edge{w,pair<long long,long long>{n+2,i}});
	}
	vector<edge> harbor;
	for(long long i=1;i<=n;i++) {
		long long w;
		cin>>w;
		harbor.push_back(edge{w,pair<long long,long long>{i,n+1}});
		harbor.push_back(edge{w,pair<long long,long long>{n+1,i}});
	}
	vector<edge> road;
	for(long long i=1;i<=m;i++) {
		long long u,v,w;
		cin>>u>>v>>w;
		road.push_back(edge{w,pair<long long,long long>{u,v}});
		road.push_back(edge{w,pair<long long,long long>{v,u}});
	}
	long long ans=solve(vector<vector<edge>>{road});
	ans=min(ans,solve(vector<vector<edge>>{sky}));
	ans=min(ans,solve(vector<vector<edge>>{harbor}));
	ans=min(ans,solve(vector<vector<edge>>{road,sky}));
	ans=min(ans,solve(vector<vector<edge>>{road,harbor}));
	ans=min(ans,solve(vector<vector<edge>>{sky,harbor}));
	ans=min(ans,solve(vector<vector<edge>>{sky,harbor,road}));
	cout<<ans<<endl;
	return 0;
}

未通过全部数据的原因是，solve函数中vector容器a在清空之后未重新指定大小。
经过修改，如下代码可以通过全部数据：

#include<iostream>
#include<queue>
#include<cstring>
#include<vector>
using namespace std;
typedef pair<long long,long long> dir;
typedef pair<long long,pair<long long,long long>> edge;
vector<vector<dir>> a;
bool vis[200005];
long long n,m;
long long Prim() {
	memset(vis,0,sizeof vis);
	priority_queue<edge,vector<edge>,greater<edge>> q;
	long long sum=0;
	q.push(edge{0,pair<long long,long long>{0,1}});
	while(!q.empty()) {
		long long fa=q.top().second.first;
		long long u=q.top().second.second;
		long long w=q.top().first;
		q.pop();
		if(vis[u]) continue;
		sum+=w;
		vis[u]=true;
		for(auto&i:a[u])
			if(!vis[i.second]) 
				q.push(edge{i.first,pair<long long,long long>{u,i.second}});
	}
	bool flag=true;
	for(long long i=1;i<=n;i++)
		flag=flag&&vis[i];
	if(!flag) return 1e18;
	return sum;
}

long long solve(vector<vector<edge>> b) {
	a.clear();
	for(long long i=0;i<=n+2;i++)
		a.push_back(vector<dir>{});
	for(auto&j:b)
		for(auto&i:j)
			a[i.second.first].push_back(dir{i.first,i.second.second});
	return Prim();
}
int main() {
	cin>>n>>m;
	vector<edge> sky;
	for(long long i=1;i<=n;i++) {
		long long w;
		cin>>w;
		sky.push_back(edge{w,pair<long long,long long>{i,n+2}});
		sky.push_back(edge{w,pair<long long,long long>{n+2,i}});
	}
	vector<edge> harbor;
	for(long long i=1;i<=n;i++) {
		long long w;
		cin>>w;
		harbor.push_back(edge{w,pair<long long,long long>{i,n+1}});
		harbor.push_back(edge{w,pair<long long,long long>{n+1,i}});
	}
	vector<edge> road;
	for(long long i=1;i<=m;i++) {
		long long u,v,w;
		cin>>u>>v>>w;
		road.push_back(edge{w,pair<long long,long long>{u,v}});
		road.push_back(edge{w,pair<long long,long long>{v,u}});
	}
	long long ans=solve(vector<vector<edge>>{road});
	ans=min(ans,solve(vector<vector<edge>>{sky}));
	ans=min(ans,solve(vector<vector<edge>>{harbor}));
	ans=min(ans,solve(vector<vector<edge>>{road,sky}));
	ans=min(ans,solve(vector<vector<edge>>{road,harbor}));
	ans=min(ans,solve(vector<vector<edge>>{sky,harbor}));
	ans=min(ans,solve(vector<vector<edge>>{sky,harbor,road}));
	cout<<ans<<endl;
	return 0;
}
WangLi&a
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
调试学习笔记
qq_44865905的博客
09-01 274
巨有用系列： 找button的事件： 找到button的target： po [btn allTargets] 找action：真的能找到方法名 po [btn actionsForTarget:(id)0x166af1f0 forControlEvent:0]
Python调试学习笔记总结
weixin_67991858的博客
12-13 187
在Python学习中掌握调试，既能够提⾼捕捉代码Bug的能力，又可以极大的提升编程工作效率。因此，我们都不应该忽略学习Python调试的重要性。本文将会总结一下Python调试的学习笔记，具体内容包括从命令⾏运⾏、从脚本内部运⾏以及命令列表。这会触发调试在脚本第⼀⾏指令处停⽌执⾏，这在脚本很短的情况下会很有帮助。你可以通过Python调试模式接着查看变量信息，并且逐⾏调试。
调试笔记
qq_40731414的博客
11-14 667
调试笔记 朱红喜 2020-11-14 更新中… 1.串口安装apk 1. 挂载vendor文件夹，获得读写权限 su mount -o rw,remount /vendor //非系统目录才需要挂载，例如system目录下的就不需要直接拷贝 2. 拷贝U盘的apk 到对应的路径下 cp /mnt/usb/XXX-XXX/xxx.apk /vendor/app/xx/xxx.apk 或者 cp /mnt/usb/XXX-XXX/xxx.apk /system/priv-app/xxxx/xxx.ap
软件调试笔记
学而不思则罔
06-13 522
（1）每句代码都有一个特权记号，cpu在执行的时候首先把这个记号存到“特权寄存器”中，执行的时候根据这个特权级别决定该代码能访问哪些数据1.每个任务有自己的很多段.每个段的信息用一个段描述符维护.多个段描述符构成了段描述符表.2.段描述符表分为三种:GDT(全局),LDT(任务),IDT(cpu中断)3.段选择子:一个64位的值,内容是段描述符表中的段描述符的索引号,其中有一位标示了是指向GDT的
调试命令笔记
求变，从思想开始
07-06 455
make CROSS_COMPILE=arm-linux-androideabi-  make kernelmenuconfig V=1 2187  vim scripts/Makefile.build  2188  make kernelmenuconfig V=1 2189  grep -rn kernelmenuconfig ./  2190  make -f scripts/Makefil...
2022年做笔记的软件知乎.docx
11-04
2022年做笔记的软件知乎.docx 从文件标题、描述、标签和部分内容中，我们可以提炼出以下知识点： 1. notes-taking APPs：有道云笔记、office365、visio、uml等都是优秀的笔记软件。 2. 手写笔记的重要性：手写笔记...
MATLAB学习笔记.zip
04-27
MATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记.zipMATLAB学习笔记....
计算机网络基础笔记.zip
06-20
计算机网络基础笔记.zip计算机网络基础笔记.zip计算机网络基础笔记.zip计算机网络基础笔记.zip计算机网络基础笔记.zip计算机网络基础笔记.zip计算机网络基础笔记.zip计算机网络基础笔记.zip计算机网络基础笔记.zip...
数据结构笔记2022.pdf
08-19
数据结构笔记2022.pdf
笔记 2022年9月18日.note
09-18
笔记 2022年9月18日.note
软件调试 笔记1
yuanlanxiaup
12-03 107
-----------------------------《软件调试》前言--------------------------------------------------------------------------- 指令集(Instruction Set)：一台计算机认识的所有指令 程序：按照一定格式编写的指令序列 通用计算机：同一台计算机，执行不同的指令，就可以完成不同的任务 ...
算法调试笔记
qq_39933667的博客
07-03 454
  今天在进行算法调试的时候，1、发现whie函数中执行了很多初始化程序，这样不利于程序的实时性，并进行了改正，2、不同状态需要随时有指示灯进行指示。以便调试人员的观察，3、为保证信号的完整性，要确保硬件接地良好。...
调试笔记 --- Sending non-protected broadcast ...
kevin's cache的专栏
11-11 7950
软件版本：android8.1 硬件平台：展讯 使用自定义的广播，然后用命令行测试的时候出现如下warning: 1300 D AndroidRuntime: Calling main entry com.android.commands.am.Am 01-01 08:00:36.945 610 1072 E ActivityManager: Sending non-protecte...
KernelShark调试笔记
advdbgger的博客
03-24 3008
KernelShark是Linux系统上的一个优化工具，最初是由红帽公司开发的，主要开发者是Steven Rostedt。根据内核代码中的签名信息，Steven在2007年接手内核的ftrace模块，他可能是在开发ftrace的过程中，出于测试的需要，开发了建立在ftrace功能上的两个工具程序，一个是命令行形式的trace-cmd，另一个便是图形界面的KernelSha...
Windows软件调试学习笔记（三）—— 调试事件的处理
qq_41988448的博客
07-29 1208
软件调试学习笔记（三）—— 调试事件的处理要点回顾调试事件的处理实验一：实现简单调试器（创建进程）实验二：分析异常来源实验三：实现简单调试器（附加进程）实验四：分析NtDebugActiveProcess总结 要点回顾 当调试器与被调试进程建立连接后，调试器与被调试进程关系如下图所示 被调试进程产生调试事件时，会有专门的API对调试事件进行捕获，并写入调试事件链表当中。 调试器不断检索调试事件链表，不断从调试事件链表中取出调试事件并进行处理。 调试事件的处理 调试器调试目标进程步骤： 关联（创建进程
编程调试笔记
Jerry Lee の blog
03-11 272
编程调试笔记1.出错的时候，一定要分析错误的调用栈信息，才能定位错误的位置。2.调试3.单元测试4.文档测试 详见-廖雪峰python教程的【错误、调试和测试章节】 1.出错的时候，一定要分析错误的调用栈信息，才能定位错误的位置。 记录错误 如果不捕获错误，自然可以让Python解释器来打印出错误堆栈，但程序也被结束了。既然我们能捕获错误，就可以把错误堆栈打印出来，然后分析错误原因，同时，让程序继...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1111
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
最新发布
Jk_Mr的博客
07-20 1112
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
burpsuite2022.6.1
09-01
Burp Suite 2022.6.1是Burp Suite的一个版本，它是一个用于Web应用程序渗透测试的工具。根据引用，您可以通过关注VX公众号401SecNote并回复"burp"来获取Burp Suite Professional v2022.6.1及其运行环境。此外，根据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值