Skip to content

Instantly share code, notes, and snippets.

@CodeBoy2006

CodeBoy2006/caryon.h

Created September 10, 2022 14:24
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save CodeBoy2006/a7b753c9f132c115b94142e7516d635a to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save CodeBoy2006/a7b753c9f132c115b94142e7516d635a to your computer and use it in GitHub Desktop.
Download ZIP
CarYon 数据生成器
Raw
caryon.h
#ifndef CARYON_H
#define CARYON_H
#ifndef _GLIBCXX_NO_ASSERT
# include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <windows.h>
#if __cplusplus >= 201103L
# include <ccomplex>
# include <cfenv>
# include <cinttypes>
# include <cstdalign>
# include <cstdbool>
# include <cstdint>
# include <ctgmath>
# include <cwchar>
# include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
# include <array>
# include <atomic>
# include <chrono>
# include <condition_variable>
# include <forward_list>
# include <future>
# include <initializer_list>
# include <mutex>
# include <random>
# include <ratio>
# include <regex>
# include <scoped_allocator>
# include <system_error>
# include <thread>
# include <tuple>
# include <type_traits>
# include <typeindex>
# include <unordered_map>
# include <unordered_set>
#endif
#define makein(m, n) for (__ci = m; __ci <= n; __ci++)
#define fs(i, x, y, z) for (long long i = x; i <= y; i += z)
#define ft(i, x, y, z) for (long long i = x; i >= y; i += z)
#ifndef CarYon
# define CarYon 3.7
#endif
std::string dataname;
int cprime[1000000];
int __ci;
int __cnt;
const int __N = 151, __moda = 1000000007;
int maxtime = 1000;
long double runtime;
bool ___flag = false;
void csh() {
__cnt = 0;
}
int cgcd(int a, int b) {
int t = 1;
while (t != 0) {
t = a % b;
a = b;
b = t;
}
return a;
}
template < typename T1, typename T2 >
void ms(T1* a, T2 b) {
memset(a, b, sizeof(a));
}
template < typename T >
int sz(T* a) {
return sizeof(a);
}
int lcm(int x, int y) {
return x / cgcd(x, y) * y;
}
std::stringstream sp;
namespace crand {
bool isInit;
int MTindex;
long long MT[624];
void csrand(int seed) {
MTindex = 0;
isInit = 1;
MT[0] = seed;
for (int i = 1; i < 624; i++) {
int t = 1812433253 * (MT[i - 1] ^ (MT[i - 1] >> 30)) + i;
MT[i] = t & 0xffffffff;
}
}
inline void generate() {
for (int i = 0; i < 624; i++) {
long long y = (MT[i] & 0x80000000) + (MT[(i + 1) % 624] & 0x7fffffff);
MT[i] = MT[(i + 397) % 624] ^ (y >> 1);
if (y % 2 == 1)
MT[i] ^= 2147483647;
}
}
inline int cyrand() {
if (!isInit)
#if __cplusplus <= 201103L
csrand((int)time(NULL));
#else
csrand((int)time(nullptr));
#endif
if (MTindex == 0)
generate();
int y = MT[MTindex];
y = y ^ (y >> 11);
y = y ^ ((y << 7) & 1636928640);
y = y ^ ((y << 15) & 1022730752);
y = y ^ (y >> 18);
MTindex = (MTindex + 1) % 624;
return y;
}
inline long long cyrand_ll() {
return ((long long)(cyrand()) << 31) + cyrand();
}
inline int cyrand(int a, int b) {
if (a > b)
a = b;
if (a == b)
return a;
else
return cyrand() % (b - a + 1) + a;
}
inline long long cyrand_ll(long long a, long long b) {
if (a > b)
a = b;
if (a == b)
return a;
else
return cyrand_ll() % (b - a + 1) + a;
}
inline bool cyrand_bool() {
if (cyrand(0, 1) == 0)
return false;
else
return true;
}
inline char cyrand_letter() {
return cyrand(32, 126);
}
inline char cyrand_engs() {
return 'a' + cyrand(0, 26);
}
inline char cyrand_engb() {
return 'A' + cyrand(0, 26);
}
inline char cyrand_fomatc() {
switch (cyrand(0, 4)) {
case 0: {
return '\n';
break;
}
case 1: {
return '\t';
break;
}
case 2: {
return '\r';
break;
}
case 3: {
return '\v';
break;
}
case 4: {
return '\f';
break;
}
}
}
inline std::string cyrand_word(int a) {
std::string chen_zhe;
for (int kkksc03 = 0; kkksc03 < a; kkksc03++) {
char t=cyrand_engs();
chen_zhe += t;
}
return chen_zhe;
}
inline std::string cyrand_article(int a) {
std::string soha;
soha = cyrand_word(cyrand(1, 10));
for (int lzn = 1; lzn < a; lzn++) {
soha = soha + " " + cyrand_word(cyrand(1, 10));
}
return soha;
}
template < typename T >
inline T choice(T* a, int lbound, int ubound) {
return a[cyrand(lbound, ubound)];
}
inline double doubleRandom() {
srand(time(0));
return (double)(rand() / (double)RAND_MAX);
}
void RandomP(int* arr,int size){
for(int i=0;i<size;i++){
arr[i]=i+1;
}
int t=cyrand(0,size/2);
for(int i=0;i<t;i++){
std::swap(arr[cyrand(0,size-1)],arr[cyrand(0,size-1)]);
}
}
inline bool __checktmp(int* arr, int tmp, int flag, int end) {
if (flag == 0) {
return true;
}
for (int i = 0; i < end; i++) {
if (flag == -1) {
if (arr[i] == tmp) {
return false;
}
}
else if (flag == 1) {
if (arr[i] > tmp) {
return false;
}
}
else if (flag == 2) {
if (arr[i] < tmp) {
return false;
}
}
else if (flag == 3) {
if (arr[i] >= tmp) {
return false;
}
}
else if (flag == 4) {
if (arr[i] <= tmp) {
return false;
}
}
}
return true;
}
inline void randomArr(int* arr, int n, int lower, int upper, int flag) {
for (int i = 0; i < n;) {
int tmp = cyrand(lower, upper);
if (__checktmp(arr, tmp, flag, i - 1)) {
arr[i++] = tmp;
}
}
}
} // namespace crand
namespace cgraph {
template < typename T >
struct edge {
int v;
T w;
bool operator<(const edge& rw) const // priority_queue
{
return w > rw.w;
}
};
template < typename T >
struct U {
std::vector< edge< T > > u;
};
template < typename T >
struct graph { // graph
int n, m;
std::vector< U< T > > g;
graph() {
;
}
void update(int ntemp) {
U< T > updatemp;
updatemp.u.clear();
while (g.size() <= ntemp)
g.push_back(updatemp);
}
int ccmax(int a, int b) {
if (a > b)
return a;
else
return b;
}
void addedge(int u, int v, T w) {
n = ccmax(n, u);
n = ccmax(n, v);
update(ccmax(u, v));
m++;
edge< T > tmp;
tmp.v = v, tmp.w = w;
g[u].u.push_back(tmp);
}
bool is_connect() {
const int vstsize = n + 1;
int vstn = 0;
bool vst[vstsize];
memset(vst, false, sizeof(vst));
std::queue< int > q;
int begin = crand::cyrand(1, n);
vst[begin] = true;
vstn = 1;
q.push(begin);
while (!q.empty()) {
int tmp = q.front();
q.pop();
for (int i = 0; i < g[tmp].u.size(); i++) {
if (!vst[g[tmp].u[i].v]) {
vst[g[tmp].u[i].v] = true;
vstn++;
q.push(g[tmp].u[i].v);
}
}
}
return ((vstn == n) ? true : false);
}
void output(graph< T > c) {
std::cout << c;
}
};
template < typename T >
std::ostream& operator<<(std::ostream& os, const graph< T >& c) {
os << c.n << ' ' << c.m << '\n';
for (int i = 1; i <= c.n; i++) {
for (int j = 0; j < c.g[i].u.size(); j++)
os << i << ' ' << c.g[i].u[j].v << ' ' << c.g[i].u[j].w << '\n';
}
return os;
}
template < typename T >
graph< T > operator+(graph< T > a, graph< T > b) {
graph< T > ret;
ret = a;
ret.m = a.m + b.m;
ret.update(ret.n);
for (int i = 1; i <= b.n; i++) {
for (int j = 0; j < b.g[i].u.size(); j++) {
ret.g[i].u.push_back(b.g[i].u[j]);
}
}
return ret;
}
template < typename T >
graph< T > rand_graph(int n, int m, T mn, T mx, T (*randfunc)(T, T)) {
graph< T > ret;
ret.n = n;
ret.m = m;
ret.update(n);
for (int i = 1; i <= m; i++) {
edge< T > tmp;
tmp.v = crand::cyrand(1, m);
tmp.w = randfunc(mn, mx);
ret.g[crand::cyrand(1, n)].u.push_back(tmp);
}
return ret;
}
struct caryon_node2 {
int num, id1, id2;
};
bool crayon_cmp1(caryon_node2 a, caryon_node2 b) {
return a.num < b.num;
}
template < typename T >
graph< T > rand_dag(int n, int m, T mn, T mx, T (*randfunc)(T, T)) {
graph< T > ret;
ret.update(n);
ret.n = n;
ret.m = m;
for (int i = 1; i <= m; i++) {
edge< T > tmp;
int utmp = crand::cyrand(1, crand::cyrand(1, n - 1));
tmp.v = crand::cyrand(utmp + 1, n);
tmp.w = randfunc(mn, mx);
ret.g[utmp].u.push_back(tmp);
}
return ret;
}
struct caryon_node1 {
int id;
int soncnt;
};
template < typename T >
graph< T > rand_tree(int n, int k, T mn, T mx, T (*randfunc)(T, T)) {
graph< T > ret;
ret.n = n;
ret.m = n - 1;
ret.update(n);
std::vector< caryon_node1 > t;
std::vector< int > hash;
for (int i = 1; i <= n; i++) {
hash.push_back(i);
}
random_shuffle(hash.begin(), hash.end());
caryon_node1 updatemp;
updatemp.id = hash[0];
updatemp.soncnt = 0;
t.push_back(updatemp);
for (int j = 2; j <= n; j++) {
int i = hash[j - 1];
std::swap(t[crand::cyrand(0, t.size() - 1)], t[t.size() - 1]);
t[t.size() - 1].soncnt++;
if (t[t.size() - 1].soncnt == k)
t.pop_back();
edge< T > tmp;
tmp.v = t[t.size() - 1].id;
tmp.w = randfunc(mn, mx);
ret.g[i].u.push_back(tmp);
updatemp.id = i;
updatemp.soncnt = 0;
t.push_back(updatemp);
}
return ret;
}
template < typename T >
graph< T > connect_graph(int n, int m, T mn, T mx, T (*randfunc)(T, T)) {
int k = crand::cyrand(1, n);
graph< T > ret;
do {
ret = rand_graph(n, m, mn, mx, crand::cyrand);
} while (!ret.isconnect());
}
} // namespace cgraph
namespace inout {
inline void inint(int a) {
std::string c, ccci, tnmp;
std::stringstream ss, cci;
if (__cnt == 0) {
if (!___flag) {
std::string a666 = "mkdir data-" + dataname;
system(a666.c_str());
___flag = true;
}
cci << __ci;
cci >> ccci;
std::string name = "data-" + dataname + "./" + dataname + ccci + ".in";
freopen(name.c_str(), "w", stdout);
freopen(name.c_str(), "r", stdin);
}
ss << a;
ss >> c;
std::cin >> tnmp;
c = tnmp + c;
std::cout << c;
++__cnt;
}
inline void instring(std::string a) {
std::string ccci, tnmp;
if (__cnt == 0) {
if (!___flag) {
std::string a666 = "mkdir data-" + dataname;
system(a666.c_str());
___flag = true;
}
std::stringstream cci;
cci << __ci;
cci >> ccci;
std::string name = "data-" + dataname + "./" + dataname + ccci + ".in";
freopen(name.c_str(), "w", stdout);
freopen(name.c_str(), "r", stdin);
}
std::cin >> tnmp;
a = tnmp + a;
std::cout << a;
++__cnt;
}
template < typename T >
inline void ingraph(cgraph::graph< T > a) {
std::string ccci, tnmp;
if (__cnt == 0) {
if (!___flag) {
std::string a666 = "mkdir data-" + dataname;
system(a666.c_str());
___flag = true;
}
std::stringstream cci;
cci << __ci;
cci >> ccci;
std::string name = "data-" + dataname + "./" + dataname + ccci + ".in";
freopen(name.c_str(), "w", stdout);
freopen(name.c_str(), "r", stdin);
}
a.output(a);
++__cnt;
}
template < typename T >
inline void in(T a) {
std::string c, ccci, tnmp;
std::stringstream ss, cci;
if (__cnt == 0) {
if (!___flag) {
std::string a666 = "mkdir data-" + dataname;
system(a666.c_str());
___flag = true;
}
cci << __ci;
cci >> ccci;
std::string name = "data-" + dataname + "./" + dataname + ccci + ".in";
freopen(name.c_str(), "w", stdout);
freopen(name.c_str(), "r", stdin);
}
ss << a;
ss >> c;
std::cin >> tnmp;
c = tnmp + c;
std::cout << c;
++__cnt;
}
inline void inspace() {
std::string ccci, tnmp;
if (__cnt == 0) {
if (!___flag) {
std::string a666 = "mkdir data-" + dataname;
system(a666.c_str());
___flag = true;
}
std::stringstream cci;
cci << __ci;
cci >> ccci;
std::string name = "data-" + dataname + "./" + dataname + ccci + ".in";
freopen(name.c_str(), "w", stdout);
freopen(name.c_str(), "r", stdin);
}
std::cin >> tnmp;
std::string a = tnmp + " ";
std::cout << a;
++__cnt;
}
inline void inendl() {
std::string ccci, tnmp;
if (__cnt == 0) {
if (!___flag) {
std::string a666 = "mkdir data-" + dataname;
system(a666.c_str());
___flag = true;
}
std::stringstream cci;
cci << __ci;
cci >> ccci;
std::string name = "data-" + dataname + "./" + dataname + ccci + ".in";
freopen(name.c_str(), "w", stdout);
freopen(name.c_str(), "r", stdin);
}
std::cin >> tnmp;
std::string a = tnmp + "\n";
std::cout << a;
++__cnt;
}
inline void out(int a) {
freopen("CON.exe", "w", stdout);
freopen("CON.exe", "r", stdin);
std::stringstream aa;
std::string aaa;
aa << a;
aa >> aaa;
std::string abc;
std::string name = "data-" + dataname + "./" + dataname + aaa + ".in";
freopen(name.c_str(), "r", stdin);
std::string outname = "data-" + dataname + "./" + dataname + aaa + ".out";
freopen(outname.c_str(), "w", stdout);
system("std.exe");
}
inline void makeout(int b, int a) {
MessageBox(NULL,
"In files are already generated, you can find them in the "
"new folder "
"in this directory.",
"CarYon", MB_ICONINFORMATION);
for (int i = b; i <= a; ++i) {
out(i);
freopen("CON.exe", "r", stdin);
freopen("CON.exe", "w", stdout);
std::stringstream _a;
std::string _i;
_a << i;
_a >> _i;
}
MessageBox(NULL,
"Out files are already generated, you can find them in the "
"new folder "
"in this directory.",
"CarYon", MB_ICONINFORMATION);
}
inline void closefile() {
freopen("CON.exe", "w", stdout);
freopen("CON.exe", "r", stdin);
}
} // namespace inout
namespace cydebug {
std::stringstream __re;
void makeDebugFile(int a, int b) {
std::string ___a = "mkdir debug-" + dataname;
system(___a.c_str());
for (int i = a; i <= b; ++i) {
std::stringstream debug1;
std::string Debug1;
debug1 << i;
debug1 >> Debug1;
std::string debugname1 =
"debug-" + dataname + "./" + dataname + Debug1 + ".ans";
std::string debugname2 =
"data-" + dataname + "./" + dataname + Debug1 + ".in";
freopen(debugname1.c_str(), "w", stdout);
freopen(debugname2.c_str(), "r", stdin);
long double clock1 = clock();
__re << system("myprogram.exe") << std::endl;
runtime = (int)(clock() - clock1);
sp << runtime << std::endl;
}
inout::closefile();
}
void compareFile(int a, int b) {
int ____cnt = 0;
freopen("Debug.log", "w", stdout);
for (int i = a; i <= b; i++) {
inout::closefile();
freopen("Debug.log", "a", stdout);
std::cout << "Comparing " << i << ".out and " << i << ".ans...\n";
std::stringstream debug1;
std::string Debug1;
debug1 << i;
debug1 >> Debug1;
std::string command = "tools\\Compare\\NOIPStyle.exe debug-" +
dataname + "\\" + dataname + Debug1 +
".ans data-" + dataname + "\\" + dataname +
Debug1 + ".out";
int flag = system(command.c_str());
sp >> runtime;
int __tmp;
__re >> __tmp;
freopen("Debug.log", "a", stdout);
if (__tmp != 0) {
std::cout << "TestCase " << i << ", result: RE.\n";
}
else if (runtime > maxtime) {
std::cout << "TestCase " << i
<< ", result: TLE. The program\'s runtime is " << runtime
<< " ms.\n";
}
else if (flag == 1) {
std::cout << "TestCase " << i << ", result: AC.\n";
____cnt++;
}
else if (flag == 0) {
std::cout << "TestCase " << i << ", result: WA.\n";
}
else if (flag == -1) {
std::cout << "TestCase " << i << ", result: Judgement failed.\n";
}
else {
std::cout << "TestCase " << i << ", result: UKE.\n";
}
}
inout::closefile();
std::cout << "Compare is compeleted." << std::endl;
long double score = (long double)____cnt * 1.0 / (b - a + 1) * 100;
std::stringstream tempp;
std::string tmp;
tempp << score;
tempp >> tmp;
std::string command = "The score is " + tmp + "\n";
MessageBox(NULL, command.c_str(), "CarYon", MB_ICONINFORMATION);
}
void debug(int a, int b) {
makeDebugFile(a, b);
MessageBox(NULL, "Debug files were maked successfully.", "CarYon",
MB_ICONINFORMATION);
compareFile(a, b);
MessageBox(NULL, "Debug successfully.", "CarYon", MB_ICONINFORMATION);
system("pause");
}
} // namespace cydebug
namespace cconst {
const long double PI = 3.141592653589793238462643383279502884197169399;
const long double E = 2.7182818284590452353602874713527;
const std::string ALPHABET_SMALL = "abcdefghijklmnopqrstuvwxyz";
const std::string ALPHABET_CAPITAL = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const std::string ALPHABET =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
const std::string NUMBERS = "0123456789";
const int INF = 0x7f7f7f;
} // namespace cconst
#if __cplusplus >= 201103L
namespace caryon_cpp11 {
template < typename T >
T choice_plus(std::initializer_list< T > a) {
std::vector< T > b;
for (auto i : a) {
b.push_back(i);
}
return b[crand::cyrand(1, b.size()) - 1];
}
} // namespace caryon_cpp11
#endif
namespace cmath {
class quadtri {
public:
int a, b, c;
char s;
int Delta;
quadtri() {
a = 1;
b = 0;
c = 0;
s = 'x';
Delta = 0;
}
quadtri(int x, int y, int z, char tmp) {
a = x;
b = y;
c = z;
s = tmp;
Delta = b * b - 4 * a * c;
}
void make(char abc) {
s = abc;
a = crand::cyrand(-100, 100);
while (a == 0) {
a = crand::cyrand(-100, 100);
}
b = crand::cyrand(-100, 100);
c = crand::cyrand(-100, 100);
}
void makeDelta() {
Delta = b * b - 4 * a * c;
}
void makecanfac(char abc) {
do {
s = abc;
a = crand::cyrand(-100, 100);
while (a == 0) {
a = crand::cyrand(-100, 100);
}
b = crand::cyrand(-100, 100);
c = crand::cyrand(-100, 100);
Delta = b * b - 4 * a * c;
} while (!(Delta == (int)sqrt(Delta) * (int)sqrt(Delta)));
}
quadtri operator+(const quadtri cc) const {
quadtri tmp;
tmp.a = a + cc.a;
tmp.b = b + cc.b;
tmp.c = c + cc.c;
return tmp;
}
quadtri operator-(const quadtri aaa) const {
quadtri tmp;
tmp.a = a - aaa.a;
tmp.b = b - aaa.b;
tmp.c = c - aaa.c;
return tmp;
}
quadtri operator+(const int aaa) const {
quadtri tmp;
tmp.a = a;
tmp.b = b;
tmp.c = tmp.c + aaa;
return tmp;
}
quadtri operator-(const int aaa) const {
return *this + (-a);
}
};
class stpolyon {
public:
long double length, perimeter;
long long edge;
long double oprc(bool flag) {
if (flag) {
perimeter = (long double)edge * length;
}
return (long double)edge * length;
}
};
class kucan { // By Billy2007
public:
long long p, q, dlt[__N][__N];
kucan() {
p = 1, q = 1;
ms(dlt, 0);
}
kucan operator+(const kucan b) const {
kucan c;
if (b.p == p && b.q == q) {
fs(i, 1, p, 1) {
fs(j, 1, q, 1) {
c.dlt[i][j] = dlt[i][j] + b.dlt[i][j];
}
}
c.p = p;
c.q = q;
}
else {
fs(i, 1, p, 1) {
fs(j, 1, q, 1) {
c.dlt[i][j] = dlt[i][j]; //+b.dlt[i][j];
}
}
fs(i, 1, b.p, 1) {
fs(j, 1, b.q, 1) {
c.dlt[i + p][j + q] = b.dlt[i][j];
}
}
c.p = p + b.p;
c.q = q + b.q;
}
return c;
}
kucan operator-(const kucan b) const {
kucan c;
if (b.p == p && b.q == q) {
fs(i, 1, p, 1) {
fs(j, 1, q, 1) {
c.dlt[i][j] = dlt[i][j] - b.dlt[i][j];
}
}
c.p = p;
c.q = q;
}
return c;
}
kucan operator*(const kucan b) const {
kucan c;
if (b.p == q) {
c.p = p;
c.q = b.q;
fs(i, 1, c.p, 1) {
fs(j, 1, c.q, 1) {
long long jk = 0;
fs(k, 1, q, 1) {
jk += dlt[i][k] * b.dlt[k][j];
jk %= __moda;
}
c.dlt[i][j] = jk;
c.dlt[i][j] %= __moda;
}
}
}
return c;
}
kucan operator*(const long long b) const {
kucan c;
fs(i, 1, p, 1) {
fs(j, 1, q, 1) {
c.dlt[i][j] = dlt[i][j] * b;
}
}
c.p = p;
c.q = q;
return c;
}
void out() {
fs(i, 1, p, 1) {
fs(j, 1, q, 1) {
std::cout << dlt[i][j];
std::cout << ' ';
}
std::cout << std::endl;
}
}
};
class circle {
public:
long double r, c, area;
long double oprc(bool flag) {
if (flag)
c = 2 * r * cconst::PI;
return 2 * r * cconst::PI;
}
long double opra(bool flag) {
if (flag)
area = cconst::PI * r * r;
return cconst::PI * r * r;
}
circle operator+(const circle x) const {
circle tmp;
tmp.r = r + x.r;
tmp.c = 2 * r * cconst::PI;
tmp.area = cconst::PI * r * r;
return tmp;
}
circle operator-(const circle x) const {
circle tmp;
tmp.r = r - x.r;
tmp.c = 2 * r * cconst::PI;
tmp.area = cconst::PI * r * r;
return tmp;
}
bool operator>(const circle b) const {
circle c = *this - b;
if (c.r > 0)
return true;
else
return false;
}
bool operator>=(const circle b) const {
return !(b > *this);
}
bool operator<(const circle b) const {
return b > *this;
}
bool operator<=(const circle b) const {
return !(*this > b);
}
bool operator==(const circle b) const {
return !(*this > b) && !(b > *this);
}
bool operator!=(const circle b) const {
return !(*this == b);
}
};
inline long double
cdistance(long double a1, long double a2, long double b1, long double b2) {
return sqrt((a1 - b1) * (a1 - b1) + (a2 - b2) * (a2 - b2));
}
template < typename T >
inline T cabs(T a) {
return a > 0 ? a : -a;
}
inline int cmin(int a, int b) {
return a < b ? a : b;
}
inline int cmax(int a, int b) {
return a > b ? a : b;
}
template < typename T >
T cgcd(T a, T b) {
return a == 0 ? b : cgcd(b % a, a);
}
inline bool isprime(int a) {
if (a < 2)
return false;
for (int i = 2; i <= sqrt(a); ++i) {
if (a % i == 0)
return false;
}
return true;
}
inline int cmakeprime(int a, int b) {
int prcnt = 0;
for (int i = a; i <= b; i++) {
if (isprime(i)) {
cprime[prcnt++] = i;
}
}
}
inline int crprimenum(int beg, int end) {
return cprime[crand::cyrand(beg, end)];
}
class rectangle {
public:
int a, b, peri, area;
rectangle() {
a = 0;
b = 0;
peri = 0;
area = 0;
}
void makePeri() {
peri = (a + b) * 2;
}
void makeArea() {
area = a * b;
}
};
class triangle {
public:
int a, b, c, h1, h2, h3, peri, area;
triangle() {
a = b = c = h1 = h2 = h3 = peri = area = 0;
}
void makePeri() {
peri = a + b + c;
}
void makeArea() {
int p = (a + b + c) / 2;
area = sqrt(p * (p - a) * (p - b) * (p - c));
}
};
class frac { // By GoneTime&luosw
private:
void huaj() {
long long kk = cgcd(son, mom);
son /= kk;
mom /= kk;
}
bool fu() {
huaj();
if (son < 0 && mom < 0) {
son = -son;
mom = -mom;
return 0;
}
else if (son > 0 && mom > 0) {
return 0;
}
else
return 1;
}
public:
int son, mom;
frac() {
son = 0;
mom = 1;
}
frac(int a, int b) {
son = a;
mom = b;
}
long double value() {
return (long double)son * 1.0 / mom;
}
std::string take(bool flag) {
int c = cgcd(son, mom);
son /= c;
mom /= c;
std::stringstream tmp1, tmp2;
std::string aaa, bbb;
tmp1 << son;
tmp1 >> aaa;
tmp2 << mom;
tmp2 >> bbb;
return (flag) ? aaa + '/' + bbb : aaa + ' ' + bbb;
}
std::string fracr(bool flag) {
std::stringstream tmp1, tmp2;
std::string aaa, bbb;
tmp1 << son;
tmp1 >> aaa;
tmp2 << mom;
tmp2 >> bbb;
return (flag) ? aaa + '/' + bbb : aaa + ' ' + bbb;
}
frac operator*(const frac b) const {
frac c;
c.son = son * b.son;
c.mom = mom * b.mom;
c.huaj();
return c;
}
frac operator/(const frac b) const {
frac c;
c.son = son * b.mom;
c.mom = mom * b.son;
c.huaj();
return c;
}
frac operator+(const frac b) const {
frac c;
c.mom = lcm(mom, b.mom);
c.son = son * (c.mom / mom) + b.son * (c.mom / b.mom);
c.huaj();
return c;
}
frac operator-(const frac b) const {
frac c;
c.mom = lcm(mom, b.mom);
c.son = son * (c.mom / mom) - b.son * (c.mom / b.mom);
c.huaj();
return c;
}
frac operator+(const int a) const {
frac tmp;
frac abc;
abc.son = a;
abc.mom = 1;
tmp = *this + abc;
return tmp;
}
frac operator-(const int a) const {
return *this + (-a);
}
frac operator*(const int a) const {
frac tmp, abc;
abc.son = a;
abc.mom = 1;
tmp = tmp * abc;
return tmp;
}
frac operator/(const int a) const {
frac tmp, abc;
abc.son = a;
abc.mom = 1;
tmp = tmp / abc;
return tmp;
}
bool operator>(const frac b) const {
frac c = *this - b;
if (c.fu())
return 0;
else
return 1;
}
bool operator<(const frac b) const {
return b > *this;
}
bool operator<=(const frac b) const {
return !(*this > b);
}
bool operator>=(const frac b) const {
return !(b > *this);
}
bool operator!=(const frac b) const {
return (b > *this) || (*this > b);
}
bool operator==(const frac b) const {
return !(*this > b) && !(b > *this);
}
};
} // namespace cmath
namespace cgeo {
class point {
public:
double x, y;
point() {
x = 0;
y = 0;
}
point(int a, int b) {
x = a;
y = b;
}
double pointDis(point b) {
return sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
}
};
class line {
public:
double k, b;
line() {
k = 0;
b = 0;
}
line makeLine(point a, point b) {
line tmp;
tmp.k = (a.y - b.y) / (a.x - b.x);
tmp.b = a.y - ((a.y - b.y) / (a.x - b.x) * a.x);
return tmp;
}
};
class hypotenuse {
public:
double k;
hypotenuse() {
k = 1;
}
hypotenuse makeHypotenuse(point a) {
hypotenuse tmp;
tmp.k = a.x * a.y;
}
};
class parabola {
public:
double a, b, c;
parabola() {
a = 1;
b = 0;
c = 0;
}
};
} // namespace cgeo
namespace ca {
using namespace cydebug;
using namespace cgeo;
using namespace cmath;
using namespace cgraph;
using namespace crand;
using namespace inout;
using namespace cconst;
#if __cplusplus >= 201103L
using namespace caryon_cpp11;
#endif
} // namespace ca
#endif
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment