代码逻辑修复求助：运行时错误及栈溢出异常问题

嘿，我看了你写的这个朋友分钱的代码，问题太明显了——你完全没加终止条件啊！这就导致像初始都是3美元的情况，递归会无限调用下去，直接把栈撑爆，难怪会出现StackOverflow和Runtime Error。

先给你理清楚问题出在哪：

原代码的核心问题 #

先贴下你的代码方便分析：

class Program { 
    public int Friends(int a,int b, int c, int d, int count) { 
        int m = b/3 + c/3 + d/3; 
        int n = c/3 + d/3 + a/3; 
        int o = d/3 + a/3 + b/3; 
        int p = a/3 + b/3 + c/3; 
        a=m; b=n; c=o; d=p; 
        count +=1; 
        count = Friends(a,b,c,d,count); 
        return count; 
    } 
    static void Main(){ 
        int count =0; 
        Program p = new Program(); 
        int a = p.Friends(3,3,3,3, count); 
        System.Console.WriteLine(a); 
    } 
}

1. 完全缺失终止条件：当四个人钱数相等时（比如都是3），每次计算后的新钱数还是一模一样的（3/3+3/3+3/3=3），递归会一直调用自己，永远停不下来，直接触发栈溢出。
2. 没处理循环状态：就算不是全相等的情况，也可能出现钱数组合循环往复的情况，同样会导致无限递归。
3. 递归方式的局限：递归调用的层数一旦太多，就容易超过栈的容量，换成迭代写法会更安全稳定。

修复后的代码方案 #

我给你改了个迭代版本，加了必要的终止条件和状态检测，完美解决你的问题：

using System;
using System.Collections.Generic;

class Program
{
    public static int CalculateEqualizationDays(int a, int b, int c, int d)
    {
        int days = 0;
        // 用来记录已经出现过的钱数状态，防止循环
        HashSet<string> seenStates = new HashSet<string>();

        while (true)
        {
            // 生成当前状态的字符串标识，方便检测重复
            string currentState = $"{a},{b},{c},{d}";
            
            // 如果状态重复，说明进入无限循环，返回-1
            if (seenStates.Contains(currentState))
            {
                return -1;
            }
            seenStates.Add(currentState);

            // 计算一轮分钱后的新钱数
            int newA = b / 3 + c / 3 + d / 3;
            int newB = a / 3 + c / 3 + d / 3;
            int newC = a / 3 + b / 3 + d / 3;
            int newD = a / 3 + b / 3 + c / 3;

            // 如果分钱后状态没变化（也就是已经均分了），属于无限循环，返回-1
            if (a == newA && b == newB && c == newC && d == newD)
            {
                return -1;
            }

            // 检查分钱后是否达到均分，如果是，返回当前天数+1
            if (newA == newB && newB == newC && newC == newD)
            {
                return days + 1;
            }

            // 更新钱数，天数加1
            a = newA;
            b = newB;
            c = newC;
            d = newD;
            days++;
        }
    }

    static void Main()
    {
        // 测试初始全3的情况，返回-1
        Console.WriteLine(CalculateEqualizationDays(3, 3, 3, 3));
        
        // 测试初始15,0,0,0的情况，会经过4轮后达到全0，返回4
        Console.WriteLine(CalculateEqualizationDays(15, 0, 0, 0));
    }
}

关键改进说明 #

• 状态跟踪：用HashSet记录每一轮的钱数组合，一旦重复就判定为无限循环，直接返回-1。
• 双重终止检测：既检测分钱后是否状态不变（均分情况），也检测是否达到均分状态（这时候返回天数）。
• 迭代替代递归：彻底避免了递归带来的栈溢出问题，就算循环次数多也能稳定运行。

内容的提问来源于stack exchange，提问作者Akshay Chauhan