#735029 (C++17(gcc12)) No.1823 Tricolor Dango

• 問題: No.1823 Tricolor Dango
• ユーザー: Yourein
• 提出日時: 2022-01-28 21:45:27
• 言語: C++17(gcc12) (gcc 12.3.0 + boost 1.87.0)
• 結果: WA
• 実行時間: -
• コード長: 8,033 bytes
• コンパイル時間: 3,233 ms
• コンパイル使用メモリ: 162,048 KB
• 実行使用メモリ: 5,472 KB
• 最終ジャッジ日時: 2024-12-30 06:01:03
• 合計ジャッジ時間: 5,183 ms
• ジャッジサーバーID （参考情報）: judge1 / judge5

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	2 ms; 5,248 KB
testcase_01	WA	-
testcase_02	WA	-
testcase_03	WA	-
testcase_04	WA	-
testcase_05	WA	-
testcase_06	WA	-
testcase_07	WA	-
testcase_08	WA	-
testcase_09	WA	-
testcase_10	WA	-
testcase_11	AC	28 ms; 5,248 KB
testcase_12	WA	-
testcase_13	AC	28 ms; 5,248 KB
testcase_14	AC	32 ms; 5,248 KB
testcase_15	AC	26 ms; 5,248 KB
testcase_16	AC	13 ms; 5,248 KB
testcase_17	AC	18 ms; 5,248 KB
testcase_18	AC	34 ms; 5,248 KB
testcase_19	AC	85 ms; 5,472 KB
testcase_20	AC	30 ms; 5,248 KB
testcase_21	WA	-
testcase_22	WA	-
testcase_23	WA	-
testcase_24	WA	-
testcase_25	WA	-

コンパイルメッセージ

main.cpp: In function 'std::istream& operator>>(std::istream&, std::vector<_Tp>&)':
main.cpp:220:94: warning: no return statement in function returning non-void [-Wreturn-type]
  220 | template <typename T> istream &operator>>(istream &is, vector<T> &x){for (auto &y:x) is >> y;}
      |                                                                                              ^

ソースコード

#include <iostream>
#include <iomanip>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>

//Binary Indexed Tree
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
using namespace __gnu_pbds;
//Binary Indexed Tree

using namespace std;
using ll = long long;
using ld = long double;

#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()


namespace cpio{
    //IO library for Competitive-Programming
    struct scanner {
        private:
            struct reader {
                template <typename T> operator T() const {T buf; std::cin >> buf; return buf;}
            };
        public:
            scanner() {std::cin.sync_with_stdio(false); std::cin.tie(nullptr);}

            reader operator()() const {return reader();}
    };

    //Debug out
    void dout(){
        cerr << "\n";
    }
    template<typename T, typename... Ts>
    void dout(const T& a, const Ts&... b){
        cerr << a;
        (cerr << ... << (cerr << ' ', b));
        cerr << "\n";
    }

    template<typename... T>
    void input(T&... a){
        (cin >> ... >> a);
    }

    void fixed(){cout << fixed << setprecision(12);}
}

namespace cpmath{
    //Math library for Competitive-Programming
    const ll mod97 = 1000000007;
    const ll mod99 = 1000000009;
    const ll mod89 = 998244353;
    const long double pi = 3.14159265359;
    std::unordered_set<long long> allowed_mod;
    std::unordered_set<long long> unallowed_mod;

    constexpr int DX4[4] = {1, 0, -1, 0};
    constexpr int DY4[4] = {0, 1, 0, -1};
    constexpr int DX8[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
    constexpr int DY8[8] = {-1, -1, -1, 0, 0, 1, 1, 1};

    ll factorial(ll a, ll b = -1, const ll fmod = -1){
        ll ans = 1;
        if (fmod > 1) {
            if (b == -1) for (ll i = a; i > 1; i--) ans = ((ans%fmod)*(i%fmod))%fmod;
            else for (ll i = a; i >= b; i--) ans = ((ans%fmod)*(i%fmod))%fmod;
        }
        else{
            if (b == -1) for (ll i = a; i > 1; i--) ans = ans*i;
            else for(ll i = a; i >= b; i--) ans = ans*i;
        }
        return ans;
    }

    ll fastpow(ll m, ll p){
        if (p == 0) return 1;
        if (p%2 == 0){
            ll t = fastpow(m, p/2);
            return t*t;
        }
        return m*fastpow(m, p-1);
    }

    ll modpow(ll m, ll p, const ll fmod){
        if (p == 0) return 1;
        if (p%2 == 0){
            ll t = modpow(m, p/2, fmod);
            return (t*t)%fmod;
        }
        return (m*modpow(m, p-1, fmod))%fmod;
    }

    ld dtor(const ld deg){return deg*(pi/(ld)180);}

    template <typename T = long long>
    class modint{
    private:
        T num;
        long long mod;
        bool set_prime_flag;
    public:
        explicit modint(T n, long long m = cpmath::mod99, bool pflag = true){
            num = static_cast<T>(n);
            set_prime_flag = pflag;
            
            if (pflag == true){
                if (mod_is_prime(m)) mod = m;
                else throw std::invalid_argument("Invalid value for mod: Check mod is prime number or set plag to false");
            }
            else mod = m;
        } //modint constructer

        //+ operator
        constexpr modint operator+(modint &t){return modint((this->raw()+t.raw())%this->mod, this->mod, this->set_prime_flag);}
        constexpr modint operator+(long long t){return modint((this->raw()+t)%this->mod, this->mod, this->set_prime_flag);}
        constexpr modint operator+=(modint &t){
            this->num = (this->raw()+t.raw())%mod;
            return modint(this->num, mod, set_prime_flag);
        }
        constexpr modint operator+=(long long t){
            this->num = (this->raw()+t)%mod;
            return modint(this->num, mod, set_prime_flag);
        }
        //+ operator
        //- operator
        constexpr modint operator-(modint &t){return modint(((this->raw()-t.raw())%this->mod+this->mod)%this->mod, this->mod, this->set_prime_flag);}
        constexpr modint operator-(long long t){return modint(((this->raw()-t)%this->mod+this->mod)%this->mod, this->mod, this->set_prime_flag);}
        constexpr modint operator-=(modint &t){
            this->num = ((this->raw()-t.raw())%this->mod+this->mod)%this->mod;
            return modint(this->num, this->mod, this->set_prime_flag);
        }
        constexpr modint operator-=(long long t){
            this->num = ((this->raw()+t)%this->mod+this->mod)%this->mod;
            return modint(this->num, mod, this->set_prime_flag);
        }
        //- operator
        //* operator
        constexpr modint operator*(modint &t){return modint((this->raw()*t.raw())%this->mod, this->mod, this->set_prime_flag);}
        constexpr modint operator*(long long t){return modint((this->raw()*(t%mod))%this->mod, this->mod, this->set_prime_flag);}
        constexpr modint operator*= (modint &t){
            this->num = (this->raw()*t.raw())%this->mod;
            return modint(this->num, this->mod, this->set_prime_flag);
        }
        constexpr modint operator*=(long long t){
            this->num = (this->raw()*(t%mod))%mod;
            return modint(this->num, this->mod, this->set_prime_flag);
        }
        //* operator

        //= operator
        constexpr modint operator=(long long t){
            this->num = t%mod;
            return modint(this->num, this->mod, this->set_prime_flag);
        }
        //= operator

        void plus(T n){num = (num+(n%mod))%mod;}
        void minus(T n){num = ((num-(n%mod))%mod+mod)%mod;}
        void multi(T n){num = ((num%mod)*(n%mod))%mod;}
        void div(T n){
            if (set_prime_flag == false) throw std::logic_error("Not Divisible in case you don't set pflag true");
            else num = (num*inversed(n))%mod;
        }
        
        T raw(){return num;}
    private:
        long long inversed(ll n){
            return cpmath::modpow(n, mod-2, mod);
        }

        bool mod_is_prime(int n){
            if (n == cpmath::mod97 || n == cpmath::mod99 || n == cpmath::mod89 || cpmath::allowed_mod.count(n) > 0){
                return true;
            }
            else if (cpmath::unallowed_mod.count(n) > 0){
                return false;
            }
            else{
                for (ll i = 2; i*i <= n; i++){
                    if (n%i == 0) {
                        cpmath::unallowed_mod.insert(n);
                        return false;
                    }
                }
                cpmath::allowed_mod.insert(n);
                return true;
            }
        } //mod_is_prime
    }; //modint
}

cpio::scanner in;
using cpio::dout;
using cpio::input;
using cpmath::mod89;
using cpmath::mod97;
using cpmath::mod99;
using cpmath::modint;
//using cpmath::DX4;
//using cpmath::DY4;
//using cpmath::DX8;
//using cpmath::DY8;

//GNU Binary Indexed Tree
// template<typename T>
// using gtree = tree<T, null_type, greater<T>, rb_tree_tag, tree_order_statistics_node_update>;

template <typename T> istream &operator>>(istream &is, vector<T> &x){for (auto &y:x) is >> y;}

int main(){
    // cpio::fixed(); // Decimal Point Output
    int t = in();

    while(t--){
        priority_queue<ll> dango;
        int n = in();
        for (int i = 0; i < n; i++){
            ll ai = in();
            dango.push(ai);
        }

        while(1){
            ll a, b, c;
            a = dango.top();
            dango.pop();
            b = dango.top();
            dango.pop();
            c = dango.top();
            dango.pop();

            ll made = min({a, b, c});
            a -= made;
            b -= made;
            c -= made;

            if (a > 0) dango.push(a);
            if (b > 0) dango.push(b);
            if (c > 0) dango.push(c);

            if (dango.size() < 3) break;
        }

        if (dango.size() == 0) cout << "Yes" << endl;
        else cout << "No" << endl;
    }
}