[已解决]c++改写成c

greenery

踩气球问题，我直接把答案c++改成c出现了奇怪的bug help
踩气球描述：
六一儿童节，小朋友们做踩气球游戏，气球的编号是1～100，两位小朋友各踩了一些气球，要求他们报出自己所踩气球的编号的乘积。现在需要你编一个程序来判断他们的胜负，判断的规则是这样的：如果两人都说了真话，数字大的人赢；如果两人都说了假话，数字大的人赢；如果报小数字的人说的是真话而报大数字的人说谎，则报小数字的人赢（注意：只要所报的小数字是有可能的，即认为此人说了真话）。
输入：
输入为两个数字，0 0表示结束；
输出：
输出为获胜的数字。
输入样例：
36 62 49 343 0 0
输出样例：
62 49

答案代码：

1. #include <iostream>
   
2. #include <string.h>
   
3. using namespace std;
   
4. 
   
5. /*        "注意：只要所报的小数字是有可能的，即认为此人说了真话",
   
6.         这句话的意思是要先判断小数字，报小数字的小朋友踩过的气球，
   
7.         则报大数字的小朋友无法再踩，
   
8.         因此要做一个访问标记
   
9.         这题的主体的思路是 假设判断数字 n 能否由1到100之间的数字相乘得到，
   
10.         则判断 n % k == 0 ? dfs(n / k, k-1) : dfs(n, k-1) 依次判断下去，如果  
    
11.         n == 1 说明能找到1到100之间的且不重复的数相乘等于原来的n
    
12. */
    
13. 
    
14. //标记是否访问
    
15. bool vis[101];
    
16. 
    
17. bool dfs(int n, int k)
    
18. {
    
19.         if(n == 1)
    
20.         {
    
21.                 return true;
    
22.         }
    
23. 
    
24. 
    
25.         if(k>1)
    
26.         {
    
27.                 if(n % k == 0 && vis[k] == 0)
    
28.                 {
    
29.                         vis[k] = 1;
    
30.                         return dfs(n / k, k - 1);
    
31. 
    
32.                 }
    
33.                 else
    
34.                 {
    
35.                         return dfs(n, k-1);
    
36.                 }
    
37.         }
    
38.         return false;
    
39. }
    
40. 
    
41. int main(int argc, char const *argv[])
    
42. {
    
43.         int a, b, low, high;
    
44.         bool flag1, flag2;
    
45.         while(cin>>a>>b && (a!=0 && b!=0))
    
46.         {
    
47.                 if(a > b)
    
48.                 {
    
49.                         low = b;
    
50.                         high = a;
    
51.                 }
    
52.                 else
    
53.                 {
    
54.                         low = a;
    
55.                         high = b;
    
56.                 }
    
57. 
    
58.                 memset(vis, 0, sizeof(vis));
    
59. 
    
60.                 flag1 = dfs(low, 100);
    
61.                 flag2 = dfs(high, 100);
    
62. 
    
63.                 if((flag1 && flag2) || (!flag1 && !flag2))
    
64.                 {
    
65.                         cout<<high<<endl;
    
66.                 }
    
67.                 else if (flag1 && !flag2)
    
68.                 {
    
69.                         cout<<low<<endl;
    
70.                 }
    
71.                 else
    
72.                 {
    
73.                         cout<<high<<endl;
    
74.                 }
    
75. 
    
76.         }
    
77.         return 0;
    
78. }

复制代码

我的c：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. int num1,num2;
   
4. int flag1,flag2;
   
5. int balloon[101];
   
6. int result[1000],count=1;
   
7. enum{false,true};
   
8. //有问题
   
9. int Do(int currnum,int currballoon)
   
10. {
    
11.         if(currnum==1)
    
12.         {
    
13.                 return true;
    
14.         }
    
15.         else if(currnum>1)
    
16.         {
    
17.                 if(currnum%currballoon==0&&balloon[currballoon]==0)
    
18.                 {
    
19.                         balloon[currballoon]=1;
    
20.                         return Do(currnum/currballoon,currballoon-1);
    
21.                 }
    
22.                 else
    
23.                 {
    
24.                         return Do(currnum,currballoon-1);
    
25.                 }
    
26.                
    
27.         }
    
28.         return false;
    
29. }
    
30. 
    
31. int main(void)
    
32. {
    
33.         int a,b,i;//a-high,b-low;
    
34.         while(1)
    
35.         {
    
36.                 scanf("%d%d",&num1,&num2);
    
37.                 if(num1==0&&num2==0)break;
    
38.                 if(num1>num2)
    
39.                 {
    
40.                         a=num1,b=num2;
    
41.                 }
    
42.                 else
    
43.                 {
    
44.                         a=num2,b=num1;
    
45.                 }
    
46.                 for(i=1;i<=100;i++)
    
47.                 {
    
48.                         balloon[i]=0;
    
49.                 }
    
50.                 //memset(balloon,0,sizeof(balloon));
    
51.                 flag1=Do(a,100);
    
52.                 flag2=Do(b,100);
    
53.                 if(flag1&&flag2||!flag1&&!flag2)
    
54.                 {
    
55.                         result[count++]=a;
    
56.                 }
    
57.                 else if(!flag1&&flag2)
    
58.                 {
    
59.                         result[count++]=b;
    
60.                 }
    
61.                 else
    
62.                 {
    
63.                         result[count++]=a;
    
64.                 }
    
65.         }
    
66.         for(i=1;i<count;i++)
    
67.         {
    
68.                 printf("%d\n",result[i]);
    
69.         }
    
70.        
    
71.         return 0;
    
72. }
    

复制代码

最佳答案

月排行榜 / 总排行榜

xieglt

2020-10-19 16:13:06

原答案也不严谨。
比如说输入 64 ，64 分解因数如下
64 = 2*32
64 = 4 * 16
64 = 1 * 64
64 = 2 * 4 * 8
64 = 1 * 2 * 4 * 8
等等等等，如何确定哪些气球是他踩的呢？没法确定，严谨的做法要把所有可能性都排除出来。
跟答案相比，你的代码有一个问题：

答案是：

1. 
   
2. bool dfs(int n, int k)
   
3. {
   
4.     //这里是n
   
5.     if(n == 1)
   
6.         {
   
7.                 return true;
   
8.         }
   
9. 
   
10.    //这里是k   
    
11.    if(k>1)
    
12.       {
    
13.            ....
    
14.       }
    
15.       return false;
    
16. }
    

复制代码

而你的代码是：

1. 
   
2. int Do(int currnum,int currballoon)
   
3. {
   
4.         //对应 n 没错
   
5.         if(currnum==1)
   
6.         {
   
7.                 return true;
   
8.         }
   
9.         //这里应该改成 if(currballoon > 1)
   
10.         else if(currnum>1)
    
11.         {
    
12.              ...
    
13.         }
    
14.      return false;
    
15. }
    

复制代码

按你的代码逻辑，最后总是返回 true ,或者递归出不来导致堆栈溢出 stack overflow

跳转到最佳答案楼层

xieglt

原答案也不严谨。
比如说输入 64 ，64 分解因数如下
64 = 2*32
64 = 4 * 16
64 = 1 * 64
64 = 2 * 4 * 8
64 = 1 * 2 * 4 * 8
等等等等，如何确定哪些气球是他踩的呢？没法确定，严谨的做法要把所有可能性都排除出来。
跟答案相比，你的代码有一个问题：

答案是：

1. 
   
2. bool dfs(int n, int k)
   
3. {
   
4.     //这里是n
   
5.     if(n == 1)
   
6.         {
   
7.                 return true;
   
8.         }
   
9. 
   
10.    //这里是k   
    
11.    if(k>1)
    
12.       {
    
13.            ....
    
14.       }
    
15.       return false;
    
16. }
    

复制代码

而你的代码是：

1. 
   
2. int Do(int currnum,int currballoon)
   
3. {
   
4.         //对应 n 没错
   
5.         if(currnum==1)
   
6.         {
   
7.                 return true;
   
8.         }
   
9.         //这里应该改成 if(currballoon > 1)
   
10.         else if(currnum>1)
    
11.         {
    
12.              ...
    
13.         }
    
14.      return false;
    
15. }
    

复制代码

按你的代码逻辑，最后总是返回 true ,或者递归出不来导致堆栈溢出 stack overflow

greenery

xieglt 发表于 2020-10-19 16:13
原答案也不严谨。
比如说输入 64 ，64 分解因数如下
64 = 2*32

太对了，我自己都看花眼了

greenery

“注意：只要所报的小数字是有可能的，即认为此人说了真话”加上这句话应该题目没问题