結果

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

テストケース

テストケース表示
入力 結果 実行時間
使用メモリ
99_challenge01.txt AC 38 ms
10,604 KB
99_system_test1.txt AC 39 ms
10,888 KB
99_system_test2.txt WA -
99_system_test3.txt AC 39 ms
10,988 KB
99_system_test4.txt AC 38 ms
10,816 KB
99_system_test5.txt WA -
99_system_test6.txt AC 40 ms
11,332 KB
99_system_test7.txt AC 38 ms
10,860 KB
in01.txt AC 37 ms
10,616 KB
in02.txt AC 37 ms
10,568 KB
in03.txt AC 38 ms
10,624 KB
in04.txt AC 39 ms
10,616 KB
in05.txt AC 38 ms
10,628 KB
in06.txt AC 37 ms
10,568 KB
in07.txt AC 38 ms
10,628 KB
in08.txt AC 39 ms
10,628 KB
in09.txt AC 38 ms
10,620 KB
in10.txt AC 38 ms
10,616 KB
in11.txt AC 38 ms
10,608 KB
in12.txt AC 37 ms
10,612 KB
in13.txt AC 38 ms
10,624 KB
in14.txt AC 38 ms
10,624 KB
in15.txt AC 38 ms
10,592 KB
in16.txt AC 38 ms
10,596 KB
in17.txt AC 38 ms
10,600 KB
in18.txt AC 38 ms
10,616 KB
in19.txt AC 38 ms
10,612 KB
in20.txt AC 60 ms
17,812 KB
in21.txt AC 61 ms
17,824 KB
in22.txt AC 57 ms
17,824 KB
sample01.txt AC 37 ms
10,604 KB
sample02.txt AC 38 ms
10,612 KB
sample03.txt AC 47 ms
10,608 KB
テストケース一括ダウンロード
コンパイルメッセージ
Microsoft (R) Visual C# Compiler version 2.8.2.62916 (2ad4aabc)
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