poj 1016 Numbers That Count

点击打开链接

Numbers That Count

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 17922		Accepted: 5940

Description

"Kronecker's Knumbers" is a little company that manufactures plastic digits for use in signs (theater marquees, gas station price displays, and so on). The owner and sole employee, Klyde Kronecker, keeps track of how many digits of each type he has used by
maintaining an inventory book. For instance, if he has just made a sign containing the telephone number "5553141", he'll write down the number "5553141" in one column of his book, and in the next column he'll list how many of each digit he used: two 1s, one
3, one 4, and three 5s. (Digits that don't get used don't appear in the inventory.) He writes the inventory in condensed form, like this: "21131435". 



The other day, Klyde filled an order for the number 31123314 and was amazed to discover that the inventory of this number is the same as the number---it has three 1s, one 2, three 3s, and one 4! He calls this an example of a "self-inventorying number", and
now he wants to find out which numbers are self-inventorying, or lead to a self-inventorying number through iterated application of the inventorying operation described below. You have been hired to help him in his investigations. 



Given any non-negative integer n, its inventory is another integer consisting of a concatenation of integers c1 d1 c2 d2 ... ck dk , where each ci and di is an unsigned integer, every ci is positive, the di satisfy 0<=d1<d2<...<dk<=9, and, for each digit d
that appears anywhere in n, d equals di for some i and d occurs exactly ci times in the decimal representation of n. For instance, to compute the inventory of 5553141 we set c1 = 2, d1 = 1, c2 = 1, d2 = 3, etc., giving 21131435. The number 1000000000000 has
inventory 12011 ("twelve 0s, one 1"). 



An integer n is called self-inventorying if n equals its inventory. It is called self-inventorying after j steps (j>=1) if j is the smallest number such that the value of the j-th iterative application of the inventory function is self-inventorying. For instance,
21221314 is self-inventorying after 2 steps, since the inventory of 21221314 is 31321314, the inventory of 31321314 is 31123314, and 31123314 is self-inventorying. 



Finally, n enters an inventory loop of length k (k>=2) if k is the smallest number such that for some integer j (j>=0), the value of the j-th iterative application of the inventory function is the same as the value of the (j + k)-th iterative application. For
instance, 314213241519 enters an inventory loop of length 2, since the inventory of 314213241519 is 412223241519 and the inventory of 412223241519 is 314213241519, the original number (we have j = 0 in this case). 



Write a program that will read a sequence of non-negative integers and, for each input value, state whether it is self-inventorying, self-inventorying after j steps, enters an inventory loop of length k, or has none of these properties after 15 iterative applications
of the inventory function.

Input

A sequence of non-negative integers, each having at most 80 digits, followed by the terminating value -1. There are no extra leading zeros.

Output

For each non-negative input value n, output the appropriate choice from among the following messages (where n is the input value, j is a positive integer, and k is a positive integer greater than 1): 

n is self-inventorying 

n is self-inventorying after j steps 

n enters an inventory loop of length k 

n can not be classified after 15 iterations

Sample Input

22
31123314
314213241519
21221314
111222234459
-1

Sample Output

22 is self-inventorying
31123314 is self-inventorying
314213241519 enters an inventory loop of length 2
21221314 is self-inventorying after 2 steps
111222234459 enters an inventory loop of length 2 

题目大意：给一个大数，问我们经过多少次操作以后可以得到一个循环，操作的方法就是统计这个数中由小到大的数字出现的次数，然后写成  （数字1出现次数）1（数字2出现次数）2这样的形式，没有这个数字就不写。

问经过多少次操作可以出现循环，。循环的结果有4种：

1、本身就是一个循环，就是说数字a操作一个还是数字a : a->a->a->a

2、经过n步以后变成条件1的情况:a->b->c->c->c->c->c

3、经过n步以后构成了一个环:a->b->c->a->b->c

4、经过15次操作依然没出现以上3种情况

题目就是一个模拟题，不过判重我用了一个map把字符串映射一个数字，但速度很慢 200+ms，后来看了别人的思路，就是存在一个字符串数组里顺序比较就行了，效率很高32MS，看来是我想太多了。。。。

#include<stdio.h>
#include<map>
#include<string>
#include<string.h>
#include<iostream>
using namespace std;
string solve(string str)
{
	int i;
	int hash[10] = {0};
	int len = str.length();
	for(i = 0; i < len; i++)
	{
		hash[str[i] - '0'] ++;
	}
	string new_str;
	char ch[30] = {0};
	for(i = 0; i < 10; i++)
	{
		if(hash[i] != 0)
		{
			sprintf(ch, "%d%d", hash[i], i);
			new_str.append(ch);
 
		}
	}
	return new_str;
}
int main()
{
//	freopen("in.txt", "r", stdin);
	string s;
	while(cin >> s)
	{
		if(s == "-1")
			break;
		map<string, int> mymap;
		mymap[s] = 0;
		string new_str = s, prev;
		int i;
		int flag = 0;
		for(i = 1; i < 16; i++)
		{
			prev = new_str;
			new_str = solve(new_str);
			if(prev == new_str)
			{
				flag = 1;
				break;
			}
			if(mymap[new_str] != 0)
			{
				flag = i - mymap[new_str];
				break;
			}
			else
				mymap[new_str] = i;
		}
		if(i == 1)
			cout << s << " is self-inventorying" << endl;
		else if(i < 16)
		{
			if(flag == 1)
				cout <<	s << " is self-inventorying after " << i  - 1 << " steps" << endl;
			else
				cout << s << " enters an inventory loop of length " << flag << endl;
		}
		else
			cout << s << " can not be classified after 15 iterations" << endl;
	}
	return 0;
}