project euler 74

Problem 74

---

Digit factorial chains

The number 145 is well known for the property that the sum of the factorial of its digits is equal to 145:

1! + 4! + 5! = 1 + 24 + 120 = 145

Perhaps less well known is 169, in that it produces the longest chain of numbers that link back to 169; it turns out that there are only three such loops that exist:

169 → 363601 → 1454 → 169
871 → 45361 → 871
872 → 45362 → 872

It is not difficult to prove that EVERY starting number will eventually get stuck in a loop. For example,

69 → 363600 → 1454 → 169 → 363601 (→ 1454)
78 → 45360 → 871 → 45361 (→ 871)
540 → 145 (→ 145)

Starting with 69 produces a chain of five non-repeating terms, but the longest non-repeating chain with a starting number below one million is sixty terms.

How many chains, with a starting number below one million, contain exactly sixty non-repeating terms?

---

数字阶乘链

145之所以广为人知，是因为它的各位数字的阶乘之和恰好等于本身：

1! + 4! + 5! = 1 + 24 + 120 = 145

而169则可能不太为人所知，尽管从169开始不断地取各位数字的阶乘之和构成了最长的循环回到169；事实上，只存在三个这样的循环：

169 → 363601 → 1454 → 169
871 → 45361 → 871
872 → 45362 → 872

不难证明，从任意数字出发最终都会陷入循环。例如，

69 → 363600 → 1454 → 169 → 363601 (→ 1454)
78 → 45360 → 871 → 45361 (→ 871)
540 → 145 (→ 145)

从69开始可以得到一个拥有五个不重复项的链，但是从一个小于一百万的数出发能够得到的最长的无重复项链包含有60项。

从小于一百万的数出发，有多少条链恰好包含有60个不重复项？

package projecteuler;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;

public class Prj74 extends TestCase {

	public static int UP_LIMIT = 1000000;
	//public static int UP_LIMIT = 69 + 1;

	/**
	 * 用map保存中间结果还可优化
	 */
	public void testDigitFactorialChains() {

		int count = 0;
		for (int i = 69; i < UP_LIMIT; i++) {
			if( getCycle(i) == 60){
				count += 1;
				//System.out.println(i);
			}
		}
		System.out.println(count);
	}

	int getCycle(int n) {
		List<Integer> cycle = new ArrayList<Integer>();
		cycle.add(n);
		
		int tp = n;
		while (true) {
			int[] arr = int2Arr(tp);
			tp = calculate(arr);
			if (cycle.contains(tp)) {
				break;
			}
			cycle.add(tp);
		}
		return cycle.size();
	}

	int[] int2Arr(int val) {
		String str = Integer.toString(val);
		int[] ret = new int[str.length()];
		for (int i = 0; i < ret.length; i++) {
			ret[i] = Integer.parseInt(String.valueOf(str.charAt(i)));
		}
		return ret;
	}

	int getIntArrVal(int[] arr) {
		int val = 0;
		for (int i = 0; i < arr.length; i++) {
			val = val * 10 + arr[i];
		}

		return val;
	}

	int calculate(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += getNN(arr[i]);
		}
		return sum;
	}

	int getNN(int n) {
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		map.put(0, 1);
		map.put(1, 1);
		map.put(2, 2);
		map.put(3, 3 * 2);
		map.put(4, 4 * 3 * 2);
		map.put(5, 5 * 4 * 3 * 2);
		map.put(6, 6 * 5 * 4 * 3 * 2);
		map.put(7, 7 * 6 * 5 * 4 * 3 * 2);
		map.put(8, 8 * 7 * 6 * 5 * 4 * 3 * 2);
		map.put(9, 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2);

		return map.get(n);
	}

}