結果

問題 No.917 Make One With GCD
ユーザー ひばちひばち
提出日時 2019-10-25 23:06:50
言語 C#(csc)
(csc 3.9.0)
結果
WA  
実行時間 -
コード長 7,878 bytes
コンパイル時間 1,179 ms
コンパイル使用メモリ 65,660 KB
実行使用メモリ 25,888 KB
最終ジャッジ日時 2023-10-11 08:08:48
合計ジャッジ時間 5,612 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge11
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 73 ms
23,740 KB
testcase_01 AC 70 ms
23,796 KB
testcase_02 AC 69 ms
23,876 KB
testcase_03 AC 69 ms
23,896 KB
testcase_04 AC 69 ms
23,860 KB
testcase_05 AC 68 ms
21,848 KB
testcase_06 AC 74 ms
23,888 KB
testcase_07 AC 73 ms
21,736 KB
testcase_08 AC 73 ms
21,656 KB
testcase_09 WA -
testcase_10 WA -
testcase_11 WA -
testcase_12 WA -
testcase_13 WA -
testcase_14 WA -
testcase_15 WA -
testcase_16 WA -
testcase_17 AC 71 ms
19,772 KB
testcase_18 WA -
testcase_19 AC 70 ms
21,808 KB
testcase_20 AC 71 ms
19,624 KB
testcase_21 WA -
testcase_22 AC 72 ms
21,752 KB
testcase_23 WA -
testcase_24 WA -
testcase_25 WA -
testcase_26 AC 71 ms
21,684 KB
testcase_27 AC 72 ms
21,908 KB
testcase_28 AC 68 ms
21,840 KB
testcase_29 AC 71 ms
21,668 KB
testcase_30 AC 72 ms
21,768 KB
testcase_31 AC 72 ms
21,768 KB
testcase_32 AC 71 ms
21,696 KB
testcase_33 AC 72 ms
21,740 KB
testcase_34 AC 72 ms
21,912 KB
testcase_35 AC 72 ms
23,880 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using static Template;

namespace SolveSpace
{
    using static System.Console;
    using static System.Convert;
    using static System.Math;
    using Pi = Pair<int, int>;
    using Number = System.Int64;

    class Solver
    {
        public void Solve()
        {
            var num = Input.num;
            var ar = Input.ar;
            var dic = new Dictionary<long, List<int>>();
            for(var i = 0; i < num; i++)
            {
                var f = Factorize(ar[i]);
                foreach(var d in f.Keys)
                {
                    if (!dic.ContainsKey(d))
                        dic[d] = new List<int>();
                    dic[d].Add(i);
                }
            }
            var uf = new UnionFind(num);
            var res = (long)ar.Count(a => a != 1);
            foreach (var d in dic.Values)
            {
                var ct = new int[num];
                for (var i = 0; i < d.Count; i++)
                    ct[uf.Parent(d[i])]++;
                var r = 1L;var q = 0L;
                for (var i = 0; i < num; i++)
                    if (ct[i] != 0)
                    {
                        r *= 1L << ct[i];
                        q += (1L << ct[i])-1;
                    }
                res += r - q-1;
                for (var i = 1; i < d.Count; i++)
                    uf.Union(d[i - 1], d[i]);
            }
            WriteLine((1L << num) - res - 1);
        }

        public static Dictionary<long, int> Factorize(long num)
        {
            var dic = new Dictionary<long, int>();
            for (var i = 2L; i * i <= num; i++)
            {
                var ct = 0;
                while (num % i == 0)
                {
                    ct++;
                    num /= i;
                }
                if (ct != 0) dic[i] = ct;
            }
            if (num != 1) dic[num] = 1;
            return dic;
        }

    }

    public class UnionFind
    {
        protected int[] parent, size, rank;
        public UnionFind(int num)
        {
            parent = new int[num]; size = new int[num]; rank = new int[num];
            for (var i = 0; i < num; i++) { parent[i] = i; size[i] = 1; }
        }
        protected int Find(int i)
            => i == parent[i] ? i : (parent[i] = Find(parent[i]));
        public int Parent(int i)
            => Find(i);
        public int Size(int i)
            => size[Find(i)];
        public virtual bool Union(int v1, int v2)
        {
            v1 = Find(v1); v2 = Find(v2);
            if (v1 == v2) return false;
            if (rank[v1] < rank[v2])
                swap(ref v1, ref v2);
            parent[v2] = v1;
            size[v1] += size[v2];
            if (rank[v1] == rank[v2])
                rank[v1]++;
            return true;
        }
        public bool IsSame(int v1, int v2)
            => Find(v1) == Find(v2);
    }
}

#region Template
public class Template
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T num, T val) where T : IComparable<T>
    { if (num.CompareTo(val) == 1) { num = val; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T num, T val) where T : IComparable<T>
    { if (num.CompareTo(val) == -1) { num = val; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T v1, ref T v2)
    { var t = v2; v2 = v1; v1 = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T[] Create<T>(int n, Func<T> f)
        => Enumerable.Repeat(0, n).Select(_ => f()).ToArray();
    public static void Fail() => Fail("No");
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
    static void Main(string[] args)
    {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        Console.SetOut(sw);
        var p = new SolveSpace.Solver();
        for (var i = 1; i > 0; --i)
            p.Solve();
        Console.Out.Flush();
    }
}

public class Input
{
    public static string read => Console.ReadLine().Trim();
    public static int[] ar => read.Split(' ').Select(int.Parse).ToArray();
    public static int num => Convert.ToInt32(read);
    public static long[] arL => read.Split(' ').Select(long.Parse).ToArray();
    public static long numL => Convert.ToInt64(read);
    public static char[][] grid(int h)
        => Create(h, () => read.ToCharArray());
    public static int[] ar1D(int n)
        => Create(n, () => num);
    public static long[] arL1D(int n)
        => Create(n, () => numL);
    public static string[] strs(int n)
        => Create(n, () => read);
    public static int[][] ar2D(int n)
        => Create(n, () => ar);
    public static long[][] arL2D(int n)
        => Create(n, () => arL);
    public static List<T>[] edge<T>(int n)
        => Create(n, () => new List<T>());
    public static void Make<T1, T2>(out T1 v1, out T2 v2)
    {
        v1 = Next<T1>();
        v2 = Next<T2>();
    }
    public static void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3)
    {
        Make(out v1, out v2);
        v3 = Next<T3>();
    }
    public static void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4)
    {
        Make(out v1, out v2, out v3);
        v4 = Next<T4>();
    }
    public static void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5)
    {
        Make(out v1, out v2, out v3, out v4);
        v5 = Next<T5>();
    }
    public static void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6)
    {
        Make(out v1, out v2, out v3, out v4, out v5);
        v6 = Next<T6>();
    }
    static Input()
    {
        sc = new Queue<string>();
        dic = new Dictionary<Type, Func<string, object>>();
        dic[typeof(int)] = s => int.Parse(s);
        dic[typeof(long)] = s => long.Parse(s);
        dic[typeof(char)] = s => char.Parse(s);
        dic[typeof(double)] = s => double.Parse(s);
        dic[typeof(uint)] = s => uint.Parse(s);
        dic[typeof(ulong)] = s => ulong.Parse(s);
        dic[typeof(string)] = s => s;
    }
    private static Dictionary<Type, Func<string, object>> dic;
    private static Queue<string> sc;
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static T Next<T>() { if (sc.Count == 0) foreach (var item in read.Split(' ')) sc.Enqueue(item); return (T)dic[typeof(T)](sc.Dequeue()); }
    public const int MOD = 1000000007;
}

public class Pair<T1, T2> : IComparable<Pair<T1, T2>>
{
    public T1 v1;
    public T2 v2;
    public Pair() { v1 = Input.Next<T1>(); v2 = Input.Next<T2>(); }
    public Pair(T1 v1, T2 v2)
    { this.v1 = v1; this.v2 = v2; }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public int CompareTo(Pair<T1, T2> p)
    {
        var c = Comparer<T1>.Default.Compare(v1, p.v1);
        if (c == 0)
            c = Comparer<T2>.Default.Compare(v2, p.v2);
        return c;
    }
    public override string ToString()
        => $"{v1.ToString()} {v2.ToString()}";
}

public class Pair<T1, T2, T3> : Pair<T1, T2>, IComparable<Pair<T1, T2, T3>>
{
    public T3 v3;
    public Pair() : base() { v3 = Input.Next<T3>(); }
    public Pair(T1 v1, T2 v2, T3 v3) : base(v1, v2)
    { this.v3 = v3; }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public int CompareTo(Pair<T1, T2, T3> p)
    {
        var c = base.CompareTo(p);
        if (c == 0)
            c = Comparer<T3>.Default.Compare(v3, p.v3);
        return c;
    }
    public override string ToString()
        => $"{base.ToString()} {v3.ToString()}";
}
#endregion
0