一个数组算法题，利用递归-回溯求解

给你10 分钟时间，根据上排给出十个数，在其下排填出对应的十个数
要求下排每个数都是先前上排那十个数在下排出现的次数。
上排的十个数如下：
【0，1，2，3，4，5，6，7，8，9】
举一个例子，
数值: 0,1,2,3,4,5,6,7,8,9
分配: 6,2,1,0,0,0,1,0,0,0
0 在下排出现了6 次，1 在下排出现了2 次，
2 在下排出现了1 次，3 在下排出现了0 次

using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Windows.Forms;
using System.Xml;
using System.Reflection;
using System.Threading;
using System;

namespace CSharpConsole
{
    public class Program
    {
        static void Main()
        {
            int[] arr = new int[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int[] output = new int[10];
            Solve(output, arr,arr.Length);
  
        }

        private static void Solve(int[] output, int[] arr,int len)
        {
            Solve_Help(0, output, arr,len);
        }

        private static void Solve_Help(int index, int[] output, int[] arr,int len)
        {
            if (index >= 10)
            {
                foreach (int t in output)   Console.Write(" " + t);
                Console.WriteLine();
                return;
            }

            for (int i = 0; i <= len; i++)
            {
                output[index] = i;
                if(IsFit(index,output,arr,len))
                    Solve_Help(index+1,output,arr,len);
            }
        }

        private static bool IsFit(int index, int[] output, int[] arr, int len)
        {
            //First Step//output的总和不能大于len
            int sum = 0;
            for (int t = 0; t <= index; t++)
                sum += output[t];
            if (sum > len) return false;
            //Second Step_1//index处的output（即output[index]大于或者等于index之前出现的真正的个数）
            int shoud_small;
            int shoud_large;
            int delta = 0;
            for(int i=0;i<=index;i++)
            {
                shoud_large=output[i];
                shoud_small = 0;
                for (int j = 0; j <= index; j++)
                    if (output[j] == arr[i])
                        shoud_small++;
                if (shoud_small > shoud_large)
                    return false;
                else
                {
                    //Second Step_2//index处的output（即output[index]大于或者等于index之前出现的真正的个数）
                    //但是，最终肯定要求完全匹配，即剩余的len-1-index必须能够将之前多出来的个数(temp_delta)补上
                    //此处有点麻烦，需要深刻意会
                    int temp_delta = shoud_large - shoud_small;
                    delta += temp_delta;
                    if (delta > len - 1 - index)
                        return false;
                }
            }
            return true;
        }

    }
}