結果

問題 No.178 美しいWhitespace (1)
ユーザー syoken_desukasyoken_desuka
提出日時 2015-04-05 23:50:28
言語 C#(csc)
(csc 3.9.0)
結果
WA  
実行時間 -
コード長 11,930 bytes
コンパイル時間 996 ms
コンパイル使用メモリ 118,064 KB
実行使用メモリ 26,180 KB
最終ジャッジ日時 2024-07-04 02:14:36
合計ジャッジ時間 2,518 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 25 ms
25,960 KB
testcase_01 AC 25 ms
24,100 KB
testcase_02 AC 24 ms
23,920 KB
testcase_03 AC 26 ms
24,052 KB
testcase_04 WA -
testcase_05 WA -
testcase_06 WA -
testcase_07 AC 27 ms
26,088 KB
testcase_08 WA -
testcase_09 WA -
testcase_10 WA -
testcase_11 AC 27 ms
26,160 KB
testcase_12 AC 26 ms
26,040 KB
testcase_13 WA -
testcase_14 WA -
testcase_15 WA -
testcase_16 WA -
testcase_17 WA -
testcase_18 AC 26 ms
24,048 KB
testcase_19 WA -
testcase_20 AC 26 ms
24,240 KB
testcase_21 WA -
testcase_22 WA -
testcase_23 AC 26 ms
24,048 KB
testcase_24 AC 26 ms
25,908 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
Microsoft (R) Visual C# Compiler version 3.9.0-6.21124.20 (db94f4cc)
Copyright (C) Microsoft Corporation. All rights reserved.

ソースコード

diff # 

#region ZIPPER
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using sc = Scanner;
//using Geometry;
//using gl = Geometry.GeometryLibrary;
class Program
{
    static void Main(string[] args)
    {
        Solver solver = new Solver();
        solver.Solve();
#if DEBUG
        System.Console.WriteLine("続行するには何かキーを押してください．．．");
        System.Console.ReadKey();
#endif

    }
}
/// <summary>
/// 標準入力読み取り支援，自作（某最速の人を参考）
/// </summary>

#endregion ZIPPER

public class Solver
{
    #region IGNORE_ME
    public Solver()
    {
        //こんすとらくたん　きにしなくてよろしい
    }
    #endregion IGNORE_ME

    public int MOD = 1000000007;

    public void Solve()
    {
        int n = sc.NextInt();
        int[][] ab = new int[n][];
        int maxLine = 0;
        int answer = 0;
        for (int i = 0; i < n; i++)
        {
            ab[i] = sc.NextIntArray();
        }
        int[] k = new int[n];
        for (int i = 0; i < n; i++)
        {
            k[i] = ab[i][0] + 4 * ab[i][1];
            if (k[i] > maxLine)
            {
                maxLine = k[i];
            }
        }
        int oddOrEven = k[0] % 2;
        for (int i = 0; i < k.Length; i++)
        {
            if (k[i] % 2 != oddOrEven)
            {
                Console.WriteLine("-1");
                return;
            }
        }
        for (int i = 0; i < n; i++)
        {
            answer += (maxLine - k[i])/2;
        }
        Console.WriteLine(answer);
        /* nimonme yo
        int h = sc.NextInt();
        int w = sc.NextInt();
        CharInterpreter.AddCorrespondence('#', 1);
        CharInterpreter.AddCorrespondence('.', 0);*/
#if DEBUG
        Console.WriteLine("");//local check
#endif
    }

}



/// <summary>
/// セグメント木
/// </summary>
/// <typeparam name="T">データ型</typeparam>
public class SegmentTree<T>
{

    /// <summary>
    /// 格納可能な数
    /// </summary>
    public int Length { get; private set; }

    /// <summary>
    /// 計算上無効なノードを規定する　最小値→int.MaxValue 参照型→null　など
    /// </summary>
    public T InvalidValue { get; private set; }

    /// <summary>
    /// ２つの区間を結合するときの処理方法を動的に決定する
    /// このとき a 
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public delegate T Marging(T a, T b);

    /// <summary>
    /// 要素が計算上で無効な要素出ることを調べる方法を動的に決定する．
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <returns></returns>
    public delegate bool ComparisonInvalidValue(T a);

    /// <summary>
    /// インデクサで配列っぽく葉の要素の更新が処理できる！ It's cool...
    /// </summary>
    /// <param name="index"></param>
    /// <returns></returns>
    public T this[int index]
    {
        get
        {
            return Data[Length / 2 - 1 + index];
        }
        set
        {
            Update(index, value);
        }
    }

    /// <summary>
    /// 集合，あるいは要素の2つ，A，BからA∩Bを求める．
    /// Tが参照型のとき，新しくインスタンスを生成しないとバグることに注意．
    /// </summary>
    public Marging Marge { get; private set; }

    /// <summary>
    /// 計算に含めてはいけないアイテムかどうか
    /// </summary>
    public ComparisonInvalidValue IsInvalidItem { get; private set; }
    private T[] Data;

    /// <summary>
    /// コンストラクタ
    /// </summary>
    /// <param name="length">最低限確保したい領域，内部ではlength≦2^nを満たす最小の2^n個分確保する．利用上の影響はない</param>
    /// <param name="invalidValue">使わない領域を弾くための無効値</param>
    public SegmentTree(int length, T invalidValue, Marging marge, ComparisonInvalidValue isInvalidValue)
    {
        this.Marge = marge;
        this.InvalidValue = invalidValue;
        this.IsInvalidItem = isInvalidValue;
        //配列を2^n分確保する　lengthより大きめ
        for (int i = 1; ; i *= 2)
            if (i > length)
            {
                Data = new T[2 * i];
                break;
            }
        for (int i = 0; i < Data.Length; i++)
        {
            Data[i] = invalidValue;
        }
        Length = Data.Length / 2;

    }


    /// <summary>
    /// 更新する
    /// </summary>
    /// <param name="k"></param>
    /// <param name="elem"></param>
    public void Update(int k, T elem)
    {
        k += Length - 1;
        Data[k] = elem;
        while (k > 0)
        {
            k = (k - 1) / 2;
            Data[k] = Marge(Data[k * 2 + 1], Data[k * 2 + 2]);
        }
    }

    /// <summary>
    /// 区間に対する問い合わせをlog n で処理する
    /// 求める区間の値は[start,end-1)，言い換えるとstartからend-1までの区間に注目する．（start=endとかするとバグる）
    /// </summary>
    /// <param name="start">配列の始点 0から</param>
    /// <param name="end">配列の終点 n-1＿＿＿　まで</param>
    /// <returns></returns>
    public T RangeQuery(int start, int end)
    {
        return RecursionQuery(start, end, 0, 0, Length);
    }

    private T RecursionQuery(int start, int end, int k, int l, int r)
    {
        if (r <= start || end <= l) return InvalidValue; //区間にかすりすらしない
        if (start <= l && r <= end) return Data[k]; //区間の中にすっぽり入る
        else //交差してるので分割して調べる
        {
            return Marge(
                 RecursionQuery(start, end, k * 2 + 1, l, (l + r) / 2)
               , RecursionQuery(start, end, k * 2 + 2, (l + r) / 2, r)
                );
        }
    }
}




public static class Scanner
{
    public static string NextString()
    {
        string tmp = "";
        while (true)
        {
            int readData;
            string data;
            readData = Console.Read();
            if (readData == -1) //EOF
            {
                break;
            }
            data = char.ConvertFromUtf32(readData);
            if (data == " " || data == "\n")
            {
                break;
            }
            tmp += data;
        }
        return tmp;
    }
    public static int NextInt()
    {
        string tmp = "";
        while (true)
        {
            int readData;
            string data;
            readData = Console.Read();
            if (readData == -1) //EOF
            {
                break;
            }
            data = char.ConvertFromUtf32(readData);
            if (data == " " || data == "\n")
            {
                break;
            }
            tmp += data;
        }
        return int.Parse(tmp);
    }
    public static long NextLong()
    {
        string tmp = "";
        while (true)
        {
            int readData;
            string data;
            readData = Console.Read();
            if (readData == -1) //EOF
            {
                break;
            }
            data = char.ConvertFromUtf32(readData);
            if (data == " " || data == "\n")
            {
                break;
            }
            tmp += data;
        }
        return long.Parse(tmp);
    }
    public static double NextDouble()
    {
        string tmp = "";
        while (true)
        {
            int readData;
            string data;
            readData = Console.Read();
            if (readData == -1) //EOF
            {
                break;
            }
            data = char.ConvertFromUtf32(readData);
            if (data == " " || data == "\n")
            {
                break;
            }
            tmp += data;
        }
        return double.Parse(tmp);
    }

    public static string[] NextStrArray()
    {
        return Console.ReadLine().Split(' ');
    }
    public static int[] NextIntArray()
    {

        string[] s = NextStrArray();
        int[] a = new int[s.Length];
        for (int i = 0; i < a.Length; i++)
        {
            a[i] = int.Parse(s[i]);
        }
        return a;
    }
    public static long[] NextLongArray()
    {
        string[] s = NextStrArray();
        long[] a = new long[s.Length];
        for (int i = 0; i < a.Length; i++)
        {
            a[i] = long.Parse(s[i]);
        }
        return a;
    }
    public static double[] NextDoubleArray()
    {
        string[] s = NextStrArray();
        double[] a = new double[s.Length];
        for (int i = 0; i < a.Length; i++)
        {
            a[i] = double.Parse(s[i]);
        }
        return a;
    }
}

/// <summary>
/// 二次元グリッドなどの文字列で与えられたマップなどで、
/// 手軽にデータ変換を適用するためのクラス
/// </summary>
public static class CharInterpreter
{
    /// <summary>
    /// 変換用辞書
    /// </summary>
    private static Dictionary<char, int> MapToInt = new Dictionary<char, int>(); 
    /// <summary>
    /// 変換法則を追加する
    /// </summary>
    /// <param name="c">char文字</param>
    /// <param name="i">対応する整数値</param>
    public static void AddCorrespondence(char c,int i)
    {
        MapToInt.Add(c,i);
    }
    /// <summary>
    /// 文字列に対して、対応付けされた
    /// 例外処理をしていないので注意
    /// </summary>
    /// <returns>対応対応がなかった場合はバグる；；</returns>
    public static int Inquiry(char c)
    {
        int ret = 0;
        MapToInt.TryGetValue(c, out ret);
        return ret;
    }
    /// <summary>
    /// 指定された変換法則の元でint[,]の二次元平面を生成する
    /// 対応関係がない場合の例外処理をしていないので注意
    /// </summary>
    /// <param name="field">配列の各文字列の長さが全て同じでないとうまく作動しないので注意</param>
    /// <returns> int[ field.length , field[0].length]型の配列 </returns>
    public static int[,] GenerateSquareField(string[] field)
    {
        int[,] ret = new int[field.Length, field[0].Length];
        for (int i = 0; i < field.Length; i++)
        {
            for (int j = 0; j < field[0].Length; j++)
            {
                MapToInt.TryGetValue(field[i][j], out ret[i, j]);
            }
        }
        return ret;
    }
}


/*
 C 40点
    public void Solve()
    {
        int n = sc.NextInt();
        string s = Console.ReadLine();
        int[] c = sc.NextIntArray();
        int[] dp  = new int[n+1];
        for (int i = 1; i < dp.Length; i++)
        {
            dp[i] = int.MaxValue;
        }
        for (int i = 0; i < dp.Length; i++)
        {
            for (int j = i; j <dp.Length; j++)
            {
                if (IsKaibun(s,i,j))
                {

                    dp[j+1] = Math.Min(dp[j+1], dp[i] + c[j-i]);
                }
            }
        }
        Console.WriteLine(dp[n]);
#if DEBUG
        Console.WriteLine("");//local check
#endif
    }

    public bool IsKaibun(string s, int start, int end)
    {
        if (end >= s.Length)
        {
            return false;
        }
#if DEBUG
                    Console.WriteLine(" {0};{1},",start,end);
#endif 
        for (int i = 0; start + i < end - i; i++)
        {
            if (!s[start+i].Equals(s[end - i]))
            {
#if DEBUG
                Console.WriteLine("out" + s[start + i] + " " + s[end - i]);
#endif 
                return false;
            }
        }
#if DEBUG
        Console.WriteLine("OK\n");
#endif 
        return   true;
    }

 */
0