【writeup】nitac_mini_ctf、PPC問題のACコード

Pathway and Street

Bの道(コスト101333)を通りたく無い。(が、やむを得ず通らないといけない場合もある) そこで、コストを「firstをBの回数、secondをAの距離」となるpairで持つとそのままダイクストラ出来て良いです。 (段階的に渡れるBの数を増やす解法もあり得るけど面倒だと思う)

前半ライブラリ張ったので長い

#if 1
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <array>
#include <deque>
#include <algorithm>
#include <utility>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <numeric>
#include <assert.h>
#include <bitset>
#include <list>
#include <fstream>

std::ifstream in("input.txt");
auto& out = std::cout;
#define all_range(C) std::begin(C), std::end(C)
const double PI = 3.141592653589793238462643383279502884197169399375105820974944;


int32_t N,A,B;


#include <queue>
#include <vector>
#include <functional>
#include <utility>
#include <algorithm>
#include <iterator>

using COST_T = std::pair<int32_t, uint64_t>;
constexpr uint32_t N_MAX = 100000;
constexpr COST_T INF{ 1000000, 1000000000000000 };//std::numeric_limits<double>::infinity()

#if defined(_MSC_VER) && defined(_DEBUG)
//static_assert(false, "リリースでコンパイルしないと遅いよ!!");
#endif

struct edge {
    uint32_t to;
    COST_T cost;
    edge() {}
    edge(uint32_t to_, COST_T cost_)
        :to(to_), cost(cost_) {}
};
std::vector<edge> graph[N_MAX];

//ダイクストラ
COST_T D[N_MAX];
void Dijkstra(uint32_t s)
{
    using P = std::pair<COST_T, uint32_t>;//cost pos
    std::priority_queue<P, std::vector<P>, std::greater<>> que;
    std::fill(std::begin(D), std::end(D), INF);

    D[s].first = 0;
    D[s].second = 0;
    que.emplace(COST_T{ 0 ,0}, s);
    while (!que.empty())
    {
        auto p = que.top(); que.pop();
        const auto& nowpos = p.second;
        const auto& nowcost = p.first;
        if (D[nowpos] < nowcost) { continue; }

        //for (int32_t to = 0; to < N; ++to)
        //{
        // auto cost = nowcost + graph[nowpos][to];
        // if (cost < D[to]) {
        //     D[to] = cost;
        //     que.emplace(D[to], to);
        // }
        //}

        for (const auto& e : graph[nowpos])
        {
            auto cost = nowcost ;
            cost.first += e.cost.first;
            cost.second += e.cost.second;
            if (cost < D[e.to]) {
                D[e.to] = cost;
                que.emplace(cost, e.to);
            }
        }

    }
}

template<typename Arithmetic, typename Integral>
Arithmetic
ipow(Arithmetic bace, Integral n)
{
    //繰り返し二条法
    auto res = (Arithmetic)(1);
    while (n > 0) {
        if (n & 1) res *= bace;
        bace *= bace;
        n >>= 1;
    }
    return res;
}
constexpr bool is_prime(uint32_t N)
{
    if (N <= 1) {
        return false;
    }
    for (size_t i = 2; i*i <= N; ++i)
    {
        if (N%i == 0) {
            return false;
        }
    }
    return true;
}
template <uint64_t MOD> class mint_base;
//mint_base_base型用の累乗関数
template <uint64_t MOD> constexpr mint_base<MOD> m_pow(mint_base<MOD> x, uint64_t n)noexcept;
//mod計算を自動で行う整数テンプレートクラス
template <uint64_t MOD_ = 1000000007>
class mint_base
{
public:
    static constexpr auto MOD = MOD_;
    static_assert(!(MOD <= 2), "MOD cannot be below 2.");
    static_assert(MOD <= (0xFFFFFFFFFFFFFFFF / 2), "MOD is too big");//加算してオーバーフローしない
    static_assert(MOD <= 0xFFFFFFFF, "MOD is too big");//乗算してオーバーフローしない
    constexpr mint_base<MOD> operator+(const mint_base<MOD> &other)const noexcept
    {
        auto v = *this;
        return v += other;
    }
    constexpr mint_base<MOD> operator-(const mint_base<MOD> &other)const noexcept
    {
        auto v = *this;
        return v -= other;
    }
    constexpr mint_base<MOD> operator*(const mint_base<MOD> &other)const noexcept
    {
        auto v = *this;
        return v *= other;
    }
    constexpr auto operator/(const mint_base<MOD> &other)const noexcept
    {
        auto v = *this;
        return v /= other;
    }
    constexpr mint_base<MOD>& operator+=(const mint_base<MOD> &other) noexcept
    {
        a += other.a;
        if (MOD <= a) { a -= MOD; };
        return *this;
    }
    constexpr mint_base<MOD>& operator-=(const mint_base<MOD> &other) noexcept
    {
        if (a >= other.a) {
            a -= other.a;
        }
        else {
            a = (a + MOD) - other.a;
        }
        return *this;
    }
    constexpr mint_base<MOD>& operator*=(const mint_base<MOD> &other) noexcept
    {
#if 1
        a *= other.a;
        a %= MOD;
#else
       //MOD <= (MAXUINT64 / 2)条件下
       uint64_t b = other.a, v = 0;
       while (b > 0) {
           if (b & 1) {
               v += a;
               if (v >= MOD)v -= MOD;
           }
           a += a;
           if (MOD <= a)a -= MOD;
           b >>= 1;
       }
       a = v;
#endif
        return *this;
    }
    constexpr mint_base<MOD>& operator/=(const mint_base<MOD> &other) noexcept
    {
        return *this *= ~other;
    }
    constexpr mint_base<MOD> operator+()const noexcept { return *this; }
    constexpr mint_base<MOD> operator-()const noexcept
    {
        return{ MOD - a, mod_value_tag{} };
    }
    constexpr mint_base<MOD>& operator++() noexcept
    {
        if (MOD <= ++a) { a = 0; };
        return *this;
    }
    constexpr mint_base<MOD>& operator--() noexcept
    {
        if (a <= 0) { a = MOD; };
        --a;
        return *this;
    }
    constexpr mint_base<MOD> operator++(int) noexcept
    {
        auto tmp = *this;
        ++*this;
        return tmp;
    }
    constexpr mint_base<MOD> operator--(int) noexcept
    {
        auto tmp = *this;
        --*this;
        return tmp;
    }
    constexpr mint_base<MOD> operator~()const noexcept
    {
        return ipow(*this, e_phi - 1);
    }
    constexpr mint_base<MOD>& operator=(const mint_base<MOD> &other) noexcept
    {
        a = other.a;
        return *this;
    }
    constexpr explicit operator uint64_t()const noexcept
    {
        return a;
    }
    constexpr explicit operator unsigned()const noexcept
    {
        return (unsigned)a;
    }
    static constexpr uint64_t getmod() noexcept
    {
        return MOD;
    }
    constexpr mint_base(uint64_t a_) noexcept :a(a_ % MOD) {}
    constexpr mint_base()noexcept : a(0) {}
    struct mod_value_tag {};
    constexpr mint_base(uint64_t a_, mod_value_tag) :a(a_) {}
private:
    static constexpr uint64_t get_e_phi()noexcept {
        //オイラー値の導出
        uint64_t temp = MOD;
        uint64_t m_ = MOD;
        for (uint64_t i = 2; i * i <= m_; ++i)
        {
            if (m_ % i == 0)
            {
                temp = temp / i * (i - 1);
                for (; m_ % i == 0; m_ /= i);
            }
        }
        if (m_ != 1)temp = temp / m_ * (m_ - 1);
        return temp;
    }
    static constexpr uint64_t e_phi = get_e_phi();//オイラー値
    uint64_t a;
};
//mint_base型用の累乗関数
template<uint64_t MOD>constexpr mint_base<MOD> m_pow(mint_base<MOD> x, uint64_t n)noexcept
{
    mint_base<MOD> res = 1;
    while (n > 0)
    {
        if (n & 1)res *= x;
        x *= x;
        n >>= 1;
    }
    return res;
}
//mint_baseの階乗計算
//O(x)時間が必要のため、fact_set関数を推奨する。
template<uint64_t MOD>constexpr mint_base<MOD> fact(mint_base<MOD> x)noexcept
{
    mint_base<MOD> res(1);
    for (uint64_t i = 1; i <= (uint64_t)x; ++i)
    {
        res *= i;
    }
    return res;
}
//mint_baseの階乗計算
//0からxまでの階乗を返す
//O(x)時間が必要
template<uint64_t MOD>std::vector<mint_base<MOD>> fact_set(mint_base<MOD> x = mint_base<MOD>(-1))
{
    mint_base<MOD> res(1);
    std::vector<mint_base<MOD>> set((uint64_t)(x)+1);
    set[0] = 1;
    for (uint64_t i = 1; i <= (uint64_t)x; ++i)
    {
        res *= i;
        set[i] = res;
    }
    return res;
}
//mint_base型のstreamへの出力
template<uint64_t MOD> std::ostream& operator<<(std::ostream& os, mint_base<MOD> i)
{
    os << (uint64_t)i;
    return os;
}
//mint_base型のstreamからの入力
template<uint64_t MOD> std::istream& operator >> (std::istream& is, mint_base<MOD>& i)
{
    uint64_t tmp;
    is >> tmp;
    i = tmp;
    return is;
}
typedef mint_base<1000000007> mint;
namespace mint_literal {
    constexpr mint operator""_mi(unsigned long long x)noexcept {
        return mint(x);
    }
}
using namespace mint_literal;
//mint_baseの階乗計算
//0からxまでの階乗を返す
//O(N)
template<int32_t X, uint64_t MOD = mint::MOD>
/*constexpr*/ std::array<mint_base<MOD>, X + 1> fact_set_c()
{
    mint_base<MOD> res(1);
    std::array<mint_base<MOD>, X + 1> set;
    set[0] = 1;
    for (int32_t i = 1; i <= X; ++i)
    {
        res *= i;
        set[i] = res;
    }
    return set;
}
template<typename RET = mint, typename Integral>
RET combination(Integral all, Integral get)
{
    assert(all >= get);
    get = std::min(all - get, get);
#if 1
    //時間計算量O(1)+初期化O(NlogMOD)
    static_assert(false, "");
    static const auto fact_v = fact_set_c<要素数 + 1>();
    static const auto fact_div_v = [&]() {
        auto tmp = fact_v;
        for (auto& i : tmp) { i = ~i; }
        return tmp;
    }();
    //return fact_v[all] / (fact_v[get] * fact_v[all - get]);
    return fact_v[all] * fact_div_v[get] * fact_div_v[all - get];
#elif 0
   //時間計算量O(1)
   //空間計算量、初期化時間計算量O(N^2)
   constexpr int32_t ALL_MAX = 要素数;// 10'000;
   static std::vector<RET> DP_comb[ALL_MAX + 1];
   if (!DP_comb[all].empty())
   {
       return DP_comb[all][get];
   }

   if (DP_comb[0].empty())
   {
       DP_comb[0].resize(1);
       DP_comb[0][0] = (RET)1;
       DP_comb[1].resize(1);
       DP_comb[1][0] = (RET)1;
   }
   for (int32_t i = 2; i <= all; i++)
   {
       if (DP_comb[i].empty())
       {
           int32_t size = i / 2 + 1;
           DP_comb[i].resize(size);
           DP_comb[i][0] = (RET)1;
           for (int32_t j = 1; j < size - 1; j++)
           {
               DP_comb[i][j] = DP_comb[i - 1][j - 1] + DP_comb[i - 1][j];
           }
           DP_comb[i][size - 1] = DP_comb[i - 1][size - 2] + DP_comb[i - 1][(i & 1) ? (size - 1) : (size - 2)];
       }
   }
   return DP_comb[all][get];
#else
   //時間計算量O(get * logMOD)
   RET ret = (RET)1;
   for (Integral i = 1; i <= get; ++i)
   {
       ret *= all + 1 - i;
       ret /= i;
   }
   return ret;
#endif
}

int main()
{
    using std::endl;
    in.sync_with_stdio(false);
    out.sync_with_stdio(false);
    in.tie(nullptr);
    out.tie(nullptr);

    in >> N>>A>>B;

    for (int32_t i = 0; i < A; i++)
    {
        int64_t a, b, c;
        in >> a >> b >> c; --a; --b;
        graph[a].emplace_back((int32_t)b, COST_T{ 0, (uint64_t)c });
        graph[b].emplace_back((int32_t)a, COST_T{ 0, c });
    }
    for (int32_t i = 0; i < B; i++)
    {
        int64_t a, b;
        in >> a >> b; --a; --b;
        graph[a].emplace_back(b, COST_T{ 1, 0 });
        graph[b].emplace_back(a, COST_T{ 1, 0 });
    }

    Dijkstra(0);

    mint b = 10;
    b = ipow(b, 1333);

    mint sum = 0;
    for (size_t i = 0; i < N; i++)
    {
        sum += mint(D[i].first)*b + D[i].second;
    }

    out << sum << endl;




    return 0;
}
#endif

scramble

相変わらず前半ライブラリのみです。 部分文字列の接頭文字列の個数を貪欲に数えたら何故か通ってしまった。(証明してない)

#if 1
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <array>
#include <deque>
#include <algorithm>
#include <utility>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <numeric>
#include <assert.h>
#include <bitset>
#include <list>

std::ifstream in("input.txt");
auto& out = std::cout;
#define all_range(C) std::begin(C), std::end(C)
const double PI = 3.141592653589793238462643383279502884197169399375105820974944;

template<typename Arithmetic, typename Integral>
std::enable_if_t< std::is_unsigned<Integral>::value, Arithmetic>
ipow(Arithmetic bace, Integral n)
{
    //繰り返し二条法
    auto res = (Arithmetic)(1);
    while (n > 0) {
        if (n & 1) res *= bace;
        bace *= bace;
        n >>= 1;
    }
    return res;
}
constexpr bool is_prime(uint32_t N)
{
    if (N <= 1) {
        return false;
    }
    for (size_t i = 2; i*i <= N; ++i)
    {
        if (N%i == 0) {
            return false;
        }
    }
    return true;
}
template <uint64_t MOD> class mint_base;
//mint_base_base型用の累乗関数
template <uint64_t MOD> constexpr mint_base<MOD> m_pow(mint_base<MOD> x, uint64_t n)noexcept;
//mod計算を自動で行う整数テンプレートクラス
template <uint64_t MOD_ = 1000000007>
class mint_base
{
public:
    static constexpr auto MOD = MOD_;
    static_assert(!(MOD <= 2), "MOD cannot be below 2.");
    static_assert(MOD <= (0xFFFFFFFFFFFFFFFF / 2), "MOD is too big");//加算してオーバーフローしない
    static_assert(MOD <= 0xFFFFFFFF, "MOD is too big");//乗算してオーバーフローしない
    constexpr mint_base<MOD> operator+(const mint_base<MOD> &other)const noexcept
    {
        auto v = *this;
        return v += other;
    }
    constexpr mint_base<MOD> operator-(const mint_base<MOD> &other)const noexcept
    {
        auto v = *this;
        return v -= other;
    }
    constexpr mint_base<MOD> operator*(const mint_base<MOD> &other)const noexcept
    {
        auto v = *this;
        return v *= other;
    }
    constexpr auto operator/(const mint_base<MOD> &other)const noexcept
    {
        auto v = *this;
        return v /= other;
    }
    constexpr mint_base<MOD>& operator+=(const mint_base<MOD> &other) noexcept
    {
        a += other.a;
        if (MOD <= a) { a -= MOD; };
        return *this;
    }
    constexpr mint_base<MOD>& operator-=(const mint_base<MOD> &other) noexcept
    {
        if (a >= other.a) {
            a -= other.a;
        }
        else {
            a = (a + MOD) - other.a;
        }
        return *this;
    }
    constexpr mint_base<MOD>& operator*=(const mint_base<MOD> &other) noexcept
    {
#if 1
        a *= other.a;
        a %= MOD;
#else
       //MOD <= (MAXUINT64 / 2)条件下
       uint64_t b = other.a, v = 0;
       while (b > 0) {
           if (b & 1) {
               v += a;
               if (v >= MOD)v -= MOD;
           }
           a += a;
           if (MOD <= a)a -= MOD;
           b >>= 1;
       }
       a = v;
#endif
        return *this;
    }
    constexpr mint_base<MOD>& operator/=(const mint_base<MOD> &other) noexcept
    {
        return *this *= ~other;
    }
    constexpr mint_base<MOD> operator+()const noexcept { return *this; }
    constexpr mint_base<MOD> operator-()const noexcept
    {
        return{ MOD - a, mod_value_tag{} };
    }
    constexpr mint_base<MOD>& operator++() noexcept
    {
        if (MOD <= ++a) { a = 0; };
        return *this;
    }
    constexpr mint_base<MOD>& operator--() noexcept
    {
        if (a <= 0) { a = MOD; };
        --a;
        return *this;
    }
    constexpr mint_base<MOD> operator++(int) noexcept
    {
        auto tmp = *this;
        ++*this;
        return tmp;
    }
    constexpr mint_base<MOD> operator--(int) noexcept
    {
        auto tmp = *this;
        --*this;
        return tmp;
    }
    constexpr mint_base<MOD> operator~()const noexcept
    {
        return ipow(*this, e_phi - 1);
    }
    constexpr mint_base<MOD>& operator=(const mint_base<MOD> &other) noexcept
    {
        a = other.a;
        return *this;
    }
    constexpr explicit operator uint64_t()const noexcept
    {
        return a;
    }
    constexpr explicit operator unsigned()const noexcept
    {
        return (unsigned)a;
    }
    static constexpr uint64_t getmod() noexcept
    {
        return MOD;
    }
    constexpr mint_base(uint64_t a_) noexcept :a(a_ % MOD) {}
    constexpr mint_base()noexcept : a(0) {}
    struct mod_value_tag {};
    constexpr mint_base(uint64_t a_, mod_value_tag) :a(a_) {}
private:
    static constexpr uint64_t get_e_phi()noexcept {
        //オイラー値の導出
        uint64_t temp = MOD;
        uint64_t m_ = MOD;
        for (uint64_t i = 2; i * i <= m_; ++i)
        {
            if (m_ % i == 0)
            {
                temp = temp / i * (i - 1);
                for (; m_ % i == 0; m_ /= i);
            }
        }
        if (m_ != 1)temp = temp / m_ * (m_ - 1);
        return temp;
    }
    static constexpr uint64_t e_phi = get_e_phi();//オイラー値
    uint64_t a;
};
//mint_base型用の累乗関数
template<uint64_t MOD>constexpr mint_base<MOD> m_pow(mint_base<MOD> x, uint64_t n)noexcept
{
    mint_base<MOD> res = 1;
    while (n > 0)
    {
        if (n & 1)res *= x;
        x *= x;
        n >>= 1;
    }
    return res;
}
//mint_baseの階乗計算
//O(x)時間が必要のため、fact_set関数を推奨する。
template<uint64_t MOD>constexpr mint_base<MOD> fact(mint_base<MOD> x)noexcept
{
    mint_base<MOD> res(1);
    for (uint64_t i = 1; i <= (uint64_t)x; ++i)
    {
        res *= i;
    }
    return res;
}
//mint_baseの階乗計算
//0からxまでの階乗を返す
//O(x)時間が必要
template<uint64_t MOD>std::vector<mint_base<MOD>> fact_set(mint_base<MOD> x = mint_base<MOD>(-1))
{
    mint_base<MOD> res(1);
    std::vector<mint_base<MOD>> set((uint64_t)(x)+1);
    set[0] = 1;
    for (uint64_t i = 1; i <= (uint64_t)x; ++i)
    {
        res *= i;
        set[i] = res;
    }
    return res;
}
//mint_base型のstreamへの出力
template<uint64_t MOD> std::ostream& operator<<(std::ostream& os, mint_base<MOD> i)
{
    os << (uint64_t)i;
    return os;
}
//mint_base型のstreamからの入力
template<uint64_t MOD> std::istream& operator >> (std::istream& is, mint_base<MOD>& i)
{
    uint64_t tmp;
    is >> tmp;
    i = tmp;
    return is;
}
typedef mint_base<1000000007> mint;
namespace mint_literal {
    constexpr mint operator""_mi(unsigned long long x)noexcept {
        return mint(x);
    }
}
using namespace mint_literal;
//mint_baseの階乗計算
//0からxまでの階乗を返す
//O(N)
template<int32_t X, uint64_t MOD = mint::MOD>
/*constexpr*/ std::array<mint_base<MOD>, X + 1> fact_set_c()
{
    mint_base<MOD> res(1);
    std::array<mint_base<MOD>, X + 1> set;
    set[0] = 1;
    for (int32_t i = 1; i <= X; ++i)
    {
        res *= i;
        set[i] = res;
    }
    return set;
}
template<typename RET = mint, typename Integral>
RET combination(Integral all, Integral get)
{
    assert(all >= get);
    get = std::min(all - get, get);
#if 1
    //時間計算量O(1)+初期化O(NlogMOD)
    static_assert(false, "");
    static const auto fact_v = fact_set_c<要素数 + 1>();
    static const auto fact_div_v = [&]() {
        auto tmp = fact_v;
        for (auto& i : tmp) { i = ~i; }
        return tmp;
    }();
    //return fact_v[all] / (fact_v[get] * fact_v[all - get]);
    return fact_v[all] * fact_div_v[get] * fact_div_v[all - get];
#elif 0
   //時間計算量O(1)
   //空間計算量、初期化時間計算量O(N^2)
   constexpr int32_t ALL_MAX = 要素数;// 10'000;
   static std::vector<RET> DP_comb[ALL_MAX + 1];
   if (!DP_comb[all].empty())
   {
       return DP_comb[all][get];
   }

   if (DP_comb[0].empty())
   {
       DP_comb[0].resize(1);
       DP_comb[0][0] = (RET)1;
       DP_comb[1].resize(1);
       DP_comb[1][0] = (RET)1;
   }
   for (int32_t i = 2; i <= all; i++)
   {
       if (DP_comb[i].empty())
       {
           int32_t size = i / 2 + 1;
           DP_comb[i].resize(size);
           DP_comb[i][0] = (RET)1;
           for (int32_t j = 1; j < size - 1; j++)
           {
               DP_comb[i][j] = DP_comb[i - 1][j - 1] + DP_comb[i - 1][j];
           }
           DP_comb[i][size - 1] = DP_comb[i - 1][size - 2] + DP_comb[i - 1][(i & 1) ? (size - 1) : (size - 2)];
       }
   }
   return DP_comb[all][get];
#else
   //時間計算量O(get * logMOD)
   RET ret = (RET)1;
   for (Integral i = 1; i <= get; ++i)
   {
       ret *= all + 1 - i;
       ret /= i;
   }
   return ret;
#endif
}

int32_t num[256][100010];
std::string s;

int main()
{
    using std::endl;
    in.sync_with_stdio(false);
    out.sync_with_stdio(false);
    in.tie(nullptr);
    out.tie(nullptr);

    in >> s;
    //for (size_t i = 0; i < s.size(); i++)
    //{
    // num[s[i]][i+1]++;
    //}
    //for (size_t i = 0; i < 256; i++)
    //{
    // for (size_t j = 1; j <= 100000; j++)
    // {
    //     num[i][j] += num[i][j-1];
    // }
    //}

    mint m = 0;
    mint mi = 0;
    mint min = 0;
    mint mini = 0;
    mint minic = 0;
    mint minict = 0;
    mint minictf = 0;

    for (size_t i = 0; i < s.size(); i++)
    {
        if (s[i] == 'm') {
            m += 1;
        }
        if (s[i] == 'i') {
            mi += m;
            mini += min;
        }
        if (s[i] == 'n') {
            min += mi;
        }
        if (s[i] == 'c') {
            minic += mini;
        }
        if (s[i] == 't') {
            minict += minic;
        }
        if (s[i] == 'f') {
            minictf += minict;
        }
    }
    out << minictf << endl;

    return 0;
}
#endif