Submission #155361

---

Source Code Expand

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

namespace MixTester
{
    class Program
    {
        public static TextReader input;
        public static TextWriter output;


        public static List<int> ResidueList(int half_)
        {
            List<int> result = new List<int>();
            for (int i = 1; i <= half_; i++)
            {
                if (half_ % i == 0)
                    result.Add(i);
            }

            return result;
        }
        public static void Main(string[] args)
        {
            #region
            //Initialize
            input = Console.In;
            output = Console.Out;
            //input = new StreamReader("power.txt");
            //output = new StreamWriter("send.txt");
            //EndInitialize
            #endregion
            //ABC006
            //A
            /*
            int N = ReadInteger(1)[0];

            if (N % 3 == 0)
                output.WriteLine("YES");
            else
                output.WriteLine("NO");
             * */
            //B
            /*
            int N = ReadInteger(1)[0];
            ModularInteger pre2 = new ModularInteger(0), pre1 = new ModularInteger(0), now = new ModularInteger(1);

            ModularInteger answer;

            if (N < 3)
                answer = new ModularInteger(0);
            else
            {
                answer = now;
                for (int i = 0; i < N - 3; i++)
                {
                    answer = pre2 + pre1 + now;
                    pre2 = pre1;
                    pre1 = now;
                    now = answer;
                }
            }

            output.WriteLine(answer);
            */
            //C
            int[] start = ReadInteger(2);
            int head = start[0];
            int leg = start[1];

            if (leg < 2 * head || leg > 4 * head)
                output.WriteLine("-1 -1 -1");
            else if (leg < 3 * head)
            {
                int diff = 3 * head - leg;
                int roujin = head - diff;
                int adult = diff;
                output.WriteLine(string.Format("{0} {1} 0", adult, roujin));
            }
            else
            {
                int diff = leg - 3 * head;
                int roujin = head - diff;
                int child = diff;
                output.WriteLine(string.Format("0 {0} {1}", roujin, child));
            }

        
        }
        public static int[] ReadInteger(int count_)
        {
            int[] result = new int[count_];
            string line = input.ReadLine();
            string[] parts = line.Split(' ', ':', '/');
            for (int i = 0; i < count_; i++)
            {
                result[i] = int.Parse(parts[i]);
            }

            return result;

        }
    }

    struct ModularInteger : IComparable
    {
        /// <summary>
        /// この値はint maxの半分未満にしてください
        /// </summary>
        public const int MODULO = 10007;

        private long m_value;

        public long Value
        {
            get { return this.m_value; }
            private set { this.m_value = value; }
        }

        public ModularInteger(long initialvalue_)
            : this()
        {
            if (initialvalue_ >= 0)
                Value = initialvalue_ % MODULO;
            else
                Value = (initialvalue_ % MODULO) + MODULO;
        }

        public static ModularInteger operator +(ModularInteger left_, ModularInteger right_)
        {
            return new ModularInteger(left_.Value + right_.Value);
        }
        public static ModularInteger operator -(ModularInteger left_, ModularInteger right_)
        {
            return new ModularInteger(left_.Value - right_.Value);
        }
        public static ModularInteger operator *(ModularInteger left_, ModularInteger right_)
        {
            return new ModularInteger(left_.Value * right_.Value);
        }
        public static bool operator >(ModularInteger left_, ModularInteger right_)
        {
            return left_.Value > right_.Value;
        }
        public static bool operator <(ModularInteger left_, ModularInteger right_)
        {
            return left_.Value < right_.Value;
        }
        public override string ToString()
        {
            return m_value.ToString();
        }

        int IComparable.CompareTo(object obj)
        {
            return (int)(this.m_value - ((ModularInteger)obj).m_value);
        }
    }


   
    class BinaryHeap<T> : PriorityQueue<T>
    {
        private FlexibleArray<T> m_implearray;

        private IComparer<T> m_comparer;

        private delegate int MyComparer(T a_, T b_);

        public BinaryHeap(IComparer<T> comparer_, int initialsize_ = 128)
        {
            /*
            try
            {
                MyComparer comparer = (T a_, T b_) =>
                {
                    IComparable comparable_a = (IComparable)a_;
                    return comparable_a.CompareTo(b_);
                };
            }*/
            m_implearray = new FlexibleArray<T>(initialsize_);
            m_comparer = comparer_;
        }

        /// <summary>
        /// 指定されたインデックスの親のインデックスを返します。
        /// </summary>
        /// <param name="childindex_">子ノードのインデックス</param>
        /// <returns></returns>
        private static int ParentIndex(int childindex_)
        {
            return (childindex_ - 1) / 2;
        }

        /// <summary>
        /// 指定されたインデックスの左側の子のインデックスを返します。
        /// </summary>
        /// <param name="parentindex_"></param>
        /// <returns></returns>
        private static int ChildFirstIndex(int parentindex_)
        {
            return parentindex_ * 2 + 1;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="parentindex_"></param>
        /// <returns></returns>
        private static int ChildSecondIndex(int parentindex_)
        {
            return parentindex_ * 2 + 2;
        }

        public override void Enqueue(T element_)
        {
            //まずは指定された要素を末尾に追加
            m_implearray.PushBack(element_);
            //親と比較して、親より小さかったら(優先度が高かったら)親と交換する
            int lastindex = m_implearray.Length - 1;
            while (m_comparer.Compare(m_implearray[ParentIndex(lastindex)], m_implearray[lastindex]) > 0)
            {
                m_implearray.Swap(lastindex, ParentIndex(lastindex));
                lastindex = ParentIndex(lastindex);
            }
        }

        public bool Empty
        {
            get { return m_implearray.Length <= 0; }
        }

        public override T Dequeue()
        {
            //キューが空の時はnullを返す
            if (this.Empty)
            {
                throw new Exception("Queue is Empty");
            }
            //ルートと最後の葉を入れ替える
            m_implearray.Swap(0, m_implearray.Length - 1);
            //出力を準備しておく
            T front = m_implearray.PopBack();
            //現在ルートが大きい値になってしまっている。
            //２つの子が両方あるなら、その小さい方と交換
            int parentindex = 0;
            while (true)
            {
                int childleft = ChildFirstIndex(parentindex);
                int childright = ChildSecondIndex(parentindex);
                if (m_implearray.IndexChecker(childleft) && m_implearray.IndexChecker(childright))
                {
                    //子のどちらかよりも大きかった場合
                    if (m_comparer.Compare(m_implearray[childleft], m_implearray[parentindex]) <= 0 ||
                        m_comparer.Compare(m_implearray[childright], m_implearray[parentindex]) <= 0)
                    {
                        //左と右を比較して、より小さい方と交換
                        if (m_comparer.Compare(m_implearray[childleft], m_implearray[childright]) < 0)
                        {
                            m_implearray.Swap(childleft, parentindex);
                            parentindex = childleft;
                        }
                        else
                        {
                            m_implearray.Swap(childright, parentindex);
                            parentindex = childright;
                        }
                    }
                    //子のどちらよりもすでに小さかった場合は終了
                    else
                    {
                        break;
                    }
                }
                //片方の左側しか存在しない場合は、左側とだけ比べる
                else if (m_implearray.IndexChecker(childleft))
                {
                    if (m_comparer.Compare(m_implearray[childleft], m_implearray[parentindex]) < 0)
                    {
                        m_implearray.Swap(childleft, parentindex);
                        parentindex = childleft;
                    }
                    //比べた結果左の子以下だった場合は終了
                    else
                    {
                        break;
                    }
                }
                //そもそももう子供がいない場合は終了
                else
                {
                    break;
                }
            }
            return front;
        }

        public override T PeekFront()
        {
            return m_implearray[0];
        }
    }

    class BinaryHeap<TKey, TValue> where TKey : IComparable
    {
    }

    abstract class PriorityQueue<T>
    {
        public abstract void Enqueue(T element_);

        public abstract T Dequeue();

        public abstract T PeekFront();
    }

    class FlexibleArray<T> : IEnumerable<T>
    {
        private int m_nextindex;

        private T[] m_bodyarray;

        public FlexibleArray(int initalsize_ = 128)
        {
            m_nextindex = 0;
            m_bodyarray = new T[initalsize_];
        }

        public void PushBack(T element_)
        {
            //配列サイズをオーバーしてしまったら中身の配列を２倍に拡大
            if (m_nextindex >= m_bodyarray.Length)
                this.ExtendSize(m_nextindex * 2);
            m_bodyarray[m_nextindex] = element_;
            m_nextindex += 1;
        }

        public T PopBack()
        {
            m_nextindex -= 1;
            return m_bodyarray[m_nextindex];
        }

        public void Swap(int a_, int b_)
        {
            T temp;
            temp = m_bodyarray[a_];
            m_bodyarray[a_] = m_bodyarray[b_];
            m_bodyarray[b_] = temp;
        }

        public bool IndexChecker(int index_)
        {
            return index_ >= 0 && index_ < m_nextindex;
        }

        public int Length
        {
            get { return m_nextindex; }
        }

        public T this[int index_]
        {
            get
            {
                if (index_ >= 0 && index_ < m_nextindex)
                    return m_bodyarray[index_];
                else
                    throw new IndexOutOfRangeException();
            }
        }

        private void ExtendSize(int newsize_)
        {
            if (m_bodyarray.Length >= newsize_)
            {
                throw new ArgumentException();
            }
            T[] newarray = new T[newsize_];
            m_bodyarray.CopyTo(newarray, 0);
            m_bodyarray = newarray;
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            throw new NotImplementedException();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }
    }
}

Submission Info

Judge Result