結果

問題 No.653 E869120 and Lucky Numbers
ユーザー sekiya9311
提出日時 2018-02-23 23:30:17
言語 C#
(csc 3.100.19.26603)
結果
WA   .
(最新)
AC  
(最初)
実行時間 -
コード長 9,340 Byte
コンパイル時間 1,809 ms
使用メモリ 18,668 KB
最終ジャッジ日時 2019-12-07 06:48:41

テストケース

テストケース表示
入力 結果 実行時間
使用メモリ
99_challenge01.txt AC 49 ms
11,412 KB
99_system_test1.txt AC 44 ms
11,692 KB
99_system_test2.txt WA -
99_system_test3.txt AC 45 ms
11,784 KB
99_system_test4.txt AC 44 ms
11,600 KB
99_system_test5.txt WA -
99_system_test6.txt AC 47 ms
12,172 KB
99_system_test7.txt AC 44 ms
11,696 KB
in01.txt AC 43 ms
11,432 KB
in02.txt AC 42 ms
11,412 KB
in03.txt AC 44 ms
11,452 KB
in04.txt AC 43 ms
11,452 KB
in05.txt AC 44 ms
11,468 KB
in06.txt AC 43 ms
11,400 KB
in07.txt AC 43 ms
11,440 KB
in08.txt AC 43 ms
11,452 KB
in09.txt AC 44 ms
11,448 KB
in10.txt AC 44 ms
11,452 KB
in11.txt AC 44 ms
11,448 KB
in12.txt AC 43 ms
11,444 KB
in13.txt AC 44 ms
11,456 KB
in14.txt AC 44 ms
11,456 KB
in15.txt AC 44 ms
11,424 KB
in16.txt AC 44 ms
11,424 KB
in17.txt AC 44 ms
11,424 KB
in18.txt AC 44 ms
11,440 KB
in19.txt AC 44 ms
11,436 KB
in20.txt AC 69 ms
18,660 KB
in21.txt AC 69 ms
18,668 KB
in22.txt AC 64 ms
18,664 KB
sample01.txt AC 44 ms
11,416 KB
sample02.txt AC 43 ms
11,424 KB
sample03.txt AC 44 ms
11,432 KB
テストケース一括ダウンロード
コンパイルメッセージ
Microsoft (R) Visual C# Compiler version 3.3.1-beta4-19462-11 (66a912c9)
Copyright (C) Microsoft Corporation. All rights reserved.

ソースコード

diff #
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ProgrammingContest
{
    class Writer : IDisposable
    {
        private System.IO.TextWriter writer;
        private StringBuilder sb;
        private bool isReactive;
        public Writer(string path)
            : this(new System.IO.StreamWriter(path))
        {
        }
        public Writer(bool isReactive)
            : this(null, isReactive)
        {
        }
        public Writer(System.IO.TextWriter writer = null,
                        bool isReactive = false)
        {
            this.writer = (writer ?? Console.Out);
            this.isReactive = isReactive;
            if (!this.isReactive)
            {
                this.sb = new StringBuilder();
            }
        }
        public void Dispose()
        {
            if (!this.isReactive)
            {
                this.writer.Write(sb.ToString());
            }
            if (!this.writer.Equals(Console.Out))
            {
                this.writer.Dispose();
            }
        }
        public void Write(object val)
        {
            if (this.isReactive)
            {
                this.writer.Write(val.ToString());
                this.writer.Flush();
            }
            else
            {
                this.sb.Append(val.ToString());
            }
        }
        public void Write(string format, params object[] vals)
        {
            if (this.isReactive)
            {
                this.writer.Write(format, vals);
                this.writer.Flush();
            }
            else
            {
                this.sb.AppendFormat(format, vals);
            }
        }
        public void WriteLine(object val = null)
        {
            this.Write((val ?? string.Empty).ToString() + System.Environment.NewLine);
        }
        public void WriteLine(int val)
        {
            this.WriteLine(val.ToString());
        }
        public void WriteLine(long val)
        {
            this.WriteLine(val.ToString());
        }
        public void WriteLine(string val)
        {
            this.WriteLine((object)val);
        }
        public void WriteLine(string format, params object[] vals)
        {
            this.Write(format + System.Environment.NewLine, vals);
        }
    }

    class Scanner : IDisposable
    {
        private Queue<string> buffer;
        private char[] sep;
        private System.IO.TextReader reader;
        public Scanner(string path, char[] sep = null)
            : this(new System.IO.StreamReader(path), sep)
        {
        }
        public Scanner(System.IO.TextReader reader = null,
                        char[] sep = null)
        {
            this.buffer = new Queue<string>();
            this.sep = (sep ?? new char[] { ' ' });
            this.reader = (reader ?? Console.In);
        }
        private void CheckBuffer()
        {
            if (this.buffer.Count == 0 && this.reader.Peek() != -1)
            {
                string str = string.Empty;
                for (; string.IsNullOrEmpty(str);
                    str = this.reader.ReadLine()) ;

                str.Split(this.sep).ToList()
                   .ForEach(el => this.buffer.Enqueue(el));
            }
        }

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

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

        public int NextInt
        {
            get
            {
                return int.Parse(this.Next);
            }
        }
        public int[] GetIntArray(int N)
        {
            return Enumerable.Range(0, N)
                             .Select(e => this.NextInt)
                             .ToArray();
        }

        public double NextDouble
        {
            get
            {
                return double.Parse(this.Next);
            }
        }
        public double[] GetdoubleArray(int N)
        {
            return Enumerable.Range(0, N)
                             .Select(e => this.NextDouble)
                             .ToArray();
        }

        public long NextLong
        {
            get
            {
                return long.Parse(this.Next);
            }
        }
        public long[] GetLongArray(int N)
        {
            return Enumerable.Range(0, N)
                             .Select(e => this.NextLong)
                             .ToArray();
        }

        public bool IsEnd
        {
            get
            {
                this.CheckBuffer();
                return this.buffer.Count == 0;
            }
        }
    }

    class MainClass : IDisposable
    {
        Scanner sc;
        Writer wr;
        string backPath = "..";
        char dirSep = System.IO.Path.DirectorySeparatorChar;
        string inFilePath = string.Empty;
        string outFilePath = string.Empty;
        public MainClass()
        {
            this.inFilePath = this.backPath
                            + this.dirSep
                            + this.backPath
                            + this.dirSep
                            + "in.txt";
            this.outFilePath = this.backPath
                             + this.dirSep
                             + this.backPath
                             + this.dirSep
                             + "out.txt";

            this.wr = new Writer(this.IsReactive);
            //this.wr = new Writer(this.outFilePath);
#if DEBUG
            if (!this.IsReactive)
            {
                this.sc = new Scanner(this.inFilePath);
            }
            else
            {
                this.sc = new Scanner();
            }
#else
            this.sc = new Scanner();
#endif
        }
        static void Main(string[] args)
        {
            using (var mainClass = new MainClass())
            {
                mainClass.Solve();
            }
        }

        public void Dispose()
        {
            if (this.sc != null)
            {
                this.sc.Dispose();
                this.sc = null;
            }
            if (this.wr != null)
            {
                this.wr.Dispose();
                this.wr = null;
            }
#if DEBUG
            Console.WriteLine("続行するには何かキーを押してください...");
            Console.ReadKey();
#endif
        }

        void MakeTestCase()
        {
            Random rand = new Random();
            if (this.wr != null)
            {
                this.wr.Dispose();
            }
            this.wr = new Writer(inFilePath);


        }

        void Solve()
        {
            var p = ReverseStr(sc.Next);
            if (p == "0")
            {
                wr.WriteLine("No");
                return;
            }
            var que = new Queue<State>();
            que.Enqueue(new State(0, 0));
            var sets = new HashSet<int>[p.Length + 1].Select(e => new HashSet<int>()).ToArray();
            while (que.Count > 0)
            {
                var now = que.Dequeue();
                if (now.i == p.Length)
                {
                    if (now.c == 0)
                    {
                        wr.WriteLine("Yes");
                        return;
                    }
                    else
                    {
                        continue;
                    }
                }
                else if (now.c.ToString().Length == p.Length - now.i && ReverseStr(now.c.ToString()) == p.Substring(now.i, p.Length - now.i))
                {
                    wr.WriteLine("Yes");
                    return;
                }
                var cand = new List<int> { 6, 7 };
                if (now.i > 0) cand.Add(0);
                foreach (var i in cand)
                {
                    foreach (var j in cand)
                    {
                        if (i == 0 && j == 0) continue;
                        if ((i + j + now.c % 10) % 10 == p[now.i] - '0')
                        {
                            if (sets[now.i + 1].Contains(now.c / 10 + (i + j + now.c % 10) / 10))
                            {
                                continue;
                            }
                            sets[now.i + 1].Add(now.c / 10 + (i + j + now.c % 10) / 10);
                            que.Enqueue(new State(now.i + 1, now.c / 10 + (i + j + now.c % 10) / 10));
                        }
                    }
                }
            }
            wr.WriteLine("No");
        }

        struct State
        {
            public int i;
            public int c;
            public State(int i, int c)
            {
                this.i = i;
                this.c = c;
            }
        }
        string ReverseStr(string str)
        {
            return string.Join("", str.Reverse());
        }
        private bool IsReactive { get; } = false; // TODO: reactive check !!
    }
}
0