結果

問題 No.2180 Comprehensive Line Segments
ユーザー MasKoaTSMasKoaTS
提出日時 2022-10-11 21:25:43
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
TLE  
(最新)
AC  
(最初)
実行時間 -
コード長 3,827 bytes
コンパイル時間 2,721 ms
コンパイル使用メモリ 215,916 KB
実行使用メモリ 10,148 KB
最終ジャッジ日時 2024-11-17 01:05:59
合計ジャッジ時間 106,961 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 7 ms
10,016 KB
testcase_01 AC 2 ms
10,016 KB
testcase_02 AC 2 ms
10,020 KB
testcase_03 TLE -
testcase_04 AC 2 ms
10,016 KB
testcase_05 AC 2 ms
10,016 KB
testcase_06 AC 2 ms
10,020 KB
testcase_07 AC 2 ms
10,020 KB
testcase_08 AC 2 ms
10,016 KB
testcase_09 TLE -
testcase_10 TLE -
testcase_11 TLE -
testcase_12 TLE -
testcase_13 TLE -
testcase_14 TLE -
testcase_15 TLE -
testcase_16 TLE -
testcase_17 TLE -
testcase_18 TLE -
testcase_19 TLE -
testcase_20 AC 2 ms
6,820 KB
testcase_21 TLE -
testcase_22 AC 7 ms
6,816 KB
testcase_23 AC 709 ms
6,816 KB
testcase_24 AC 54 ms
6,816 KB
testcase_25 TLE -
testcase_26 TLE -
testcase_27 TLE -
testcase_28 TLE -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
#define rep(i, l, n) for (int i = (l); i < (n); i++)
#define all(x) x.begin(), x.end()
#define last(v) v[v.size() - 1]
using namespace std;
using ll = long long;
template <class T>	using V = vector<T>;

inline bool isContinuousBit(int bit) {
	while (bit) {
		if ((bit & 3) == 3) {
			return true;
		}
		bit >>= 1;
	}
	return false;
}

inline ll gcd(ll x, ll y) {
	x = abs(x);	y = abs(y);
	while (y != 0) {
		ll r = x % y;
		x = y;
		y = r;
	}
	return x;
}

inline ll lcm(ll x, ll y) {
	ll g = gcd(x, y);
	return x / g * y;
}

struct Fraction {
	ll num;
	ll den;

	Fraction(void) {
		num = 0ll;
		den = 1ll;
	}

	Fraction(ll num, ll den) {
		assert(den != 0);
		ll g = gcd(num, den);
		num /= g;
		den /= g;
		if (den < 0) {
			num = -num;
			den = -den;
		}
		this->num = num;
		this->den = den;
	}

	Fraction operator+(const Fraction other) const {
		ll l = lcm(this->den, other.den);
		ll a = l / this->den;
		ll b = l / other.den;
		ll nnum = this->num * a + other.num * b;
		ll nden = l;
		return Fraction(nnum, nden);
	}

	Fraction operator-(const Fraction other) const {
		Fraction f = Fraction(-other.num, other.den);
		return (*this) + f;
	}

	Fraction operator*(const Fraction other) const {
		ll nnum = this->num * other.num;
		ll nden = this->den * other.den;
		return Fraction(nnum, nden);
	}

	Fraction operator/(const Fraction other) const {
		Fraction f = Fraction(other.den, other.num);
		return (*this) * f;
	}

	bool operator<(const Fraction other) const {
		ll l = lcm(this->den, other.den);
		ll a = l / this->den;
		ll b = l / other.den;
		return (this->num * a < other.num* b);
	}

	bool operator==(const Fraction other) const {
		ll l = lcm(this->den, other.den);
		ll a = l / this->den;
		ll b = l / other.den;
		return (this->num * a == other.num * b);
	}
};
const Fraction zero = Fraction();

inline int sgn(Fraction x) {
	if (zero < x) {
		return 1;
	}
	if (x < zero) {
		return -1;
	}
	return 0;
}


struct Vector2 {
	Fraction x;
	Fraction y;

	Vector2(void) {
		x = zero;
		y = zero;
	}

	Vector2(Fraction x, Fraction y) {
		this->x = x;
		this->y = y;
	}

	Vector2 operator-(const Vector2 other) const {
		return Vector2(this->x - other.x, this->y - other.y);
	}
};

inline bool beSmaeInclination(Vector2 one, Vector2 other) {
	if (one.x == zero) {
		return (other.x == zero and zero < one.y / other.y);
	}
	Fraction a = other.x / one.x;
	return (a * one.y == other.y and zero < a);
}

inline Fraction calcOuterProduct(Vector2 one, Vector2 other) {
	return one.x * other.y - one.y * other.x;
}


/*
* Main Code
*/

int main(void) {
	int N;	cin >> N;
	V<Vector2> P(N);
	rep(i, 0, N) {
		ll x, y;	cin >> x >> y;
		P[i] = { Fraction(x,1ll),Fraction(y,1ll) };
	}

	if (N == 1) {
		cout << 1 << endl;
		return 0;
	}

	int ans = N;
	V<int> num(N);
	rep(i, 0, N) {
		num[i] = i;
	}
	do {
		bool flag = false;
		V<Vector2> p(N);
		rep(i, 0, N) {
			p[i] = P[num[i]];
		}
		V<Vector2> vec = { p[1] - p[0] };
		rep(i, 1, N - 1) {
			Vector2 v = p[i + 1] - p[i];
			if (beSmaeInclination(last(vec), v)) {
				continue;
			}
			if (calcOuterProduct(last(vec), v) == zero) {
				flag = true;
				break;
			}
			vec.push_back(v);
		}
		if (flag) {
			continue;
		}

		int M = vec.size();
		if (M <= 2) {
			ans = min(ans, M);
			continue;
		}
		
		rep(i, 0, 1 << (M - 2)) {
			if (isContinuousBit(i)) {
				continue;
			}
			int bit = i << 1;
			int cnt = M;
			rep(j, 1, M - 1) {
				if (((bit >> j) & 1) == 0) {
					continue;
				}
				Vector2 v1 = vec[j - 1], v2 = vec[j], v3 = vec[j + 1];
				int s1 = sgn(calcOuterProduct(v1, v2));
				int s2 = sgn(calcOuterProduct(v2, v3));
				int s3 = sgn(calcOuterProduct(v1, v3));
				if (s1 == s2 and s2 == s3) {
					cnt--;
				}
			}
			ans = min(ans, cnt);
		}
	} while (next_permutation(all(num)));

	cout << ans << endl;

	return 0;
}
0