Submission #305878

#	Time	Username	Problem	Language	Result	Execution time	Memory
305878		llaki	Packing Biscuits (IOI20_biscuits)	Java	21 / 100	1097 ms	107688 KiB

biscuits

import java.util.HashMap;

public class biscuits {
    long count_tastiness(long x, long[] a) {
//        if (x == 1) {
//            return solveXIsOne(a);
//        }
        HashMap<Long, Long> freq = new HashMap<>();
        freq.put(a[0], 1l);
        return recursiveFaster(0, freq, a, x);
        //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 recursiveFaster(int pos, HashMap<Long, Long> freq, long[] a, long x) {
        //System.out.println(pos + ": " + freq);
        if (pos == a.length - 1) {
            long ans = 0;
            for (long y : freq.keySet()) {
                ans += freq.get(y) * (y / x + 1);
            }
            return ans;
        }
        if (freq.size() > 2 * x) {
            System.exit(3);
        }
        HashMap<Long, Long> map = new HashMap<>();
        // for each y in freq.keyset(): a[pos + 1] + y/2 and (y-1)/2.
        for (long y : freq.keySet()) {
            long val = a[pos + 1] + y / 2;
            if (!map.containsKey(val)) map.put(val, 0l);
            map.put(val, map.get(val) + freq.get(y));
            if (y >= x) {
                val = a[pos + 1] + (y - x) / 2;
                if (!map.containsKey(val)) map.put(val, 0l);
                map.put(val, map.get(val) + freq.get(y));
            }
        }
        return recursiveFaster(pos + 1, map, a, x);
    }

    long recursiveForOne(int pos, long l, long r, HashMap<Long, Long> freq, long[] a) {
        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 / 9
• Subtask 2: 12 / 12
• Subtask 3: 0 / 21
• Subtask 4: 0 / 35
• Subtask 5: 0 / 23