hdu6206 17青岛网络赛1001 大数

最新推荐文章于 2021-04-20 20:49:47 发布
最新推荐文章于 2021-04-20 20:49:47 发布
阅读量307 收藏
点赞数
文章标签： 不喜欢加Tag

这个模板是别人的由于支持负数操作就搬过来用了QAQ

模板原地址：http://www.cnblogs.com/huanglianjing/p/4002872.html


这道题裸的求外接圆圆心和半径，只要判断第四个点到圆心的距离比半径大就好了

注意：计算几何如果都是整数点，距离什么的都不要开方，除法都不除，别的地方乘上去，保证没有误差，1次就AC


AC代码：

//大数模板，以青岛1001为例 
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <iostream>
using namespace std;
#define MAXBIT 1007
#define BITTYPE int
typedef long long ll;

class BigInt
{
	public:
		BITTYPE bit[MAXBIT];
		bool negative;

	public:
		BigInt();            //默认构造函数，值为0
		BigInt(const ll);        //构造函数
		BigInt(const char *);    //构造函数
		BigInt(const BigInt &);    //复制构造函数

		/*重载赋值运算符*/
		BigInt& operator=(const BigInt&);
		BigInt& operator=(const int        );

		/*重载算数运算符*/
		BigInt operator+(const BigInt&    )const;
		BigInt operator+(const int        )const;
		BigInt operator+=(const BigInt&    );
		BigInt operator+=(const int        );
		BigInt operator-(const BigInt&    )const;
		BigInt operator-(const int        )const;
		BigInt operator-=(const BigInt&    );
		BigInt operator-=(const int        );
		BigInt operator-(                )const;
		BigInt operator*(const BigInt&    )const;
		BigInt operator*(const int        )const;
		BigInt operator*=(const BigInt&    );
		BigInt operator*=(const int        );
		BigInt operator/(const int        )const;
		BigInt operator/=(const int        );
		int    operator%(const int        )const;
		BigInt operator%=(const int        );

		/*重载比较运算符*/
		bool operator>(const BigInt&    )const;
		bool operator>(const int        )const;
		bool operator>=(const BigInt&    )const;
		bool operator>=(const int        )const;
		bool operator<(const BigInt&    )const;
		bool operator<(const int        )const;
		bool operator<=(const BigInt&    )const;
		bool operator<=(const int        )const;
		bool operator==(const BigInt&    )const;
		bool operator==(const int        )const;
		bool operator!=(const BigInt&    )const;
		bool operator!=(const int        )const;

		void print()        const;//输出数值
		char *string()        const;//返回数值字符串
		bool isZero()        const;//是否为0
		bool isPositive()    const;//是否为正数
		bool isNegative()    const;//是否为负数
		bool nonNegative()    const;//是否为非负数

	private:
		BigInt opposite()const;//取相反数
		BigInt absoluteAdd(const BigInt&)const;//加上绝对值
		BigInt absoluteMinus(const BigInt&)const;//减去绝对值小于自身的数的绝对值
		bool   absoluteEqual(const BigInt&)const;//绝对值等于
		bool   absoluteGreater(const BigInt&)const;//绝对值大于
		bool   absoluteEqualGreater(const BigInt&)const;//绝对值大于等于
};

BigInt::BigInt()
{
	memset(bit,0,sizeof(bit));
	negative = false;
}

BigInt::BigInt(const ll n)
{
	memset(bit,0,sizeof(bit));
	ll nn = n;
	if (nn>=0) negative = false;
	else
	{
		negative = true;
		nn = -nn;
	}
	ll pos = 0;
	while (nn)
	{
		bit[pos++] = nn % 10;
		nn /= 10;
	}
}

BigInt::BigInt(const char *s)
{
	int len = strlen(s);
	bool valid = true;//符合数字格式
	if (len >= 2)
	{
		if (s[0]!='+' && s[0]!='-' && !isdigit(s[0])) valid = false;
		for (int i=1; i<len; ++i)
		{
			if (!isdigit(s[i])) valid = false;
		}
	}
	else if (len == 1)
	{
		if (!isdigit(s[0])) valid = false;
	}
	if (len==0 || !valid)
	{
		memset(bit,0,sizeof(bit));
		negative = false;
		return;
	}
	int beg = 0, end = len-1;
	if (s[0] == '+')
	{
		negative = false;
		++beg;
	}
	else if (s[0] == '-')
	{
		bool zeroFlag = true;
		for (int i=1; i<len; ++i)
		{
			if (s[i]!='0')
			{
				zeroFlag = false;
				break;
			}
		}
		if (zeroFlag) negative = false;
		else negative = true;
		++beg;
	}
	else negative = false;
	memset(bit,0,sizeof(bit));
	for (int i=beg; i<=end; ++i)
	{
		bit[len-1-i] = s[i] - '0';
	}
}

BigInt::BigInt(const BigInt& n)
{
	memcpy(bit,n.bit,sizeof(bit));
	negative = n.negative;
}

BigInt& BigInt::operator=(const BigInt& n)
{
	memcpy(bit,n.bit,sizeof(bit));
	negative = n.negative;
	return *this;
}

BigInt& BigInt::operator=(const int n)
{
	return *this = BigInt(n);
}

BigInt BigInt::operator+(const BigInt& n)const
{
	if ((!negative && !n.negative) || (negative && n.negative))
	{
		return this->absoluteAdd(n);
	}
	else
	{
		if (absoluteEqual(n)) return BigInt();
		else if (absoluteEqualGreater(n)) return this->absoluteMinus(n);
		else return n.absoluteMinus(*this);
	}
}

BigInt BigInt::operator+(const int n)const
{
	return *this + BigInt(n);
}

BigInt BigInt::operator+=(const BigInt& n)
{
	return *this = *this + n;
}

BigInt BigInt::operator+=(const int n)
{
	return *this = *this + n;
}

BigInt BigInt::operator-(const BigInt& n)const
{
	return *this + n.opposite();
}

BigInt BigInt::operator-(const int n)const
{
	return *this - BigInt(n);
}

BigInt BigInt::operator-=(const BigInt& n)
{
	return *this = *this - n;
}

BigInt BigInt::operator-=(const int n)
{
	return *this = *this - n;
}

BigInt BigInt::operator-()const
{
	BigInt bi(*this);
	if (!this->isZero()) bi.negative = !bi.negative;
	return bi;
}

BigInt BigInt::operator*(const BigInt& n)const
{
	if (isZero() || n.isZero()) return BigInt();
	BigInt bi = BigInt();
	if ((!negative && !n.negative) || (negative && n.negative))
	{
		bi.negative = false;
	}
	else bi.negative = true;
	for (int i=0; i<MAXBIT; ++i) for (int j=0; j<MAXBIT-i; ++j)
		{
			bi.bit[i+j] += bit[i] * n.bit[j];
		}
	for (int i=0; i<MAXBIT-1; ++i)  //进位
	{
		bi.bit[i+1] += bi.bit[i] / 10;
		bi.bit[i] %= 10;
	}
	return bi;
}

BigInt BigInt::operator*(const int n)const
{
	return *this * BigInt(n);
}

BigInt BigInt::operator*=(const BigInt& n)
{
	return *this = *this - n;
}

BigInt BigInt::operator*=(const int n)
{
	return *this = *this * n;
}

BigInt BigInt::operator/(const int n)const
{
	//除以0直接返回0
	if (isZero() || n==0) return BigInt();
	BigInt bi = BigInt();
	if ((!negative && n>0) || (negative && n<0))
	{
		bi.negative = false;
	}
	else bi.negative = true;
	int div = 0;//累计除数
	for (int i=MAXBIT-1; i>=0; --i)
	{
		div = div * 10 + bit[i];
		bi.bit[i] = div / n;
		div %= n;
	}
	return bi;
}

BigInt BigInt::operator/=(const int n)
{
	//除以0直接返回0
	if (isZero() || n==0) return BigInt();
	else return *this = *this / n;
}

int BigInt::operator%(const int n)const
{
	int mod = 0;//累计余数
	for (int i=MAXBIT-1; i>=0; --i)
	{
		//mod = ((mod*(MAXBIT+1/*??*/)) + bit[i]) % n;
		mod = ((mod*10) + bit[i]) % n;
	}
	return mod;
}

BigInt BigInt::operator%=(const int n)
{
	int mod = 0;//累计余数
	for (int i=MAXBIT-1; i>=0; --i)
	{
		//mod = ((mod*(MAXBIT+1/*??*/)) + bit[i]) % n;
		mod = ((mod*10) + bit[i]) % n;
	}
	return *this = BigInt(mod);
}

bool BigInt::operator>(const BigInt& n)const
{
	if (!negative && n.negative) return true;
	else if (negative && !n.negative) return false;
	else if (!negative && !n.negative) return absoluteGreater(n);
	else return n.absoluteGreater(*this);
}

bool BigInt::operator>(const int n)const
{
	return *this > BigInt(n);
}

bool BigInt::operator>=(const BigInt& n)const
{
	if (!negative && n.negative) return true;
	else if (negative && !n.negative) return false;
	else if (!negative && !n.negative) return absoluteEqualGreater(n);
	else return n.absoluteEqualGreater(*this);
}

bool BigInt::operator>=(const int n)const
{
	return *this >= BigInt(n);
}

bool BigInt::operator<(const BigInt& n)const
{
	return n > *this;
}

bool BigInt::operator<(const int n)const
{
	return *this < BigInt(n);
}

bool BigInt::operator<=(const BigInt& n)const
{
	return n >= *this;
}

bool BigInt::operator<=(const int n)const
{
	return *this <= BigInt(n);
}

bool BigInt::operator==(const BigInt& n)const
{
	if (negative != n.negative) return false;
	for (int i=0; i<MAXBIT; ++i)
	{
		if (bit[i] != n.bit[i]) return false;
	}
	return true;
}

bool BigInt::operator==(const int n)const
{
	return *this == BigInt(n);
}

bool BigInt::operator!=(const BigInt& n)const
{
	if (negative != n.negative) return true;
	for (int i=0; i<MAXBIT; ++i)
	{
		if (bit[i] != n.bit[i]) return true;
	}
	return false;
}

bool BigInt::operator!=(const int n)const
{
	return *this != BigInt(n);
}

void BigInt::print()const
{
	if (negative) printf("-");
	int pos = MAXBIT - 1;
	for (; pos>0; --pos)
	{
		if (bit[pos]) break;
	}
	for (int i=pos; i>=0; --i) printf("%d",bit[i]);
}

char *BigInt::string()const
{
	char content1[1007+2];
	int posi = 0;
	if (negative) content1[posi++] = '-';
	int pos = MAXBIT - 1;
	for (; pos>0; --pos)
	{
		if (bit[pos]) break;
	}
	//printf("pos = %d\n",pos);
	for (int i=pos; i>=0; --i)
	{
		content1[posi++] = bit[i] + '0';
		//printf("bit[%d] = %d\n",i,bit[i]);
	}
	content1[posi] = '\0';
	return content1;
}

bool BigInt::isZero()const
{
	bool zeroFlag = true;
	for (int i=0; i<MAXBIT; ++i)
	{
		if (bit[i] != 0)
		{
			zeroFlag = false;
			break;
		}
	}
	return zeroFlag;
}

bool BigInt::isPositive()const
{
	return !negative && !isZero();
}

bool BigInt::isNegative()const
{
	return negative;
}

bool BigInt::nonNegative()const
{
	return !negative;
}

BigInt BigInt::opposite()const
{
	BigInt n(*this);
	if (!n.isZero()) n.negative = !n.negative;
	return n;
}

BigInt BigInt::absoluteAdd(const BigInt& n)const
{
	BigInt bi(*this);
	int next = 0;//进位
	for (int i=0; i<MAXBIT; ++i)
	{
		bi.bit[i] = (bit[i] + n.bit[i] + next) % 10;
		next   = (bit[i] + n.bit[i] + next) / 10;
	}
	return bi;
}

BigInt BigInt::absoluteMinus(const BigInt& n)const
{
	BigInt bi(*this);
	for (int i=MAXBIT-1; i>=0; --i)
	{
		if (bi.bit[i]>=n.bit[i]) bi.bit[i] -= n.bit[i];
		else  //借位
		{
			int borrow = i + 1;//借位位
			while (bi.bit[borrow]==0) ++borrow;
			--bi.bit[borrow];
			for (int j=i+1; j<borrow; ++j) bi.bit[j] = 9;
			bi.bit[i] = bi.bit[i] + 10 - n.bit[i];
		}
	}
	return bi;
}

bool BigInt::absoluteEqual(const BigInt& n)const
{
	for (int i=0; i<MAXBIT; ++i)
	{
		if (bit[i] != n.bit[i]) return false;
	}
	return true;
}

bool BigInt::absoluteGreater(const BigInt& n)const
{
	for (int i=MAXBIT-1; i>=0; --i)
	{
		if (bit[i]>n.bit[i]) return true;
		else if (bit[i]<n.bit[i]) return false;
	}
	return false;
}

bool BigInt::absoluteEqualGreater(const BigInt& n)const
{
	for (int i=MAXBIT-1; i>=0; --i)
	{
		if (bit[i]>n.bit[i]) return true;
		else if (bit[i]<n.bit[i]) return false;
	}
	return true;
}
BigInt dist(BigInt px1,BigInt py1,BigInt px2,BigInt py2)
{
	BigInt t;
	t=(px1-px2)*(px1-px2)+(py1-py2)*(py1-py2);
	return t;
}
BigInt coco(BigInt px1,BigInt py1,BigInt px2,BigInt py2,BigInt px3,BigInt py3,BigInt &qx,BigInt &qy,BigInt &d)
{
	BigInt r;
	BigInt er(2);

	BigInt x12=px2-px1;
	BigInt y12=py2-py1;
	BigInt x13=px3-px1;
	BigInt y13=py3-py1;

	BigInt z2=x12*(px1+px2)+y12*(py1+py2);
	BigInt z3=x13*(px1+px3)+y13*(py1+py3);
	d=er*((x12*py3+y12*px2)-(y12*px3+x12*py2));

	qx=y13*z2-y12*z3;
	qy=x12*z3-x13*z2;
	r=dist(d*px1,d*py1,qx,qy);
	return r;
}
int main()
{

	int T;
	cin>>T;
	while(T--)
	{
		ll a1,b1,c1,d1,e1,f1,g1,h1;
		cin>>a1>>b1>>c1>>d1>>e1>>f1>>g1>>h1;
		BigInt px1(a1);
		BigInt py1(b1);
		BigInt px2(c1);
		BigInt py2(d1);
		BigInt px3(e1);
		BigInt py3(f1);
		BigInt px4(g1);
		BigInt py4(h1);
		BigInt qx;
		BigInt qy;
		BigInt d;
		BigInt r=coco(px1,py1,px2,py2,px3,py3,qx,qy,d);
		BigInt tem=dist(qx,qy,d*px4,d*py4);
		if(tem>r)
			printf("Accepted\n");
		else
			printf("Rejected\n");
	
	}

}




animalcoder
关注
【2017青岛网络赛】1004 hdu 6209 The Intersection 二分
弱菜zc
09-19 1348
Problem Description A given coefficient K leads an intersection of two curves f(x) and gK(x). In the first quadrant, the curve f is a monotone increasing function that f(x)=x√. The curve g
HDU 5988 2016青岛区域赛 (最小费用流)
taotao 的大学墓志
09-06 2362
题目链接HDU 5988分析这题一看就是一个网络流的模板题，不过需要注意建边的费用!! 首先很容易想到，s与每个区域连一条边，费用为0，容量为 sis_i,区域与 tt 连一条边 容量为 bib_i 费用为0。然后就是考虑区域与区域之间的连边了。我们想象一下最终的分配方案，假设对于边 eije_{ij} 来说，我们让 kijk_{ij} 个人通过，那么eije_{ij} 不被破坏的概率是 (1−p
hdu6206—Apple（计算几何+高精度）
zhiyuanjiang的博客
09-18 664
题目链接：传送门 Apple Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 686    Accepted Submission(s): 228 Problem Description Apple is
HDU6206 几何 + 高精度
即使摸爬滚打，满身泥泞，我也要前进
10-09 401
简略题意：给出4个点的坐标，问第4个点是不是在前3个点组成的三角形的外接圆外。先求出外接圆，然后判断第4个点和圆心的距离即可，唯一的问题是精度不够，需要上java。import java.io.PrintWriter; import java.math.BigDecimal; import java.math.BigInteger; import java.util.Scanner; /** *
HDU6206Apple(Java可以过，但是我有一个大胆的想法)
Cai_Haiq的博客
09-18 1079
比赛的时候我有些蠢了。。。 本来想这是个签到题，一看69发，0A。接着就怂了。然后我有个大胆的想法，（接下来说大胆的想法）当时把我激动坏了，（真的蠢）没有这个大胆的想法一看有Java 过了的早就想到用大数A了。结果写了好久才发现人家大数A了，才去写Java。。。 这个题的坑在于数据范围超过了double的精度，所以会有精度丢失，用Java大数就怕了。BigDecimal的精度足够。 Java
hdu 6206 Apple 计算几何
老李2009
09-19 418
Apple Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Problem Description Apple is Taotao's favourite fruit. In his backyard, there are three apple trees w
HDU 6206 Apple（高精度C++）
南极亚拉的博客
09-20 471
题意：给你三个点，保证不再同一条直线上，再给你一点，问你是否在这三个点形成的圆外。 思路：就是求出三个点外接圆的圆心和半径判断下。 已知三点坐标，求外接圆圆心坐标与半径。 #include #include #include #include #include #include #include #include #define MAX_L 2005 //
HDU杭电 计算机网络实验报告
03-11
这份"HDU杭电 计算机网络实验报告"压缩包提供了丰富的实验材料，涵盖了多个关键的网络技术，包括交换机配置、路由协议、地址转换（NAT）、访问控制列表（ACL）以及动态主机配置协议（DHCP）等。以下是这些实验报告所...
【2017青岛网络赛】hdu 6212 Zuma 1007 区间dp
弱菜zc
09-18 878
Problem Description Think about the Zuma Game. You have a row of at most 200 black(0) or white(1) balls on the table at the start. Each three consecutive balls never share the same colour. You al
hdu1001解题报告
03-09
hdu1001解题报告
HDU 6206 Apple（高精度浮点数）
不要錯過才珍惜
09-17 923
题目地址 题意：告诉你四个点，求最后一个点在不在前三个点围成的圆上。 思路：三个点连成的形状是一个三角形，那那个圆就是这个三角形的外接圆，那圆心应该就是在三角形的外心上，给定三角形三个顶点的坐标，如何求三角形的外心的坐标呢？我在网上找到的公式： 给定a（x1,y1） b（x2,y2） c（x3,y3）求外接圆心坐标O（x，y） 1. 首先，外接圆的圆心是三角形三条边的垂直平分线的交点，
2017 ACM-ICPC 亚洲区（青岛赛区）网络赛 HDU 6206 1001 Apple（三角形外接圆圆心和半径）
CillyB的博客
09-17 2151
题意：给你三个点，保证不再同一条直线上，再给你一点，问你是否在这三个点形成的圆外。 思路：就是求出三个点外接圆的圆心和半径判断下。精度问题需要用Java大数。 已知三点坐标，求外接圆圆心坐标与半径。 a=((y2-y1)*(y3*y3-y1*y1+x3*x3-x1*x1)-(y3-y1)*(y2*y2-y1*y1+x2*x2-x1*x1))/(2.0*((x3-x1)*(y2
hdu 6206 Apple
iTom's blog
09-18 793
给出圆上三点 A、B、C 和另一个点 D 的坐标，问 D 是否在圆外
HDU 6206 Apple (计算几何_三点求圆 & 高精度浮点数 & Java大数_BigDecimal)
Satur9的博客
04-20 237
传送门 题意：确定第四个点是否在前三个点形成的圆以外，若是输出"Accepted"，否则输出"Rejected"。 思路：这里应用其他大佬的证明过程(截图偏于保存，细则可移步查看)。 有了圆心 (，)，再带入任意一点便能求得半径值了。 但是由于这个题的精度爆double，于是采取Java的大数BigDecimal来求解，这里先展示C++的代码思路结构。 C++代码实现： #include<bits/stdc++.h> #define endl '\n' #def
hdu 6206 Apple（Java大数）
Singular__point的博客
09-19 962
Apple Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 806    Accepted Submission(s): 267 Problem Description Apple is Taotao's favo
HDU 6206 Apple （数学 高精度计算）
Merry_hj的博客
09-19 514
http://acm.hdu.edu.cn/showproblem.php?pid=2604 题目大意：给你4个点的坐标，问第4个点是否在由前3个点所构成的外接圆外，如果是就输出“Accept”否则输出“Reject”。 解题思路：对于给定的3个点（设这3个点的坐标为a（x1,y1） b（x2,y2） c（x3,y3））所构成的外接圆，圆心为O（x，y） 根据圆的特点可得如下方程 (x1-
Apple HDU6206
DeathYmz的博客
07-28 319
2018TYUT暑期ACM模拟赛(8) Apple HDU6206 题意：给出四个点，问第四个点在不在前三个点构成的圆内。 思路：一开始队里的说这个简单，妈耶，后来大家发现这个小技巧是不行的，还是要高精度，作为模拟赛的所以默默去找了一个高精度大数模板。有点小不理解自己套上圆心半径计算公式的模板不对，然后看了别的大佬的题解，为啥是求半径的公式是两点相加的平法？？？？？有点小蒙。 #incl...
HDU 6206 Apple（外心）
huatian5的博客
09-24 330
题目：http://acm.hdu.edu.cn/showproblem.php?pid=6206 题意：三个点在一个圆上，让求一个点是否在圆外 思路：就是求外接圆圆心和半径，判断点到圆心的距离是否大于半径 圆心坐标（a，b），半径为r，点(x,y)，公式为： a = ((y2-y1)(y3*y3-y1*y1+x3*x3-x1*x1) - (y3-y1)(y2*y2-y1*y1+x2*x2-
剧本杀服务平台（源码、论文、说明文档、数据库文档）.zip
最新发布
06-17
论文、开发文档、数据文档、源码 个人经导师指导并认可通过的高分设计项目，项目中的源码都是经过本地编译过可运行的，都经过严格调试，确保可以运行！主要针对计算机相关专业的正在做大作业、毕业设计的学生和需要项目实战练习的学习者，资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有需要的话可以放心下载使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值