#1017085 (C++23) No.2920 Blood Type

提出ソース
結果

問題	No.2920 Blood Type
ユーザー	wsrtrt
提出日時	2024-10-12 14:37:47
言語	C++23 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	2 ms / 2,000 ms
コード長	15,692 bytes
コンパイル時間	3,115 ms
コンパイル使用メモリ	254,296 KB
実行使用メモリ	5,248 KB
最終ジャッジ日時	2024-10-12 14:37:52
合計ジャッジ時間	4,132 ms
ジャッジサーバーID （参考情報）	judge5 / judge4
このコードへのチャレンジ
（要ログイン）
テストケース

テストケース表示
入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 5,248 KB
testcase_01	AC	2 ms 5,248 KB
testcase_02	AC	2 ms 5,248 KB
testcase_03	AC	2 ms 5,248 KB
testcase_04	AC	2 ms 5,248 KB
testcase_05	AC	2 ms 5,248 KB
testcase_06	AC	2 ms 5,248 KB
testcase_07	AC	2 ms 5,248 KB
testcase_08	AC	2 ms 5,248 KB
testcase_09	AC	2 ms 5,248 KB
testcase_10	AC	2 ms 5,248 KB
testcase_11	AC	2 ms 5,248 KB
testcase_12	AC	2 ms 5,248 KB
testcase_13	AC	2 ms 5,248 KB
testcase_14	AC	2 ms 5,248 KB
testcase_15	AC	2 ms 5,248 KB
testcase_16	AC	1 ms 5,248 KB
testcase_17	AC	2 ms 5,248 KB
testcase_18	AC	2 ms 5,248 KB
testcase_19	AC	2 ms 5,248 KB
testcase_20	AC	2 ms 5,248 KB
testcase_21	AC	1 ms 5,248 KB
testcase_22	AC	2 ms 5,248 KB
testcase_23	AC	2 ms 5,248 KB
testcase_24	AC	2 ms 5,248 KB
testcase_25	AC	2 ms 5,248 KB
testcase_26	AC	2 ms 5,248 KB
testcase_27	AC	2 ms 5,248 KB
testcase_28	AC	2 ms 5,248 KB
testcase_29	AC	1 ms 5,248 KB
testcase_30	AC	2 ms 5,248 KB
testcase_31	AC	2 ms 5,248 KB
testcase_32	AC	2 ms 5,248 KB
testcase_33	AC	2 ms 5,248 KB
testcase_34	AC	2 ms 5,248 KB
testcase_35	AC	2 ms 5,248 KB
権限があれば一括ダウンロードができます
ソースコード

raw source code
#include "bits/stdc++.h"
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define INT(...)                                                                                                                                               \
    int __VA_ARGS__;                                                                                                                                           \
    IN(__VA_ARGS__)
#define LL(...)                                                                                                                                                \
    ll __VA_ARGS__;                                                                                                                                            \
    IN(__VA_ARGS__)
#define STR(...)                                                                                                                                               \
    string __VA_ARGS__;                                                                                                                                        \
    IN(__VA_ARGS__)
#define CHR(...)                                                                                                                                               \
    char __VA_ARGS__;                                                                                                                                          \
    IN(__VA_ARGS__)
#define DBL(...)                                                                                                                                               \
    double __VA_ARGS__;                                                                                                                                        \
    IN(__VA_ARGS__)
#define ll long long
#define cout std::cout
#define yes cout<<"Yes"<<"\n"
#define no cout<<"No"<<"\n"
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#define allr(x) (x).rbegin(),(x).rend()
#define SUM(v) accumulate(all(v), 0LL)
#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define pii pair<int, int>
#define pll pair<long long,long long>
#define pb push_back
#define eb emplace_back
#define ff first
#define ss second
#define vi vector<int>
#define vll vector<long long>
#define vvll vector<vector<long long>>
#define vc vector<char>
#define vvi vector<vector<int>> 
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size)                                                                                                                                  \
    vector<type> name(size);                                                                                                                                   \
    IN(name)
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S> void scan(pair<T, S> &p) { scan(p.first), scan(p.second); }
template <class T> void scan(vector<T> &);
template <class T> void scan(vector<T> &a) {
    for(auto &i : a) scan(i);
}
template <class T> void scan(T &a) { cin >> a; }
void IN() {}
template <class Head, class... Tail> void IN(Head &head, Tail &...tail) {
    scan(head);
    IN(tail...);
}
template <class T> void print(const T &a) { cout << a; }
void OUT() { cout << endl; }
template <class Head, class... Tail> void OUT(const Head &head, const Tail &...tail) {
    print(head);
    if(sizeof...(tail)) cout << ' ';
    OUT(tail...);
}
#define vv(type, name, h, ...) vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, w)                                                                                                                                   \
    vector<vector<type>> name(h, vector<type>(w));                                                                                                             \
    IN(name)
#define vvv(type, name, h, w, ...) vector<vector<vector<type>>> name(h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)                                                                                                                         \
    vector<vector<vector<vector<type>>>> name(a, vector<vector<vector<type>>>(b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> pair<T, T> operator-(const pair<T, T> &x, const pair<T, T> &y) { return pair<T, T>(x.ff - y.ff, x.ss - y.ss); }
template <class T> pair<T, T> operator+(const pair<T, T> &x, const pair<T, T> &y) { return pair<T, T>(x.ff + y.ff, x.ss + y.ss); }
template <class T> pair<T, T> operator&(const pair<T, T> &l, const pair<T, T> &r) { return pair<T, T>(max(l.ff, r.ff), min(l.ss, r.ss)); }
template <class T> vector<T> &operator--(vector<T> &v) {
    fore(e, v) e--;
    return v;
}
template <class T> vector<T> operator--(vector<T> &v, int) {
    auto res = v;
    fore(e, v) e--;
    return res;
}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
#define UNIQUE(x) sort(all(x)), x.erase(unique(all(x)), x.end())
//åº§æ¨å§ç¸®
template <typename T> void zip(vector<T> &x) {
    vector<T> y = x;
    UNIQUE(y);
    for(int i = 0; i < x.size(); ++i) { x[i] = lb(y, x[i]); }
}
template <class T> T ceil(T x, T y) {
    assert(y >= 1);
    return (x > 0 ? (x + y - 1) / y : x / y);
}
template <class T> T floor(T x, T y) {
    assert(y >= 1);
    return (x > 0 ? x / y : (x + y - 1) / y);
}
long long POW(long long x, int n) {
    long long res = 1LL;
    for(; n; n >>= 1, x *= x)
        if(n & 1) res *= x;
    return res;
}
//0^n=0
long long modpow(long long a, long long n, long long mod) {
    a%=mod;
    assert(a!=0||n!=0);
    if(a==0)return 0;
    long long res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}
//return 0<=a&&a<h&&0<=b&&b<w;
inline bool ingrid(int a,int b,int h,int w){return 0<=a&&a<h&&0<=b&&b<w;}
//return return 0<=a&&a<n;
inline bool inl(int a,int n){return 0<=a&&a<n;}
// bit æ¼ç®ç³»
ll pow2(int i) { return 1LL << i; }
int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int lowbit(signed a) { return a == 0 ? 32 : __builtin_ctz(a); }
int lowbit(ll a) { return a == 0 ? 64 : __builtin_ctzll(a); }
// int allbit(int n) { return (1 << n) - 1; }
ll allbit(ll n) { return (1LL << n) - 1; }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
int in() {
    int x;
    cin >> x;
    return x;
}
ll lin() {
    unsigned long long x;
    cin >> x;
    return x;
}
long long sqrtll(long long x) {
    assert(x >= 0);
    long long rev = sqrt(x);
    while(rev * rev > x) --rev;
    while((rev+1) * (rev+1)<=x) ++rev;
    return rev;
}
int logN(long long n){
    int ret=1;
    while((1LL<<ret)<n)ret++;
    return ret;
}
const double PI=3.1415926535897932384626433832795028841971;
const ll MOD = 998244353;
const int INFI = numeric_limits<int>::max() / 2; const long long INFL = numeric_limits<long long>::max() / 2;
#define inf INFINITY

template<class T>
void debug(vector<T> a){
    rep(i,0,(int)a.size()){
        cout<<a[i]<<' ';
    }
    cout<<endl;
    return;
}

bool palindrome(const string& s){
    return equal(all(s),s.rbegin());
}

template <std::uint_fast64_t Modulus> class modint {
    using u64 = std::uint_fast64_t;
public:
    u64 a;
    constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
    constexpr u64 &val() noexcept { return a; }
    constexpr const u64 &val() const noexcept { return a; }
    constexpr modint operator+(const modint rhs) const noexcept {
        return modint(*this) += rhs;
    }
    constexpr modint operator-(const modint rhs) const noexcept {
        return modint(*this) -= rhs;
    }
    constexpr modint operator*(const modint rhs) const noexcept {
        return modint(*this) *= rhs;
    }
    constexpr modint operator/(const modint rhs) const noexcept {
        return modint(*this) /= rhs;
    }
    constexpr modint &operator+=(const modint rhs) noexcept {
        a += rhs.a;
        if (a >= Modulus) {
            a -= Modulus;
        }
        return *this;
    }
    constexpr modint &operator-=(const modint rhs) noexcept {
        if (a < rhs.a) {
            a += Modulus;
        }
        a -= rhs.a;
        return *this;
    }
    constexpr modint &operator*=(const modint rhs) noexcept {
        a = a * rhs.a % Modulus;
        return *this;
    }
    constexpr modint &operator/=(modint rhs) noexcept {
        u64 exp = Modulus - 2;
        while (exp) {
        if (exp % 2) {
          *this *= rhs;
        }
        rhs *= rhs;
        exp /= 2;
        }
        return *this;
    }
    friend bool operator==(const modint& a,const modint& b) { return a.val()==b.val(); }
    friend bool operator!=(const modint& a,const modint& b) { return a.val()!=b.val(); }
};
using mint9=modint<998244353>;
using mint1=modint<1000000007>;
constexpr pii dx4[4] = {pii{-1, 0}, pii{0, 1}, pii{1, 0}, pii{0, -1}};
constexpr pii dx8[8] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
constexpr pii dx[8] = { {-1, 0}, {0, -1}};

#define el "\n"
#define endl "\n"
#define fastio std::cin.sync_with_stdio(false);std::cin.tie(nullptr); 


template< typename T, typename E, typename F, typename G, typename H >
struct LazySegmentTree {
private:
    int n{}, sz{}, height{};
    vector< T > data;
    vector< E > lazy;
    const F f;
    const G g;
    const H h;
    const T ti;
    const E ei;

    inline void update(int k) {
        data[k] = f(data[2 * k + 0], data[2 * k + 1]);
    }

    inline void all_apply(int k, const E &x) {
        data[k] = g(data[k], x);
        if(k < sz) lazy[k] = h(lazy[k], x);
    }

    inline void propagate(int k) {
        if(lazy[k] != ei) {
            all_apply(2 * k + 0, lazy[k]);
            all_apply(2 * k + 1, lazy[k]);
            lazy[k] = ei;
        }
    }

public:
    LazySegmentTree() = default;

    explicit LazySegmentTree(int n, const F f, const G g, const H h,const T &ti, const E &ei)
        : n(n), f(f), g(g), h(h), ti(ti), ei(ei) {
        sz = 1;
        height = 0;
        while(sz < n) sz <<= 1, height++;
        data.assign(2 * sz, ti);
        lazy.assign(2 * sz, ei);
    }

    explicit LazySegmentTree(const vector< T > &v, const F f, const G g, const H h,const T &ti, const E &ei)
        : LazySegmentTree(v.size(), f, g, h, ti, ei) {
        build(v);
    }

    void build(const vector< T > &v) {
        assert(n == (int) v.size());
        for(int k = 0; k < n; k++) data[k + sz] = v[k];
        for(int k = sz - 1; k > 0; k--) update(k);
    }

    void set(int k, const T &x) {
        k += sz;
        for(int i = height; i > 0; i--) propagate(k >> i);
        data[k] = x;
        for(int i = 1; i <= height; i++) update(k >> i);
    }

    T get(int k) {
        k += sz;
        for(int i = height; i > 0; i--) propagate(k >> i);
        return data[k];
    }

    T operator[](int k) {
        return get(k);
    }

    T prod(int l, int r) {
        if(l >= r) return ti;
        l += sz;
        r += sz;
        for(int i = height; i > 0; i--) {
            if(((l >> i) << i) != l) propagate(l >> i);
            if(((r >> i) << i) != r) propagate((r - 1) >> i);
        }
        T L = ti, R = ti;
        for(; l < r; l >>= 1, r >>= 1) {
            if(l & 1) L = f(L, data[l++]);
            if(r & 1) R = f(data[--r], R);
            }
        return f(L, R);
    }

    T all_prod() const {
        return data[1];
    }

    void apply(int k, const E &x) {
        k += sz;
        for(int i = height; i > 0; i--) propagate(k >> i);
        data[k] = g(data[k], x);
        for(int i = 1; i <= height; i++) update(k >> i);
    }

    void apply(int l, int r, const E &x) {
        if(l >= r) return;
        l += sz;
        r += sz;
        for(int i = height; i > 0; i--) {
            if(((l >> i) << i) != l) propagate(l >> i);
            if(((r >> i) << i) != r) propagate((r - 1) >> i);
        }
        {
        int l2 = l, r2 = r;
        for(; l < r; l >>= 1, r >>= 1) {
            if(l & 1) all_apply(l++, x);
            if(r & 1) all_apply(--r, x);
        }
        l = l2, r = r2;
        }
        for(int i = 1; i <= height; i++) {
            if(((l >> i) << i) != l) update(l >> i);
            if(((r >> i) << i) != r) update((r - 1) >> i);
        }
    }

    template< typename C >
    int find_first(int l, const C &check) {
        if(l >= n) return n;
        l += sz;
        for(int i = height; i > 0; i--) propagate(l >> i);
        T sum = ti;
        do {
            while((l & 1) == 0) l >>= 1;
            if(check(f(sum, data[l]))) {
                while(l < sz) {
                    propagate(l);
                    l <<= 1;
                    auto nxt = f(sum, data[l]);
                    if(not check(nxt)) {
                        sum = nxt;
                        l++;
                    }
                }
                return l + 1 - sz;
            }
            sum = f(sum, data[l++]);
        } while((l & -l) != l);
        return n;
    }

    template< typename C >
    int find_last(int r, const C &check) {
        if(r <= 0) return -1;
        r += sz;
        for(int i = height; i > 0; i--) propagate((r - 1) >> i);
        T sum = ti;
        do {
            r--;
            while(r > 1 and (r & 1)) r >>= 1;
            if(check(f(data[r], sum))) {
                while(r < sz) {
                    propagate(r);
                    r = (r << 1) + 1;
                    auto nxt = f(data[r], sum);
                    if(not check(nxt)) {
                        sum = nxt;
                        r--;
                    }
                }
                return r - sz;
            }
            sum = f(data[r], sum);
        } while((r & -r) != r);
        return -1;
    }
};

template< typename T, typename E, typename F, typename G, typename H >
LazySegmentTree< T, E, F, G, H > get_lazy_segment_tree(int N, const F &f, const G &g, const H &h, const T &ti, const E &ei) {
    return LazySegmentTree<T,E,F,G,H>{N, f, g, h, ti, ei};
}

template< typename T, typename E, typename F, typename G, typename H >
LazySegmentTree< T, E, F, G, H > get_lazy_segment_tree(const vector< T > &v, const F &f, const G &g, const H &h, const T &ti, const E &ei) {
    return LazySegmentTree<T,E,F,G,H>{v, f, g, h, ti, ei};
}

int main(){
    fastio
    //cout<<fixed<<setprecision(16);
    STR(s,t);
    vector<int> ans(4);
    
    rep(i,0,2){
    	rep(j,0,2){
    		string st;st+=s[i];st+=t[j];
    		sort(all(st));
    		if(st[0]=='A'&&st[1]!='B'){
    			ans[0]+=1;
    		}else if(st[0]=='B'){
    			ans[1]+=1;
    		}else if(st=="AB"){
    			ans[2]+=1;
    		}else{
    			ans[3]+=1;
    		}
    	}
    }
    rep(i,0,4){
    	int p=100;
    	p/=4;
    	cout<<p*ans[i]<<' ';
    }
    cout<<el;
	return 0;
}
/*

*/
yukicoder

結果

テストケース

ソースコード
