Submission #1334601

#	Time	Username	Problem	Language	Result	Execution time	Memory
1334601		shiraishi_yui00	Fancy Fence (CEOI20_fancyfence)	C++20	40 / 100	15 ms	1964 KiB

fancyfence

///Kiana Kaslana

#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#define execute cerr << "Time elapsed: " << (1.0 * clock() / CLOCKS_PER_SEC) << "s"
#define fi first
#define se second
#define el cout <<"\n"
#define pushb push_back
#define pushf push_front
#define popf pop_front
#define popb pop_back
#define MASK(x) (1 << (x))
#define BIT(x, i) ((x) >> (i) & 1)
#define io ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define Shu "FancyFence"
///
#define IloveShu signed main()
#define ShiraishiAn while(inp())
#define YoisakiKanade while(KiritaniHaruka--)
#define ever ;;

using namespace std;

typedef long long ll;
typedef double db;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef vector<vector<int>> vvi;
typedef vector<pii> vpii;
typedef vector<ll> vll;
typedef pair<ll,ll> pll;
typedef vector<vector<ll>> vvll;
typedef vector<pll> vpll;
typedef unsigned long long ull;

const int W = 1e3 + 7;
const int N = 1e6 + 7;
const int S = 1e2 + 7;
const int midd = 1e5;
const int base = 311;
const int LG = 31;
const int mod = 1e9 + 7;
const int prime_mod = 998244353;
const int ascii = 127;
const int alphabet = 26;
const int INF = 2147483647;
const long long INFLL = 4340410370284600380;

template<typename T> bool maximize(T &res, const T &val) { if (res < val){ res = val; return 1; }; return 0; }
template<typename T> bool minimize(T &res, const T &val) { if (res > val){ res = val; return 1; }; return 0; }

mt19937 rd(time(0));
ll rng(ll l , ll r)
{
    assert(l <= r);
    uniform_int_distribution<ll> d(l , r);
    return d(rd);
}

///MAIN PROGRAMME

int KiritaniHaruka = 1;

int n;
ll h[N] , w[N];

namespace sub2
{
    bool check()
    {
        if (n > 50) return false;
        for (int i = 1 ; i <= n ; ++i)
            if (h[i] > 50 || w[i] != 1) return false;
        return true;
    }

    void solve()
    {
        ll res = 0;

        for (int l = 1 ; l <= n ; ++l)
        {
            ll mn = h[l];
            for (int r = l ; r <= n ; ++r)
            {
                mn = min(mn , h[r]);
                ll add = mn * (mn + 1) / 2 % mod;
                res = (res + add) % mod;
            }
        }

        cout << res;
    }
}

namespace sub3
{
    bool check()
    {
        for (int i = 1 ; i <= n ; ++i)
            if (h[i] != 1 && h[i] != 2)
                return false;
        return true;
    }

    ll calc(ll x)
    {
        x %= mod;
        return x * (x + 1) / 2 % mod;
    }

    void solve()
    {
        ll W = 0;
        for (int i = 1 ; i <= n ; ++i) W += w[i];

        ll res = calc(W);
        ll cur = 0;

        for (int i = 1 ; i <= n ; ++i)
        {
            if (h[i] == 2) cur += w[i];
            else
            {
                res = (res + 2 * calc(cur) % mod) % mod;
                cur = 0;
            }
        }

        res = (res + 2 * calc(cur) % mod) % mod;

        cout << res % mod;
    }
}

namespace sub4
{
    bool check()
    {
        int temp = h[1];
        for (int i = 1 ; i <= n ; ++i) if (h[i] != temp) return false;
        return true;
    }

    void solve()
    {
        __int128 W = 0;
        for (int i = 1 ; i <= n ; ++i) W += w[i];

        __int128 cur = h[1];

        __int128 res = W * (W + 1) / 2 % mod;
        res = res * (cur * (cur + 1) / 2 % mod) % mod;

        cout << (ll)res;
    }
}

void solve()
{
    if (sub2::check()) sub2::solve(); else
    if (sub3::check()) sub3::solve(); else
    if (sub4::check()) sub4::solve();
}

void inp()
{
    cin >> n;
    for (int i = 1 ; i <= n ; ++i) cin >> h[i];
    for (int i = 1 ; i <= n ; ++i) cin >> w[i];
}

void file()
{
    if (fopen(Shu".inp" , "r"))
    {
        freopen(Shu".inp" , "r" , stdin);
        freopen(Shu".out" , "w" , stdout);
    }
}

IloveShu
{
    io;
    file();

    //cin >> KiritaniHaruka;

    YoisakiKanade
    {
        inp();
        solve();
    }

//    ShiraishiAn
//    {
//        solve();
//    }
}

Compilation message (stderr)

fancyfence.cpp: In function 'void file()':
fancyfence.cpp:251:16: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  251 |         freopen(Shu".inp" , "r" , stdin);
      |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
fancyfence.cpp:252:16: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  252 |         freopen(Shu".out" , "w" , stdout);
      |         ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~

• Subtask 1: 0 / 0
• Subtask 2: 12 / 12
• Subtask 3: 13 / 13
• Subtask 4: 15 / 15
• Subtask 5: 0 / 15
• Subtask 6: 0 / 18
• Subtask 7: 0 / 27