oj.uz

Submission #305870

# Submission time Handle Problem Language Result Execution time Memory
305870 2020-09-24T03:43:23 Z llaki Packing Biscuits (IOI20_biscuits) Java 11
21 / 100
 1000 ms 11384 KB 
import java.util.HashMap;

public class biscuits {
    long count_tastiness(long x, long[] a) {
        if (x == 1) {
            return solveXIsOne(a);
        }
        return countNaive(x, a);
    }

    // How many diff. sums can we get by  (n[i] * 2^i, where 0 <= n[i] <= a[i]).
    long solveXIsOne(long[] a) {
        HashMap<Long, Long> freq = new HashMap<>();
        freq.put(a[0], 1l);
        return recursiveForOne(0, a[0], a[0], freq, a);
        //return recursiveXIsOne(0, a[0], a);
    }

    HashMap<String, Long> map = new HashMap<>();

    String toKey(int pos, long first) {
        return pos + "." + first;
    }

    long recursiveXIsOne(int pos, long first, long[] a) {
        if (pos == a.length - 1) {
            return first + 1;
        }
        String key = toKey(pos, first);
        if (map.containsKey(key)) map.get(key);
        long res = recursiveXIsOne(pos + 1, a[pos + 1] + first / 2, a);
        if (first > 0) {
            res += recursiveXIsOne(pos + 1, a[pos + 1] + (first - 1) / 2, a);
        }
        map.put(key, res);
        return res;
    }

    long recursiveForOne(int pos, long l, long r, HashMap<Long, Long> freq, long[] a) {
//        String st = "";
//        for (Long k : freq.keySet()) st += "[" + k + " -> " + freq.get(k) + "] ";
//        System.out.println(pos + ", " + l + " " + r + ", map: " + st);
        if (pos == a.length - 1) {
            long ans = 0;
            for (long y = l; y <= r; y++) {
                ans += freq.get(y) * (y + 1);
            }
            return ans;
        }
        // for each l <= y <= r: a[pos + 1] + y/2 and (y-1)/2
        long min = Long.MAX_VALUE;
        for (long y = l; y <= r; y++) {
            min = Math.min(min, a[pos + 1] + y/2);
            if (y > 0) {
                min = Math.min(min, a[pos + 1] + (y-1)/2);
            }
        }
        long max = Long.MIN_VALUE;
        for (long y = l; y <= r; y++) {
            max = Math.max(max, a[pos + 1] + y/2);
        }
        HashMap<Long, Long> map = new HashMap<>();
        for (long y = l; y <= r; y++) {
            long val = a[pos + 1] + y / 2;
            if (!map.containsKey(val)) map.put(val, 0l);
            map.put(val, map.get(val) + freq.getOrDefault(y, 0l));
            if (y > 0) {
                val = a[pos + 1] + (y - 1) / 2;
                if (!map.containsKey(val)) map.put(val, 0l);
                map.put(val, map.get(val) + freq.getOrDefault(y, 0l));
            }
        }
        return recursiveForOne(pos + 1, min, max, map, a);
    }

    long countNaive(long x, long[] a) {
        return countRec(x, a, 0);
    }

    long countRec(long x, long[] a, int index) {
        if (index == a.length - 1) {
            return a[a.length - 1] / x + 1;
        }
        long temp = a[index + 1];
        a[index + 1] = a[index + 1] + a[index] / 2;
        long answer = countRec(x, a, index + 1);
        if (a[index] >= x) {
            a[index + 1] = temp + (a[index] - x) / 2;
            answer += countRec(x, a, index + 1);
            a[index + 1] = temp;
        }
        a[index + 1] = temp;
        return answer;
    }

}
// (s[k-1] - i * X) / (2^(k-1)), 0 <= i < 2^(k - 1).
// For which i is this state valid?
// If for each position b s.t. b-th bit is set in i, (s[b+1] - (2^b + prev(i,b))X) / 2^(b+1) >= X.

Subtask #1
9.0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 87 ms 10356 KB Output is correct
2 Correct 85 ms 10164 KB Output is correct
3 Correct 82 ms 10232 KB Output is correct
4 Correct 87 ms 10360 KB Output is correct
5 Correct 85 ms 10232 KB Output is correct
6 Correct 88 ms 10476 KB Output is correct
7 Correct 82 ms 10204 KB Output is correct
8 Correct 87 ms 10356 KB Output is correct
9 Correct 85 ms 10120 KB Output is correct
10 Correct 86 ms 10212 KB Output is correct
11 Correct 82 ms 10112 KB Output is correct
12 Correct 120 ms 10728 KB Output is correct
13 Correct 118 ms 10472 KB Output is correct
14 Correct 94 ms 10760 KB Output is correct

Subtask #2
12.0 / 12.0

# Verdict Execution time Memory Grader output
1 Correct 88 ms 10232 KB Output is correct
2 Correct 90 ms 10472 KB Output is correct
3 Correct 86 ms 10100 KB Output is correct
4 Correct 90 ms 10356 KB Output is correct
5 Correct 95 ms 10636 KB Output is correct
6 Correct 99 ms 10884 KB Output is correct
7 Correct 84 ms 10356 KB Output is correct
8 Correct 106 ms 10980 KB Output is correct
9 Correct 102 ms 11016 KB Output is correct

Subtask #3
0 / 21.0

# Verdict Execution time Memory Grader output
1 Correct 85 ms 10356 KB Output is correct
2 Correct 88 ms 10204 KB Output is correct
3 Correct 83 ms 10104 KB Output is correct
4 Correct 157 ms 10740 KB Output is correct
5 Correct 161 ms 10876 KB Output is correct
6 Execution timed out 1077 ms 10688 KB Time limit exceeded
7 Halted 0 ms 0 KB -

Subtask #4
0 / 35.0

# Verdict Execution time Memory Grader output
1 Correct 101 ms 10472 KB Output is correct
2 Execution timed out 1089 ms 11384 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #5
0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 87 ms 10356 KB Output is correct
2 Correct 85 ms 10164 KB Output is correct
3 Correct 82 ms 10232 KB Output is correct
4 Correct 87 ms 10360 KB Output is correct
5 Correct 85 ms 10232 KB Output is correct
6 Correct 88 ms 10476 KB Output is correct
7 Correct 82 ms 10204 KB Output is correct
8 Correct 87 ms 10356 KB Output is correct
9 Correct 85 ms 10120 KB Output is correct
10 Correct 86 ms 10212 KB Output is correct
11 Correct 82 ms 10112 KB Output is correct
12 Correct 120 ms 10728 KB Output is correct
13 Correct 118 ms 10472 KB Output is correct
14 Correct 94 ms 10760 KB Output is correct
15 Correct 88 ms 10232 KB Output is correct
16 Correct 90 ms 10472 KB Output is correct
17 Correct 86 ms 10100 KB Output is correct
18 Correct 90 ms 10356 KB Output is correct
19 Correct 95 ms 10636 KB Output is correct
20 Correct 99 ms 10884 KB Output is correct
21 Correct 84 ms 10356 KB Output is correct
22 Correct 106 ms 10980 KB Output is correct
23 Correct 102 ms 11016 KB Output is correct
24 Correct 85 ms 10356 KB Output is correct
25 Correct 88 ms 10204 KB Output is correct
26 Correct 83 ms 10104 KB Output is correct
27 Correct 157 ms 10740 KB Output is correct
28 Correct 161 ms 10876 KB Output is correct
29 Execution timed out 1077 ms 10688 KB Time limit exceeded
30 Halted 0 ms 0 KB -