poj 1016 Numbers That Count

//由于使用了c++，所以超时了，改为c语言才可以！ 
#include "iostream"
#include "string"
#include "memory.h"
#include "vector"
#include "sstream"
using namespace std;

int c[10];
vector<string> v;//储存15个字符串转换的结果 

string countnum(string str)//将字符串进行转换 
{
    string ans;
    ans.clear();
    int len, i;
    len = str.length();
    memset(c, 0, sizeof(c));
    for (i = 0; i < len; i++)
    {
        switch(str[i])
        {
           case '0': c[0]++;
           break;
           case '1': c[1]++;
           break;
           case '2': c[2]++;
           break;
           case '3': c[3]++;
           break;
           case '4': c[4]++;
           break;
           case '5': c[5]++;
           break;
           case '6': c[6]++;
           break;
           case '7': c[7]++;
           break;
           case '8': c[8]++;
           break;
           case '9': c[9]++;
           break;
        }
    }
    for (i = 0; i < 10; i++)
    {
        if (c[i] != 0)
        {
            if (c[i] >= 10)//注意大于10时候的处理 
            {
                stringstream s;
                s << c[i];
                string temp;
                s >> temp;
                ans += temp;
            }
            else
                ans.push_back(c[i]+48);
            ans.push_back(i+48);
        }
    }
    
    return ans;
}

int main()
{
    string input;
    string temp;
    while (cin >> input && input != "-1")
    {
          temp = countnum(input);
          v.clear();
          if (temp == input)//第一种情况的输出！ 
             cout << input << " is self-inventorying" << endl;
          else
          {
              v.push_back(input);
              v.push_back(temp);
              int size = v.size();
              while (size < 15)
              {
                   temp = countnum(temp);
                   v.push_back(temp);
                   size = v.size();
              }
              bool flag = false;
              for (int i = 1; i < 15; i++)
              {
                  if (flag)  break;
                 for (int j = i-1; j >= 0; j--)
                 {
                     if (v[i] == v[j])
                     {
                         int dis = i - j;
                         if (dis == 1)//第二种情况的输出 
                         {
                            flag = true;
                            cout << input << " is self-inventorying after " << i - 1 << " steps" << endl;
                            break;
                         }
                         else//第三种情况的输出 
                         {
                             flag = true;
                             cout << input << " enters an inventory loop of length " << dis << endl;
                             break;
                         }
                     }
                 }
              }
                 if (!flag)//第四种情况的输出 
                    cout << input << " can not be classified after 15 iterations" << endl;
          }
    }
    system("pause");
}

/*
22
31123314
314213241519
21221314
111222231159
123456789
654641656
2101400052100005496
10000000000000000000
333
1
99999999999999999999999999999999999999999999999999999999999999999999999999999999
0000
0001
0111
1111
456137892
123213241561
543265544536464364
5412314454766464364
543267685643564364
5423434560121016464364
*/






#include<iostream>
#include<string>
using namespace std;

/*压缩数字串n，存放到t*/
void R(char* n,char* t)
{
	int i,j;
	int time[10]={0};  //记录n中各个数字出现的次数
	for(i=0;n[i];i++)
		time[ n[i]-'0' ]++;

	for(i=0,j=0;i<10;i++)
	{
		if(time[i])
		{
			if(time[i]<10)  //数字i出现次数<10，即占1位
			{
				t[j++]=time[i]+'0';
				t[j++]=i+'0';
			}
			else    //数字i出现次数>=10，即占2位
			{
				t[j++]=time[i]/10+'0';
				t[j++]=time[i]%10+'0';
				t[j++]=i+'0';
			}
		}
	}
	t[j]='\0';

	return;
}

int main(int i,int j)
{
	char n[16][85];    //n[0]为原串，n[1~15]分别为n连续压缩15次的数字串

	while(cin>>n[0] && n[0][0]!='-')
	{
		bool flag1=false;    //属性1，n is self-inventorying
		int flag2=0;         //属性2，n is self-inventorying after j steps，顺便记录j
		int flag3=0;         //属性3，n is enters an inventory loop of length k，顺便记录k

		for(i=1;i<=15;i++)
			R(n[i-1],n[i]);

		if(!strcmp(n[0],n[1]))  //属性1，n压缩1次就是其本身
			flag1=true;

		if(!flag1)
		{
			for(j=1;j<15;j++)
				if(!strcmp(n[j],n[j+1]))  //属性2, n压缩j次后的数字串n[j]具有属性1
				{
					flag2=j;
					break;
				}

			if(!flag2)
			{
				for(j=1;j<=15;j++)  //属性3，两两枚举各次压缩的数字串，注意循环间隔>=2
				{
					for(i=0;i<=j-2;i++)
					{
						if(!strcmp(n[j],n[i]))
						{
							flag3=j-i;
							break;
						}
					}
					if(flag3)
						break;
				}
			}
		}

		if(flag1)
			cout<<n[0]<<" is self-inventorying"<<endl;
		else if(flag2)
			cout<<n[0]<<" is self-inventorying after "<<flag2<<" steps"<<endl;
		else if(flag3)
			cout<<n[0]<<" enters an inventory loop of length "<<flag3<<endl;
		else
			cout<<n[0]<<" can not be classified after 15 iterations"<<endl;
	}
	return 0;
}