Submission #849966

#	Time	Username	Problem	Language	Result	Execution time	Memory
849966		fanwen	Skyscraper (JOI16_skyscraper)	C++17	100 / 100	126 ms	130536 KiB

skyscraper

#include <bits/stdc++.h>

using namespace std;

#define MASK(x) (1LL << (x))
#define BIT(x, i) (((x) >> (i)) & 1)
#define ALL(x) (x).begin(), (x).end()
#define REP(i, n) for (int i = 0, _n = n; i < _n; ++i)
#define FOR(i, a, b) for (int i = (a), _b = (b); i <= _b; ++i)
#define FORD(i, a, b) for (int i = (a), _b = (b); i >= _b; --i)
#define FORE(i, a, b) for (int i = (a), _b = (b); i < _b; ++i)
#define debug(...) "[" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
#define file(name) if (fopen(name".inp", "r")) { freopen(name".inp", "r", stdin); freopen(name".out", "w", stdout); }

template <class A, class B> bool minimize(A &a, B b)  { if (a > b) { a = b; return true; } return false; }
template <class A, class B> bool maximize(A &a, B b)  { if (a < b) { a = b; return true; } return false; }

template <int Mod> 
struct Modular {
private :
    int val;
    static int inverse(int a, int b) {
        a %= b;
        assert(a);
        if(a == 1) return 1;
        return int(b - (long long) inverse(b, a) * (long long) b / a);
    }
public :
    Modular(long long x = 0) : val(x % Mod) { if(val < 0) val += Mod; }

    friend bool operator == (const Modular &a, const Modular &b) { return a.val == b.val; }
    friend bool operator != (const Modular &a, const Modular &b) { return a.val != b.val; }

    Modular& operator = (const long long &x) { val = x % Mod; if(val < 0) val += Mod; return *this; }
    Modular& operator = (const Modular &x) { val = x.val; return *this; }

    friend istream & operator >> (istream &in, Modular &a) { long long x; in >> x; a = Modular(x); return in; }
    friend ostream & operator << (ostream &out, const Modular &a) { return out << a.val; }

    explicit operator int() const { return val; }
    explicit operator bool() const { return val > 0; }

    Modular inv() const {
        Modular res;
        res.val = inverse(val, Mod);
        return res;
    }

    Modular operator ++() { (*this) += 1; return *this; }
    Modular operator --() { (*this) -= 1; return *this; }
    Modular operator ++(int) { (*this) += 1; return *this - 1; }
    Modular operator --(int) { (*this) -= 1; return *this + 1; }

    Modular operator + () const { return *this; }
    Modular operator - () const {
        Modular res;
        res.val = (val ? Mod - val : 0);
        return res;
    }

    Modular& operator += (const Modular &a) {
        val += a.val;
        if(val >= Mod) val -= Mod;
        return *this;
    }
    Modular& operator -= (const Modular &a) {
        val -= a.val;
        if(val < 0) val += Mod;
        return *this;
    }
    Modular& operator *= (const Modular &a) {
        val = 1LL * val * a.val % Mod;
        return *this;
    }
    Modular& operator /= (const Modular &a) {
        (*this) *= a.inv();
        return *this;
    }
    
    friend Modular operator + (const Modular &a, const Modular &b) { return Modular(a) += b; }
    friend Modular operator - (const Modular &a, const Modular &b) { return Modular(a) -= b; }
    friend Modular operator * (const Modular &a, const Modular &b) { return Modular(a) *= b; }
    friend Modular operator / (const Modular &a, const Modular &b) { return Modular(a) /= b; }

    friend Modular operator + (const long long &a, const Modular &b) { return Modular(a) += b; }
    friend Modular operator - (const long long &a, const Modular &b) { return Modular(a) -= b; }
    friend Modular operator * (const long long &a, const Modular &b) { return Modular(a) *= b; }
    friend Modular operator / (const long long &a, const Modular &b) { return Modular(a) /= b; }

    friend Modular operator + (const Modular &a, const long long &b) { return Modular(a) += b; }
    friend Modular operator - (const Modular &a, const long long &b) { return Modular(a) -= b; }
    friend Modular operator * (const Modular &a, const long long &b) { return Modular(a) *= b; }
    friend Modular operator / (const Modular &a, const long long &b) { return Modular(a) /= b; }

};

// const int Mod = 998244353;
// const int Mod = 1e9 + 9; // 1000000009 
const int Mod = 1e9 + 7; // 1000000007

using Modint = Modular <Mod>;

template <class T> T pow(T a, long long b) {
    T ans = 1, mul = a;
    for (; b; b >>= 1) {
        if(b & 1LL) ans *= mul;
        mul *= mul;
    }
    return ans;
}

const int MAXN = 105, MAXL = 1005;

int N, L, a[MAXN];
Modint dp[MAXN][MAXN][MAXL][3];

void you_make_it(void) {
    cin >> N >> L;
    FOR(i, 1, N) cin >> a[i];
    sort(a + 1, a + N + 1);
    if(N == 1) {
    	cout << 1;
    	return;
    }
    dp[1][1][0][0] = 1;
    dp[1][1][0][1] = 2;
    FOR(i, 2, N) FORE(j, 1, i) FOR(cost, 0, L) FOR(e, 0, 2) {
    	int new_cost = cost + (a[i] - a[i - 1]) * (2 * j - e);
    	if(new_cost > L) continue;

    	dp[i][j + 1][new_cost][e] += dp[i - 1][j][cost][e] * (j + 1 - e);
    	if(e < 2) {
    		dp[i][j + 1][new_cost][e + 1] += dp[i - 1][j][cost][e] * (2 - e);
    		dp[i][j][new_cost][e + 1] += dp[i - 1][j][cost][e] * (2 - e);
    	}
    	dp[i][j][new_cost][e] += dp[i - 1][j][cost][e] * (2 * j - e);
    	dp[i][j - 1][new_cost][e] += dp[i - 1][j][cost][e] * (j - 1);
    }
    Modint ans = 0;
    FOR(i, 0, L) ans += dp[N][1][i][2];
    cout << ans;
}

signed main() {

#ifdef LOCAL
    freopen("TASK.inp", "r", stdin);
    freopen("TASK.out", "w", stdout);
#endif
    auto start_time = chrono::steady_clock::now();

    cin.tie(0), cout.tie(0) -> sync_with_stdio(0);

    you_make_it();

    auto end_time = chrono::steady_clock::now();

    cerr << "\nExecution time : " << chrono::duration_cast <chrono::milliseconds> (end_time - start_time).count() << "[ms]" << endl;

    return (0 ^ 0);
}

// Dream it. Wish it. Do it.

• Subtask 1: 5 / 5
• Subtask 2: 15 / 15
• Subtask 3: 80 / 80