AtCoder Grand Contest 022

Submission #2293774

Source codeソースコード

import std.stdio;
import std.string;
import std.format;
import std.conv;
import std.typecons;
import std.algorithm;
import std.functional;
import std.bigint;
import std.numeric;
import std.array;
import std.math;
import std.range;
import std.container;
import std.concurrency;
import std.traits;
import std.uni;
import core.bitop : popcnt;
alias Generator = std.concurrency.Generator;

enum long INF = long.max/3;
enum long MOD = 10L^^9+7;

void main() {
    long N;
    scanln(N);
    long[] as = readln.split.to!(long[]);
    long[] bs = readln.split.to!(long[]);

    long K = 50;

    long[][][] memo = new long[][][](K+1, K+1);
    long[] f(long x, long y) {
        if (!memo[x][y].empty) return memo[x][y];
        if (x == y) return [0L];
        long[] res = [];
        foreach(i; 1..x+1) {
            res ~= f(x%i, y).map!(bits => bits|1L<<i).array;
        }
        return memo[x][y] = res;
    }

    long[][] css = N.iota.map!(i => f(as[i], bs[i]).sort!"a<b".uniq.array).array;
    if (css.any!"a.empty") {
        writeln(-1);
        return;
    }

    long ans = (1L<<K)-1;
    foreach_reverse(i; 0..K) {
        long bits = ans>>(i+1)<<(i+1)|((1L<<i)-1);
        if (
            css.all!(
                cs => cs.any!(
                    c => (~bits&c) == 0
                )
            )
        ) {
            ans = bits;
        }
    }
    ans.writeln;
}

// ----------------------------------------------

void scanln(Args...)(auto ref Args args) {
    import std.meta;
    template getFormat(T) {
        static if (isIntegral!T) {
            enum getFormat = "%d";
        } else static if (isFloatingPoint!T) {
            enum getFormat = "%g";
        } else static if (isSomeString!T || isSomeChar!T) {
            enum getFormat = "%s";
        } else {
            static assert(false);
        }
    }
    enum string str = [staticMap!(getFormat, Args)].join(" ") ~ "\n";
    // readf!str(args);
    mixin("str.readf(" ~ Args.length.iota.map!(i => "&args[%d]".format(i)).join(", ") ~ ");");
}

void times(alias fun)(long n) {
    // n.iota.each!(i => fun());
    foreach(i; 0..n) fun();
}
auto rep(alias fun, T = typeof(fun()))(long n) {
    // return n.iota.map!(i => fun()).array;
    T[] res = new T[n];
    foreach(ref e; res) e = fun();
    return res;
}

T ceil(T)(T x, T y) if (__traits(isIntegral, T)) {
    // `(x+y-1)/y` will only work for positive numbers ...
    T t = x / y;
    if (t * y < x) t++;
    return t;
}

T floor(T)(T x, T y) if (__traits(isIntegral, T)) {
    T t = x / y;
    if (t * y > x) t--;
    return t;
}

// fold was added in D 2.071.0
static if (__VERSION__ < 2071) {
    template fold(fun...) if (fun.length >= 1) {
        auto fold(R, S...)(R r, S seed) {
            static if (S.length < 2) {
                return reduce!fun(seed, r);
            } else {
                return reduce!fun(tuple(seed), r);
            }
        }
    }
}

// cumulativeFold was added in D 2.072.0
static if (__VERSION__ < 2072) {
    template cumulativeFold(fun...)
    if (fun.length >= 1)
    {
        import std.meta : staticMap;
        private alias binfuns = staticMap!(binaryFun, fun);

        auto cumulativeFold(R)(R range)
        if (isInputRange!(Unqual!R))
        {
            return cumulativeFoldImpl(range);
        }

        auto cumulativeFold(R, S)(R range, S seed)
        if (isInputRange!(Unqual!R))
        {
            static if (fun.length == 1)
                return cumulativeFoldImpl(range, seed);
            else
                return cumulativeFoldImpl(range, seed.expand);
        }

        private auto cumulativeFoldImpl(R, Args...)(R range, ref Args args)
        {
            import std.algorithm.internal : algoFormat;

            static assert(Args.length == 0 || Args.length == fun.length,
                algoFormat("Seed %s does not have the correct amount of fields (should be %s)",
                    Args.stringof, fun.length));

            static if (args.length)
                alias State = staticMap!(Unqual, Args);
            else
                alias State = staticMap!(ReduceSeedType!(ElementType!R), binfuns);

            foreach (i, f; binfuns)
            {
                static assert(!__traits(compiles, f(args[i], e)) || __traits(compiles,
                        { args[i] = f(args[i], e); }()),
                    algoFormat("Incompatible function/seed/element: %s/%s/%s",
                        fullyQualifiedName!f, Args[i].stringof, E.stringof));
            }

            static struct Result
            {
            private:
                R source;
                State state;

                this(R range, ref Args args)
                {
                    source = range;
                    if (source.empty)
                        return;

                    foreach (i, f; binfuns)
                    {
                        static if (args.length)
                            state[i] = f(args[i], source.front);
                        else
                            state[i] = source.front;
                    }
                }

            public:
                @property bool empty()
                {
                    return source.empty;
                }

                @property auto front()
                {
                    assert(!empty, "Attempting to fetch the front of an empty cumulativeFold.");
                    static if (fun.length > 1)
                    {
                        import std.typecons : tuple;
                        return tuple(state);
                    }
                    else
                    {
                        return state[0];
                    }
                }

                void popFront()
                {
                    assert(!empty, "Attempting to popFront an empty cumulativeFold.");
                    source.popFront;

                    if (source.empty)
                        return;

                    foreach (i, f; binfuns)
                        state[i] = f(state[i], source.front);
                }

                static if (isForwardRange!R)
                {
                    @property auto save()
                    {
                        auto result = this;
                        result.source = source.save;
                        return result;
                    }
                }

                static if (hasLength!R)
                {
                    @property size_t length()
                    {
                        return source.length;
                    }
                }
            }

            return Result(range, args);
        }
    }
}

// minElement/maxElement was added in D 2.072.0
static if (__VERSION__ < 2072) {
    auto minElement(alias map, Range)(Range r)
    if (isInputRange!Range && !isInfinite!Range)
    {
        alias mapFun = unaryFun!map;
        auto element = r.front;
        auto minimum = mapFun(element);
        r.popFront;
        foreach(a; r) {
            auto b = mapFun(a);
            if (b < minimum) {
                element = a;
                minimum = b;
            }
        }
        return element;
    }
    auto maxElement(alias map, Range)(Range r)
    if (isInputRange!Range && !isInfinite!Range)
    {
        alias mapFun = unaryFun!map;
        auto element = r.front;
        auto maximum = mapFun(element);
        r.popFront;
        foreach(a; r) {
            auto b = mapFun(a);
            if (b > maximum) {
                element = a;
                maximum = b;
            }
        }
        return element;
    }
}

Submission

Task問題 C - Remainder Game
User nameユーザ名 Ark
Created time投稿日時
Language言語 D (DMD64 v2.070.1)
Status状態 AC
Score得点 700
Source lengthソースコード長 7896 Byte
File nameファイル名
Exec time実行時間 11 ms
Memory usageメモリ使用量 2556 KB

Test case

Set

Set name Score得点 / Max score Cases
Sample - s1.txt,s2.txt,s3.txt,s4.txt,s5.txt
All 700 / 700 01.txt,02.txt,03.txt,04.txt,05.txt,06.txt,07.txt,08.txt,09.txt,10.txt,11.txt,12.txt,13.txt,14.txt,15.txt,16.txt,17.txt,18.txt,19.txt,20.txt,21.txt,22.txt,23.txt,24.txt,25.txt,26.txt,27.txt,28.txt,29.txt,30.txt,31.txt,32.txt,33.txt,34.txt,35.txt,36.txt,37.txt,38.txt,39.txt,40.txt,41.txt,42.txt,43.txt,44.txt,45.txt,46.txt,47.txt,48.txt,49.txt,50.txt,51.txt,52.txt,53.txt,s1.txt,s2.txt,s3.txt,s4.txt,s5.txt

Test case

Case name Status状態 Exec time実行時間 Memory usageメモリ使用量
01.txt AC 2 ms 380 KB
02.txt AC 11 ms 1276 KB
03.txt AC 1 ms 380 KB
04.txt AC 1 ms 380 KB
05.txt AC 6 ms 764 KB
06.txt AC 2 ms 2556 KB
07.txt AC 2 ms 764 KB
08.txt AC 2 ms 636 KB
09.txt AC 3 ms 1020 KB
10.txt AC 2 ms 508 KB
11.txt AC 3 ms 892 KB
12.txt AC 1 ms 380 KB
13.txt AC 1 ms 380 KB
14.txt AC 3 ms 636 KB
15.txt AC 5 ms 636 KB
16.txt AC 4 ms 508 KB
17.txt AC 5 ms 764 KB
18.txt AC 8 ms 1020 KB
19.txt AC 9 ms 892 KB
20.txt AC 8 ms 1020 KB
21.txt AC 9 ms 1148 KB
22.txt AC 9 ms 892 KB
23.txt AC 9 ms 1020 KB
24.txt AC 2 ms 508 KB
25.txt AC 3 ms 508 KB
26.txt AC 2 ms 764 KB
27.txt AC 2 ms 636 KB
28.txt AC 4 ms 508 KB
29.txt AC 3 ms 636 KB
30.txt AC 2 ms 636 KB
31.txt AC 2 ms 636 KB
32.txt AC 1 ms 380 KB
33.txt AC 3 ms 508 KB
34.txt AC 4 ms 636 KB
35.txt AC 5 ms 764 KB
36.txt AC 2 ms 508 KB
37.txt AC 3 ms 508 KB
38.txt AC 2 ms 508 KB
39.txt AC 4 ms 764 KB
40.txt AC 2 ms 508 KB
41.txt AC 5 ms 764 KB
42.txt AC 3 ms 508 KB
43.txt AC 4 ms 636 KB
44.txt AC 3 ms 508 KB
45.txt AC 4 ms 636 KB
46.txt AC 2 ms 508 KB
47.txt AC 4 ms 636 KB
48.txt AC 4 ms 636 KB
49.txt AC 1 ms 380 KB
50.txt AC 1 ms 380 KB
51.txt AC 1 ms 380 KB
52.txt AC 1 ms 380 KB
53.txt AC 3 ms 508 KB
s1.txt AC 1 ms 380 KB
s2.txt AC 1 ms 380 KB
s3.txt AC 1 ms 380 KB
s4.txt AC 1 ms 380 KB
s5.txt AC 2 ms 380 KB