递归--数字黑洞--蓝桥杯

问题描述
　　任意一个四位数，只要它们各个位上的数字是不全相同的，就有这样的规律：
　　1)将组成该四位数的四个数字由大到小排列，形成由这四个数字构成的最大的四位数；
　　2)将组成该四位数的四个数字由小到大排列，形成由这四个数字构成的最小的四位数(如果四个数中含有0，则得到的数不足四位)；
　　3)求两个数的差，得到一个新的四位数(高位零保留)。
　　重复以上过程，最后一定会得到的结果是6174。
　　比如：4312 3087 8352 6174，经过三次变换，得到6174
输入格式
　　一个四位整数，输入保证四位数字不全相同
输出格式
　　一个整数，表示这个数字经过多少次变换能得到6174
样例输入
4312
样例输出
3

　　（1）非递归的办法

 1 #include <iostream>
 2 #include <algorithm>
 3 using namespace std;
 4 int ans=0;
 5 //void dfs()
 6 int main()
 7 {
 8     int a;
 9     int b[4];
10     int m;
11     int n;
12     cin>>a;
13     while(a!=6174)
14     {
15     b[0]=a%10;
16     b[1]=a%100/10;
17     b[2]=a%1000/100;
18     b[3]=a/1000;
19     sort(b,b+4);//从大到小 
20     n=b[0]*1000+b[1]*100+b[2]*10+b[3];
21     m=b[0]*1+b[1]*10+b[2]*100+b[3]*1000;
22    /* for(int i=0;i<4;i++)
23     {
24         cout<<b[i]<<endl;
25     }
26     cout<<"max  "<<m<<endl;
27     cout<<"min  "<<n<<endl;*/
28     a=m-n;
29     ans++;    
30 //    cout<<"jia wei e"<<a<<endl;
31     }
32    cout<<ans;
33     return 0;
34 }

（2）递归的办法

 1 #include <iostream>
 2 #include <algorithm>
 3 using namespace std;
 4 int ans=0;
 5 int b[4];
 6 void dfs(int a)
 7 {
 8      int m;
 9     int n;
10     if(a==6174){
11         return ;
12     }
13     else{
14     b[0]=a%10;
15     b[1]=a%100/10;
16     b[2]=a%1000/100;
17     b[3]=a/1000;
18     sort(b,b+4);//从大到小 
19     n=b[0]*1000+b[1]*100+b[2]*10+b[3];
20     m=b[0]*1+b[1]*10+b[2]*100+b[3]*1000;
21     a=m-n;
22     ans++;    
23     dfs(a);
24     }
25     
26 }
27 int main()
28 {
29     int a;
30     cin>>a;
31     dfs(a);
32    cout<<ans;
33     return 0;
34 }