結果

問題 No.2392 二平方和
ユーザー Astral__Astral__
提出日時 2023-07-28 21:35:54
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 28 ms / 2,000 ms
コード長 7,128 bytes
コンパイル時間 3,318 ms
コンパイル使用メモリ 215,528 KB
最終ジャッジ日時 2025-02-15 20:08:13
ジャッジサーバーID
(参考情報)
judge4 / judge1
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 26
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#include<bits/stdc++.h>
#define PPque priority_queue<tuple<ll, ll, ll>, vector<tuple<ll, ll, ll>>, greater<tuple<ll, ll, ll>>>
#define Pque priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>>
#define pque priority_queue<int, vector<int>, greater<int>>
#define umap unordered_map
#define uset unordered_set
#define rep(i, s, f) for(ll i = s; i <= f; i++)
#define all0(x) (x).begin() ,(x).end()
#define all(x) (x).begin() + 1, (x).end()
#define vvvi vector<vector<vector<int>>>
#define vvvl vector<vector<vector<ll>>>
#define vvi vector<vector<int>>
#define vvl vector<vector<ll>>
#define vvs vector<vector<string>>
#define vvc vector<vector<char>>
#define vvp vector<vector<pair<ll, ll>>>
#define vvb vector<vector<bool>>
#define vp vector<pair<ll, ll>>
#define vi vector<int>
#define vl vector<ll>
#define vs vector<string>
#define vc vector<char>
#define vb vector<bool>
#define P pair<ll, ll>
#define TU tuple<ll, ll, ll>
#define ENDL '\n'
#define ull unsigned long long
#define debug(a, s) rep(i, s, a.size()-1) {cout << a.at(i) << " ";}cout << endl;
#define Debug(a, s) rep(i, s, a.size()-1) {rep(j, s, a.at(i).size()-1) {cout << a.at(i).at(j) << " ";}cout << endl;}
typedef long long ll;
using namespace std;
////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
template <typename T>
T or_less(vector<T> &A, T x) { //x : sort : -1
return distance(A.begin(), upper_bound(A.begin(), A.end(), x)-1);
}
template <typename T>
T under(vector<T> &A, T x) { //x : sort : -1
return distance(A.begin(), lower_bound(A.begin(), A.end(), x)-1);
}
template <typename T>
T or_more(vector<T> &A, T x) { //x  : sort : N . //distanceA.beginA.begin() NG: A
    .begin() + 1
return distance(A.begin(), lower_bound(A.begin(), A.end(), x));
}
template <typename T>
T over(vector<T> &A, T x) { //x: sort : N
return distance(A.begin(), upper_bound(A.begin(), A.end(), x));
}
void compress(vector<ll> &A) {//reverseNG
vector<ll> temp = A;
sort(temp.begin()+1, temp.end());
for (int i = 1; i <= int(A.size()-1); i++) {
A.at(i) = distance(temp.begin(), lower_bound(temp.begin()+1, temp.end(), A.at(i)));
}
}
ll LIS1(vl &A) {//at(0)調
ll N = A.size()-1;
vl L(N+1, 1001001001001001001LL);
L.at(0) = -1 * 1001001001001001001LL;
ll ans = 0;
rep(i, 1, N) {
ll idx = over<ll>(L, A.at(i));
L.at(idx) = A.at(i);
ans = max(ans, idx);
}
return ans;
}
ll LIS2(vl &A) {//調
ll N = A.size() - 1;
vl L(N+1, 1001001001001001001LL);
L.at(0) = -1 * 1001001001001001001LL;
ll ans = 0;
rep(i, 1, N) {
ll idx = or_more<ll>(L, A.at(i));
L.at(idx) = A.at(i);
ans = max(ans, idx);
}
return ans;
}
//////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////
ll POWER(ll a, ll b, ll mod) {
a %= mod;
vector<ll> pow (61);
pow.at(0) = a;
bitset<60> bina(b);
ll answer = 1;
for (int i = 1; i <= 60; i++) {
pow.at(i) = pow.at(i-1) * pow.at(i-1) % mod;
if (bina.test(i-1)) {
answer = (answer*pow.at(i-1)) % mod;
}
}
return answer;
}
ll Div(ll a, ll b, ll mod) {
return a * POWER(b, mod-2, mod) % mod;
}
ll round(ll x, ll i) {
return ll(x + 5 * pow(10, i-1))/ll(pow(10, i)) * ll(pow(10, i));
}
template <typename T> //
void normalize(T &mol, T &deno) {
T mol_temp = abs(mol);
T deno_temp = abs(deno);
T GCD = gcd(mol_temp, deno_temp);
mol /= GCD;
deno /= GCD;
}
vvl mat_mul(vvl &a, vvl &b, ll mod) {//0-indexed &&
ll n = a.size();
vvl res(n , vl(n, 0));
rep(i, 0, n-1) {
rep(j, 0, n-1) {
rep(k, 0, n-1) {
res.at(i).at(j) += a.at(i).at(k) * b.at(k).at(j);
res.at(i).at(j) %= mod;
}
}
}
return res;
}
vvl mat_pow(vvl &a, ll b, ll mod) {//0-indexed &&
bitset<60> bina(b);
vvl power = a;
int N = a.size();
vvl res(N, vl(N, 0));
rep(i, 0, N-1) {
res.at(i).at(i) = 1;
}
rep(i, 1, 60) {
if (bina.test(i-1)) {
res = mat_mul(res, power, mod);
}
power = mat_mul(power, power, mod);
}
return res;
}
vvl comb(ll n, ll mod) {//O(N^2) O(1)
vvl v(n+1, vl(n+1, 0));
rep(i, 0, v.size() - 1) {
v.at(i).at(0) = 1;
v.at(i).at(i) = 1;
}
rep(i, 1, v.size()-1) {
rep(j, 1, i) {
v.at(i).at(j) = v.at(i-1).at(j-1) + v.at(i-1).at(j);
v.at(i).at(j) %= mod;
}
}
return v;
}
ll nCk(int n, int k, ll mod) {//O(max( ))
ll ue = 1;
ll sita = 1;
for (int i = 1; i <= k; i++) {
sita *= i;
sita %= mod;
}
for (int i = 1; i <= k; i++) {
ue *= (n-i+1);
ue %= mod;
}
return Div(ue, sita, mod);
}
ll cross(P a, P b) {
return a.first * b.second - a.second * b.first;
}
ll nto10(string S, ll base) {
ll res = 0;
reverse(all0(S));
while(!S.empty()) {
ll num = S.back() - '0';
if(num < 0 || num > 9) num = 9 + S.back() - 'a' + 1;
res = res * base + num;
S.pop_back();
}
return res;
}
string toN(ll N, ll base) {
if(N == 0) return "0";
string ans ="";
ll MOD = abs(base);
while(N != 0) {
ll first = N % MOD;
while(first < 0) first += MOD;
ans += to_string(first);
N -= first;
N /= base;
}
reverse(all0(ans));
return ans;
}
double DIST(P a, P b) {
return sqrt((a.first - b.first) * (a.first - b.first) + (a.second - b.second) * (a.second - b.second));
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
ll int_max = 1001001001;
ll ll_max = 1001001001001001001;
const double pi = 3.141592653589793;
vl dx{0, 1, 0, -1, 0, 1, 1, -1, -1};
vl dy{0, 0, -1, 0, 1, 1, -1, -1, 1};
//cout << fixed << setprecision(10);
//#pragma GCC optimize ("-O3")
//ll mod = 1000000007;
//ll mod = 998244353;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
ll p;
cin >> p;
set<ll> h;
rep(i, 1, 10000) {
h.insert(i * i);
}
rep(i, 1, 10000) {
ll j = p - (i * i);
if(h.count(j)) {
cout << "Yes";
return 0;
}
}
cout << "No";
return 0;
}
//if(S.at(i) == 1 
// mod...?(´ω)
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0