oj.uz

Submission #1079251

# Submission time Handle Problem Language Result Execution time Memory
1079251 2024-08-28T12:21:25 Z boris_mihov Skyscraper (JOI16_skyscraper) C++17
20 / 100
 2000 ms 185172 KB 
#include <unordered_map>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <cassert>
#include <vector>

typedef long long llong;
const int MAXN = 100 + 10;
const int MAXL = 1000 + 10;
const int MOD  = 1e9 + 7;

int n, l;
int a[MAXN];
int prefix[MAXN];
std::unordered_map <int,int> dp[MAXN][MAXN][2][2];

int f(int idx, int count, int sum, bool foundB, bool foundE)
{   
    if (idx == n + 1)
    {
        if (!foundB || !foundE) return 0;
        return (count == 1 && sum <= l);
    }

    int len = count - 1;
    if (idx + len - 1 > n || sum + (prefix[idx + len - 1] - prefix[idx - 1]) > l)
    {
        return 0;
    }

    if (dp[idx][count][foundB][foundE].count(sum))
    {
        return dp[idx][count][foundB][foundE][sum];
    }

    llong res = f(idx + 1, count + 1, sum - 2 * a[idx], foundB, foundE);
    if (!foundB)
    {
        res += f(idx + 1, count + 1, sum - a[idx], 1, foundE);
    }

    if (!foundE)
    {
        res += f(idx + 1, count + 1, sum - a[idx], foundB, 1);
    }

    if (count >= 1) 
    {
        res += (2LL * count - foundB - foundE) * f(idx + 1, count, sum, foundB, foundE);
        if (!foundB)
        {
            res += (count - foundE) * f(idx + 1, count, sum + a[idx], 1, foundE);
            if (foundE && count == 1 && idx == n)
            {
                res += f(idx + 1, count, sum + a[idx], 1, foundE);
            }
        }

        if (!foundE)
        {
            res += (count - foundB) * f(idx + 1, count, sum + a[idx], foundB, 1);
            if (foundB && count == 1 && idx == n)
            {
                res += f(idx + 1, count, sum + a[idx], foundB, 1);
            }
        }
    }

    if (count >= 2) 
    {
        int cntFree = count - foundB - foundE;
        res += 1LL * cntFree * (cntFree - 1) * f(idx + 1, count - 1, sum + 2 * a[idx], foundB, foundE);

        if (foundB)
        {
            res += 1LL * (count - 1 - foundE) * f(idx + 1, count - 1, sum + 2 * a[idx], foundB, foundE);
        }

        if (foundE)
        {
            res += 1LL * (count - 1 - foundB) * f(idx + 1, count - 1, sum + 2 * a[idx], foundB, foundE);
        }

        if (foundB && foundE && idx == n)
        {
            res += f(idx + 1, count - 1, sum + 2 * a[idx], foundB, foundE);
        }
    }

    return dp[idx][count][foundB][foundE][sum] = res % MOD;
}

void solve()
{
    if (n == 1)
    {
        std::cout << 1 << '\n';
        return;
    }

    std::sort(a + 1, a + 1 + n);
    for (int i = 1 ; i <= n ; ++i)
    {
        prefix[i] = prefix[i - 1] + a[i];
    }

    std::cout << f(1, 0, 0, 0, 0) << '\n';
}

void input()
{
    std::cin >> n >> l;
    for (int i = 1 ; i <= n ; ++i)
    {
        std::cin >> a[i];
    }
}

void fastIOI()
{
    std::ios_base:: sync_with_stdio(0);
    std::cout.tie(nullptr);
    std::cin.tie(nullptr);
}

int main()
{
    fastIOI();
    input();
    solve();

    return 0;
}

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 2908 KB Output is correct
2 Correct 2 ms 2908 KB Output is correct
3 Correct 1 ms 2908 KB Output is correct
4 Correct 2 ms 2908 KB Output is correct
5 Correct 2 ms 3164 KB Output is correct
6 Correct 2 ms 3160 KB Output is correct
7 Correct 2 ms 3164 KB Output is correct
8 Correct 2 ms 2908 KB Output is correct
9 Correct 2 ms 3164 KB Output is correct
10 Correct 2 ms 3160 KB Output is correct

Subtask #2
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 3164 KB Output is correct
2 Correct 4 ms 3684 KB Output is correct
3 Correct 2 ms 3164 KB Output is correct
4 Correct 4 ms 3676 KB Output is correct
5 Correct 4 ms 3676 KB Output is correct
6 Correct 4 ms 3672 KB Output is correct
7 Correct 3 ms 3164 KB Output is correct
8 Correct 2 ms 3164 KB Output is correct
9 Correct 3 ms 3416 KB Output is correct
10 Correct 4 ms 3624 KB Output is correct

Subtask #3
0 / 80.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 2908 KB Output is correct
2 Correct 2 ms 2908 KB Output is correct
3 Correct 1 ms 2908 KB Output is correct
4 Correct 2 ms 2908 KB Output is correct
5 Correct 2 ms 3164 KB Output is correct
6 Correct 2 ms 3160 KB Output is correct
7 Correct 2 ms 3164 KB Output is correct
8 Correct 2 ms 2908 KB Output is correct
9 Correct 2 ms 3164 KB Output is correct
10 Correct 2 ms 3160 KB Output is correct
11 Correct 3 ms 3164 KB Output is correct
12 Correct 4 ms 3684 KB Output is correct
13 Correct 2 ms 3164 KB Output is correct
14 Correct 4 ms 3676 KB Output is correct
15 Correct 4 ms 3676 KB Output is correct
16 Correct 4 ms 3672 KB Output is correct
17 Correct 3 ms 3164 KB Output is correct
18 Correct 2 ms 3164 KB Output is correct
19 Correct 3 ms 3416 KB Output is correct
20 Correct 4 ms 3624 KB Output is correct
21 Correct 27 ms 7868 KB Output is correct
22 Execution timed out 2054 ms 185172 KB Time limit exceeded
23 Halted 0 ms 0 KB -