結果

問題 No.800 四平方定理
ユーザー sekiya9311sekiya9311
提出日時 2019-10-20 23:41:42
言語 C#(csc)
(csc 3.9.0)
結果
AC  
実行時間 984 ms / 2,000 ms
コード長 7,115 bytes
コンパイル時間 1,112 ms
コンパイル使用メモリ 112,896 KB
実行使用メモリ 95,184 KB
最終ジャッジ日時 2024-07-02 17:35:46
合計ジャッジ時間 13,877 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 39 ms
19,584 KB
testcase_01 AC 44 ms
20,608 KB
testcase_02 AC 40 ms
19,584 KB
testcase_03 AC 41 ms
19,712 KB
testcase_04 AC 41 ms
20,224 KB
testcase_05 AC 43 ms
20,352 KB
testcase_06 AC 44 ms
20,480 KB
testcase_07 AC 47 ms
21,504 KB
testcase_08 AC 50 ms
21,888 KB
testcase_09 AC 44 ms
20,608 KB
testcase_10 AC 438 ms
69,080 KB
testcase_11 AC 388 ms
61,056 KB
testcase_12 AC 487 ms
71,940 KB
testcase_13 AC 365 ms
57,472 KB
testcase_14 AC 319 ms
59,264 KB
testcase_15 AC 496 ms
71,876 KB
testcase_16 AC 353 ms
59,648 KB
testcase_17 AC 360 ms
59,776 KB
testcase_18 AC 652 ms
74,288 KB
testcase_19 AC 637 ms
74,308 KB
testcase_20 AC 35 ms
19,072 KB
testcase_21 AC 34 ms
19,200 KB
testcase_22 AC 608 ms
74,356 KB
testcase_23 AC 972 ms
95,184 KB
testcase_24 AC 679 ms
88,244 KB
testcase_25 AC 984 ms
94,956 KB
testcase_26 AC 32 ms
18,944 KB
testcase_27 AC 33 ms
19,200 KB
testcase_28 AC 644 ms
88,344 KB
testcase_29 AC 776 ms
92,312 KB
testcase_30 AC 644 ms
88,244 KB
testcase_31 AC 603 ms
85,092 KB
testcase_32 AC 675 ms
89,264 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
Microsoft (R) Visual C# Compiler version 3.9.0-6.21124.20 (db94f4cc)
Copyright (C) Microsoft Corporation. All rights reserved.

ソースコード

diff # 

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;

namespace ProgrammingContestTemplateByDotNetCore
{

    #region "Input and Output Classes"

    class Scanner : IDisposable
    {
        private readonly Queue<string> _buffer;
        private readonly char[] _sep;
        private readonly TextReader _reader;

        public Scanner(TextReader reader = null, char[] sep = null)
        {
            _buffer = new Queue<string>();
            _sep = sep ?? new[] { ' ' };
            _reader = reader ?? Console.In;
        }

        public Scanner(string path, char[] sep = null)
            : this(new StreamReader(path), sep) { }

        private void CheckBuffer()
        {
            if (_buffer.Any() || _reader.Peek() == -1)
                return;

            string str = string.Empty;
            for (;
                string.IsNullOrWhiteSpace(str);
                str = _reader.ReadLine()) { }

            var values = str.Split(_sep).Where(s => !string.IsNullOrWhiteSpace(s));
            foreach (var item in values)
            {
                _buffer.Enqueue(item);
            }
        }

        public string Next()
        {
            CheckBuffer();
            return _buffer.Dequeue();
        }
        public string[] GetStringArray(int count)
            => Enumerable.Range(0, count)
                .Select(e => Next())
                .ToArray();

        public int NextInt() => int.Parse(Next());
        public int[] GetIntArray(int count)
            => Enumerable.Range(0, count)
                .Select(e => NextInt())
                .ToArray();

        public long NextLong() => long.Parse(Next());
        public long[] GetLongArray(int count)
            => Enumerable.Range(0, count)
                .Select(e => NextLong())
                .ToArray();

        public double NextDouble() => double.Parse(Next());
        public double[] GetDoubleArray(int count)
            => Enumerable.Range(0, count)
                .Select(e => NextDouble())
                .ToArray();

        public decimal NextDecimal() => decimal.Parse(Next());
        public decimal[] GetDecimalArray(int count)
            => Enumerable.Range(0, count)
                .Select(e => NextDecimal())
                .ToArray();

        public BigInteger NextBigInt() => BigInteger.Parse(Next());
        public BigInteger[] GetBigIntArray(int count)
            => Enumerable.Range(0, count)
                .Select(e => NextBigInt())
                .ToArray();

        public bool IsEnd
        {
            get
            {
                CheckBuffer();
                return !_buffer.Any();
            }
        }

        public void Dispose()
        {
            if (!_reader.Equals(Console.In))
                _reader.Dispose();
        }
    }

    class Writer : IDisposable
    {
        private readonly TextWriter _writer;
        private readonly StringBuilder _cache;
        private readonly bool _isReactive;

        public Writer(TextWriter writer = null, bool isReactive = false)
        {
            _writer = writer ?? Console.Out;
            _isReactive = isReactive;
            if (!_isReactive)
                _cache = new StringBuilder();
        }

        public Writer(string path)
            : this(new StreamWriter(path)) { }

        public Writer(bool isReactive)
            : this(null, isReactive) { }

        public void Write(object value)
        {
            if (_isReactive)
            {
                _writer.Write(value);
                _writer.Flush();
            }
            else
            {
                _cache.Append(value);
            }
        }

        public void WriteFormat(string format, params object[] values)
        {
            var value = string.Format(format, values);
            Write(value);
        }

        public void WriteLine(object value = null)
        {
            Write($"{value}{Environment.NewLine}");
        }

        public void WriteLine(string format, params object[] values)
        {
            WriteFormat($"{format}{Environment.NewLine}", values);
        }

        public void Dispose()
        {
            if (!_isReactive)
            {
                _writer.Write(_cache);
                _writer.Flush();
            }
            if (!_writer.Equals(Console.Out))
            {
                _writer.Dispose();
            }
        }
    }

    public static class Extensions
    {
        public static void Set<TKey, TValue>(
            this IDictionary<TKey, TValue> source,
            TKey key, TValue value)
        {
            if (source.ContainsKey(key))
                source[key] = value;
            else
                source.Add(key, value);
        }


    }

#endregion

    class MainClass : IDisposable
    {
#region "Template"

        /// <summary> 入力を受け取る </summary>
        private readonly Scanner sc;
        /// <summary> 出力を行う </summary>
        private readonly Writer wr;
        private const string _inputFile = "input.txt";
        private const string _outFile = "output.txt";

        static void Main(string[] args)
        {
            using (new MainClass()) { }
        }

        public MainClass()
        {
            wr = new Writer(_isReactive);
            // TODO: ファイルに出力したい場合はこっち → wr = new Writer(_outFile);

#if DEBUG
            // 手元では、ファイルから入力を受け取る
            sc = new Scanner(_inputFile);
#else

            // 提出時、標準入力から受け取る
            sc = new Scanner();
#endif

            Solve();
        }

        public void Dispose()
        {
            sc?.Dispose();
            wr?.Dispose();
        }

        #endregion

        const int L = 2000 * 2000 * 2 + 1;
        int[] ar = new int[L];

        void Solve()
        {
            int N = sc.NextInt();
            int D = sc.NextInt();

            {
                for (int x = 1; x <= N; x++)
                {
                    for (int y = 1; y <= N; y++)
                    {
                        var key = x * x + y * y;
                        ar[key]++;
                    }
                }
            }

            Dictionary<int, int> wz = new Dictionary<int, int>();
            {
                for (int w = 1; w <= N; w++)
                {
                    for (int z = 1; z <= N; z++)
                    {
                        var key = w * w - z * z + D;
                        if (1 <= key && key <= 2000 * 2000 * 2)
                        {
                            wz.Set(key, wz.GetValueOrDefault(key) + 1);
                        }
                    }
                }
            }

            var ans = wz.Aggregate(0L, (acc, e) => acc + e.Value * ar[e.Key]);
            wr.WriteLine(ans);
        }

        /// <summary>
        /// TODO: リアクティブ問題か否かを指定してね♪
        /// </summary>
        private const bool _isReactive = false;
    }
}
0