結果

問題 No.2397 ω冪
ユーザー hotman78hotman78
提出日時 2023-07-28 22:57:33
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
WA  
実行時間 -
コード長 10,315 bytes
コンパイル時間 4,266 ms
コンパイル使用メモリ 249,968 KB
実行使用メモリ 10,496 KB
最終ジャッジ日時 2024-10-06 20:46:15
合計ジャッジ時間 9,004 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
10,496 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 2 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 WA -
testcase_22 AC 2 ms
5,248 KB
testcase_23 WA -
testcase_24 WA -
testcase_25 AC 2 ms
5,248 KB
testcase_26 WA -
testcase_27 AC 3 ms
5,248 KB
testcase_28 AC 458 ms
5,248 KB
testcase_29 AC 41 ms
5,248 KB
testcase_30 TLE -
testcase_31 -- -
testcase_32 -- -
testcase_33 -- -
testcase_34 -- -
testcase_35 -- -
testcase_36 -- -
testcase_37 -- -
testcase_38 -- -
testcase_39 -- -
testcase_40 -- -
権限があれば一括ダウンロードができます

ソースコード

diff # 

// author: hotman78
// date: 2023/07/28-22:57:28

// --- begin raw code -----------------
// #include"cpplib/util/template.hpp"
// 
// // カントールの標準形に直す
// struct tree{
//     vector<tree>v;
//     tree(){
//     }
//     tree operator+(const tree& b)const{
//         tree res;
//         for(auto c:v){
//             if(!b.v.empty()&&c<b.v[0])break;
//             res.v.emplace_back(c);
//         }
//         for(auto c:b.v){
//             res.v.emplace_back(c);
//         }
//         sort(res.v.begin(),res.v.end());
//         reverse(res.v.begin(),res.v.end());
//         return res;
//     }
//     // tree mul_omega()const{
//     //     if(v.size()==0){
//     //         return tree();
//     //     }
//     //     tree res=*this;
//     //     tree one;
//     //     one.v.emplace_back(tree());
//     //     reverse(res.v.begin(),res.v.end());
//     //     while(res.v.size()>=2&&res.v[res.v.size()-2]==res.v[res.v.size()-1]){
//     //         res.v.erase(res.v.end()-2);
//     //     }
//     //     reverse(res.v.begin(),res.v.end());
//     //     res.v[0]=move(res.v[0])+one;
//     //     return res;
//     // }
//     tree exp(){
//         tree res=tree();
//         res.v.emplace_back(*this);
//         return res;
//     }
//     // omega^a を左からかける
//     tree mul_omega(const tree& a)const{
//         tree res=*this;
//         for(auto& c:res.v){
//             c=a+move(c);
//         }
//         return res;
//     }
//     void print(string s=""){
//         for(auto e:v){
//             cerr<<s+"-"<<endl;
//             e.print(s+"    ");
//         }
//     }
//     bool operator==(const tree&b)const{
//         return v==b.v;
//     }
//     bool operator<(const tree&b)const{
//         return v<b.v;
//     }
// };
// 
// // (a|b) = (exp(Σa))(Σexp(b))
// 
// tree get_tree(string n){
//     // cerr<<n<<endl;
//     if(n=="0"||n=="")return tree();
//     int b=0;
//     while(n.size()>=2&&n.back()=='0'){
//         n.pop_back();
//         b++;
//     }
//     n.pop_back();
//     string ast=n;
//     string bst=(b==0?"0":"1");
//     if(b)b--;
//     while(b--){
//         bst+='0';
//     }
//     auto omegab=tree();
//     omegab.v.emplace_back(get_tree(bst));
//     return get_tree(ast)+omegab;
// }
// int main(){
//     string n,m;
//     cin>>n>>m;
//     cout<< (get_tree(n)<get_tree(m)?"Yes":"No") <<endl;
// }
// --- end raw code -----------------

#line 2 "cpplib/util/template.hpp"
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
#include <bits/stdc++.h>
using namespace std;
#line 1 "cpplib/util/ioutil.hpp"
// template <class Head,class... Args>
// std::ostream& output(std::ostream& out,const Head& head,const Args&... args){
//     out>>head;
//     return output(head,args...);
// }
// template <class Head>
// std::ostream& output(std::ostream& out,const Head& head){
//     out>>head;
//     return out;
// }

template <typename T, typename E>
std::ostream &operator<<(std::ostream &out, std::pair<T, E> v) {
    out << "(" << v.first << "," << v.second << ")";
    return out;
}

// template <class... Args>
// ostream& operator<<(ostream& out,std::tuple<Args...>v){
//     std::apply(output,v);
//     return out;
// }
#line 8 "cpplib/util/template.hpp"
struct __INIT__ {
    __INIT__() {
        cin.tie(0);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(15);
    }
} __INIT__;
typedef long long lint;
constexpr long long INF = 1LL << 60;
constexpr int IINF = 1 << 30;
constexpr double EPS = 1e-10;
#ifndef REACTIVE
#define endl '\n';
#endif
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
template <typename T> inline void output(T t) {
    bool f = 0;
    for (auto i : t) {
        cout << (f ? " " : "") << i;
        f = 1;
    }
    cout << endl;
}
template <typename T> inline void output2(T t) {
    for (auto i : t)
        output(i);
}
template <typename T> inline void debug(T t) {
    bool f = 0;
    for (auto i : t) {
        cerr << (f ? " " : "") << i;
        f = 1;
    }
    cerr << endl;
}
template <typename T> inline void debug2(T t) {
    for (auto i : t)
        debug(i);
}
#define loop(n) for (long long _ = 0; _ < (long long)(n); ++_)
#define _overload4(_1, _2, _3, _4, name, ...) name
#define __rep(i, a) repi(i, 0, a, 1)
#define _rep(i, a, b) repi(i, a, b, 1)
#define repi(i, a, b, c)                                                       \
    for (long long i = (long long)(a); i < (long long)(b); i += c)
#define rep(...) _overload4(__VA_ARGS__, repi, _rep, __rep)(__VA_ARGS__)
#define _overload3_rev(_1, _2, _3, name, ...) name
#define _rep_rev(i, a) repi_rev(i, 0, a)
#define repi_rev(i, a, b)                                                      \
    for (long long i = (long long)(b)-1; i >= (long long)(a); --i)
#define rrep(...) _overload3_rev(__VA_ARGS__, repi_rev, _rep_rev)(__VA_ARGS__)

#define all(n) begin(n), end(n)
template <typename T, typename E> bool chmin(T &s, const E &t) {
    bool res = s > t;
    s = min<T>(s, t);
    return res;
}
template <typename T, typename E> bool chmax(T &s, const E &t) {
    bool res = s < t;
    s = max<T>(s, t);
    return res;
}
const vector<lint> dx = {1, 0, -1, 0, 1, 1, -1, -1};
const vector<lint> dy = {0, 1, 0, -1, 1, -1, 1, -1};
#define SUM(v) accumulate(all(v), 0LL)
#if __cplusplus >= 201703L
template <typename T, typename... Args>
auto make_vector(T x, int arg, Args... args) {
    if constexpr (sizeof...(args) == 0)
        return vector<T>(arg, x);
    else
        return vector(arg, make_vector<T>(x, args...));
}
#endif
#define extrep(v, ...) for (auto v : __MAKE_MAT__({__VA_ARGS__}))
#define bit(n, a) ((n >> a) & 1)
vector<vector<long long>> __MAKE_MAT__(vector<long long> v) {
    if (v.empty())
        return vector<vector<long long>>(1, vector<long long>());
    long long n = v.back();
    v.pop_back();
    vector<vector<long long>> ret;
    vector<vector<long long>> tmp = __MAKE_MAT__(v);
    for (auto e : tmp)
        for (long long i = 0; i < n; ++i) {
            ret.push_back(e);
            ret.back().push_back(i);
        }
    return ret;
}
using graph = vector<vector<int>>;
template <typename T> using graph_w = vector<vector<pair<int, T>>>;

#if __cplusplus >= 201703L
constexpr inline long long powll(long long a, long long b) {
    long long res = 1;
    while (b--)
        res *= a;
    return res;
}
#endif

template <typename T, typename E>
pair<T, E> &operator+=(pair<T, E> &s, const pair<T, E> &t) {
    s.first += t.first;
    s.second += t.second;
    return s;
}
template <typename T, typename E>
pair<T, E> &operator-=(pair<T, E> &s, const pair<T, E> &t) {
    s.first -= t.first;
    s.second -= t.second;
    return s;
}
template <typename T, typename E>
pair<T, E> operator+(const pair<T, E> &s, const pair<T, E> &t) {
    auto res = s;
    return res += t;
}
template <typename T, typename E>
pair<T, E> operator-(const pair<T, E> &s, const pair<T, E> &t) {
    auto res = s;
    return res -= t;
}
#define BEGIN_STACK_EXTEND(size)                                               \
    void *stack_extend_memory_ = malloc(size);                                 \
    void *stack_extend_origin_memory_;                                         \
    char *stack_extend_dummy_memory_ = (char *)alloca(                         \
        (1 + (int)(((long long)stack_extend_memory_) & 127)) * 16);            \
    *stack_extend_dummy_memory_ = 0;                                           \
    asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp"                          \
                 : "=b"(stack_extend_origin_memory_)                           \
                 : "a"((char *)stack_extend_memory_ + (size)-1024));
#define END_STACK_EXTEND                                                       \
    asm volatile("mov %%rax, %%rsp" ::"a"(stack_extend_origin_memory_));       \
    free(stack_extend_memory_);
#line 2 "main.cpp"

// カントールの標準形に直す
struct tree {
    vector<tree> v;
    tree() {}
    tree operator+(const tree &b) const {
        tree res;
        for (auto c : v) {
            if (!b.v.empty() && c < b.v[0])
                break;
            res.v.emplace_back(c);
        }
        for (auto c : b.v) {
            res.v.emplace_back(c);
        }
        sort(res.v.begin(), res.v.end());
        reverse(res.v.begin(), res.v.end());
        return res;
    }
    // tree mul_omega()const{
    //     if(v.size()==0){
    //         return tree();
    //     }
    //     tree res=*this;
    //     tree one;
    //     one.v.emplace_back(tree());
    //     reverse(res.v.begin(),res.v.end());
    //     while(res.v.size()>=2&&res.v[res.v.size()-2]==res.v[res.v.size()-1]){
    //         res.v.erase(res.v.end()-2);
    //     }
    //     reverse(res.v.begin(),res.v.end());
    //     res.v[0]=move(res.v[0])+one;
    //     return res;
    // }
    tree exp() {
        tree res = tree();
        res.v.emplace_back(*this);
        return res;
    }
    // omega^a を左からかける
    tree mul_omega(const tree &a) const {
        tree res = *this;
        for (auto &c : res.v) {
            c = a + move(c);
        }
        return res;
    }
    void print(string s = "") {
        for (auto e : v) {
            cerr << s + "-" << endl;
            e.print(s + "    ");
        }
    }
    bool operator==(const tree &b) const { return v == b.v; }
    bool operator<(const tree &b) const { return v < b.v; }
};

// (a|b) = (exp(Σa))(Σexp(b))

tree get_tree(string n) {
    // cerr<<n<<endl;
    if (n == "0" || n == "")
        return tree();
    int b = 0;
    while (n.size() >= 2 && n.back() == '0') {
        n.pop_back();
        b++;
    }
    n.pop_back();
    string ast = n;
    string bst = (b == 0 ? "0" : "1");
    if (b)
        b--;
    while (b--) {
        bst += '0';
    }
    auto omegab = tree();
    omegab.v.emplace_back(get_tree(bst));
    return get_tree(ast) + omegab;
}
int main() {
    string n, m;
    cin >> n >> m;
    cout << (get_tree(n) < get_tree(m) ? "Yes" : "No") << endl;
}
0