結果

問題 No.14 最小公倍数ソート
ユーザー warashiwarashi
提出日時 2015-11-21 11:32:12
言語 Go
(1.22.1)
結果
TLE  
実行時間 -
コード長 1,489 bytes
コンパイル時間 11,635 ms
コンパイル使用メモリ 228,868 KB
実行使用メモリ 12,288 KB
最終ジャッジ日時 2024-04-19 03:34:03
合計ジャッジ時間 19,092 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
5,248 KB
testcase_01 AC 1 ms
5,248 KB
testcase_02 AC 1 ms
5,376 KB
testcase_03 AC 1,036 ms
6,016 KB
testcase_04 TLE -
testcase_05 -- -
testcase_06 -- -
testcase_07 -- -
testcase_08 -- -
testcase_09 -- -
testcase_10 -- -
testcase_11 -- -
testcase_12 -- -
testcase_13 -- -
testcase_14 -- -
testcase_15 -- -
testcase_16 -- -
testcase_17 -- -
testcase_18 -- -
testcase_19 -- -
権限があれば一括ダウンロードができます

ソースコード

diff # 

package main

import (
	"fmt"
	"sort"
)

func prime() func() int {
	var primes []int
	i := 2
	_isPrime := func(n int) bool {
		for _, p := range primes {
			if p > n*n {
				break
			}
			if n%p == 0 {
				return false
			}
		}
		return true
	}
	return func() int {
		for !_isPrime(i) {
			i++
		}
		primes = append(primes, i)
		return i
	}
}

func primeFactorization(n int) (factor map[int]int) {
	factor = make(map[int]int)
	primes := prime()
	for {
		d := primes()
		if d > n*n {
			break
		}
		for n%d == 0 {
			n /= d
			factor[d]++
		}
	}
	if n > 1 {
		factor[n]++
	}
	return
}

func divisors(num int) []int {
	primeFactors := primeFactorization(num)
	var pNum int
	for _, v := range primeFactors {
		pNum *= v + 1
	}
	ret := make([]int, 0, pNum)
	ret = append(ret, 1)

	for p, k := range primeFactors {
		for _, x := range ret {
			for i := 0; i < k; i++ {
				x *= p
				ret = append(ret, x)
			}
		}
	}
	sort.Ints(ret)
	return ret
}

var dp, m [10001]int

func main() {
	var N int
	fmt.Scan(&N)
	A := make([]int, N)
	for i := 0; i < N; i++ {
		fmt.Scan(&A[i])
		m[A[i]]++
	}

	next := A[0]
	m[next]--
	fmt.Print(next)

	for i := 0; i < N-1; i++ {
		divisor := divisors(next)
		check := 99999
		ans := 0

		for _, d := range divisor {
			for d*dp[d] <= 10000 {
				if m[d*dp[d]] > 0 {
					if check <= dp[d] {
						break
					}
					ans = d * dp[d]
					check = dp[d]
				} else {
					dp[d]++
				}
			}
		}

		next = ans
		m[next]--
		fmt.Print(" ", next)
	}
	fmt.Print("\n")
}
0