結果

問題 No.1807 UMA Gacha
ユーザー YoureinYourein
提出日時 2022-01-14 21:41:54
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 3 ms / 2,000 ms
コード長 7,488 bytes
コンパイル時間 1,213 ms
コンパイル使用メモリ 121,632 KB
実行使用メモリ 5,248 KB
最終ジャッジ日時 2024-11-20 08:50:34
合計ジャッジ時間 2,255 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 2 ms
5,248 KB
testcase_02 AC 3 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 AC 2 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
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <iostream>
#include <cmath>
#include <cassert>
#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <stack>
using namespace std;
using ll = long long;
using ld = long double;
using i32 = int32_t;
using i64 = int64_t;

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 yes(){
        cout << "Yes\n";
    }

    void no(){
        cout << "No\n";
    }
}

namespace cpmath{
    //Math library for Competitive-Programming
    constexpr ll mod97 = 1000000007;
    constexpr ll mod99 = 1000000009;
    constexpr ll mod89 = 998244353;
    constexpr 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};

    //Calculate n! in mod (fmod)
    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;
    }

    //Calculate m^p
    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);
    }

    //Calculate m^p in mod (fmod)
    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;
    }

    //Angle convert
    long double dtor(const long double deg){return deg*(pi/(ld)180);}
    long double rtod(const long double rad){return rad*(ld)180/pi;}
    //Angle convert

    //modint a(integer < 10**18, mod, (bool)Is number for mod prime?)
    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; //Declaration of inputclass
using cpio::yes;
using cpio::no;
using cpio::dout;
using cpio::input;
using cpmath::mod89;
using cpmath::mod97;
using cpmath::mod99;
using cpmath::modint;

//For Grid serching

//using cpmath::DX4;
//using cpmath::DY4;
//using cpmath::DX8;
//using cpmath::DY8;

//For Grid serching


int main(){
    int n = in();
    ld p = in();

    if (n >= 200) cout << 1 << endl;
    else{
        ld ans = p;

        for (int i = 0; i < n-1; i++){
            ans += (1.00-ans)*p;
        }

        cout << fixed << setprecision(15) << ans << endl;
    }
}
0