数码串珠

在某寺遗址考古发掘中意外发现一串奇特的数码珠串，珠串上共串缀有6颗宝珠，每一宝珠上都刻有一个神秘的整数，长期以来，无人知晓这6颗数码串珠究竟有什么作用，专家通过考证，揭示这一数码串珠具有以下奇异特性：

（1）、这6颗宝珠上的整数互不相同，6个整数之和为31；

（2）、沿珠串相连的若干颗（1~6颗）珠上整数之和为1，2，……，31不间断，这一象征祥瑞的特性表现为完全覆盖，即可覆盖区间[1,31]中的所有整数；

请确定珠串上6颗宝珠上的整数及其相串的顺序；

6个整数和为s的全覆盖

1.说明：

为叙述方便，称沿圆圈若干个相连整数之和为“部分和”，部分和为区间[1,31]中的所有整数不间断称为“完全覆盖”；

问题是要在如图所示圆上的6个小圆圈中各填入一个整数，这6个整数之和为31，且沿圆相连的若干个（1~6个）小圆圈中整数之和覆盖区间[1,31]中的所有整数；

为了确定和为31的6个整数取值及检验这6个整数顺序是否能完全覆盖，设置，设置a数组作标记，起点为a（0）=0，约定a（1）-a（0）为第1个数，a（2）-a（1）为第2个数，……，一般地a（i）-a（i-1）为第i个数；

因为共6个数，显然a（6）=31且与起点a（0）重合，因为6个数中至少有一个数为1（否则不能覆盖1），不妨设第1个数为1，即a（1）=1；

串上6个数的每一个数都可以与（约定顺时针方向）相连的1，2，……，5个数组成部分和，易知共有31个部分和；

为构造部分和方便，定义a（7）与a（1）重合，即a（7）=a（6）+a（1）；a（8）与a（2）重合，即a（8）=a（6）+a（2）；……；最后有a（11）与a（5）重合，即a（11）=a（6）+a（5）；

设置b数组存储部分和，变量u统计b数组覆盖区间[1,31]中数的个数，若u=30（31本身显然覆盖，除去不计），即完全覆盖，输出和为31时的6个整数序列；

2.程序设计：

#include<stdio.h>
int main()
{
   int c,d,i,j,s,t,u,a[20],b[300];
   s=31;
   c=0;
   printf("6珠和为31的解有:\n");
   a[0]=0;
   a[1]=1;
   a[6]=s;
   for(a[2]=a[1]+1;a[2]<=27;a[2]++)
    for(a[3]=a[2]+1;a[3]<=28;a[3]++)
     for(a[4]=a[3]+1;a[4]<=29;a[4]++)
      for(a[5]=a[4]+1;a[5]<=30;a[5]++)
      {
         for(i=7;i<=11;i++)
            a[i]=31+a[i-6];
         for(t=0,i=0;i<=5;i++)
            for(j=i+1;j<=i+5;j++)    /*除31外，产生30个部分和*/
            {
               t++;               
               b[t]=a[j]-a[i];
            }
         u=0;
         for(d=1;d<=30;d++)
            for(i=1;i<=30;i++)
               if(b[i]==d)       /*b有[1,30]中的一个数，u增1*/
               {
                  u+=1;
                  i=30;
               }
         if(u==30)     /*u=30时为完全环覆盖*/
         {
            c++;
            printf(" (%2d) %2d",c,1);
            for(i=1;i<=5;i++)
               printf(",%2d",a[i+1]-a[i]);
            if(c%2==0)
               printf("\n");
         }
      }
   if(c>0)
      printf("共有以上%d个解\n",c);
} 

3.程序运行示例及其注意事项：

6珠和为31的解有:
 ( 1)  1, 2, 5, 4, 6,13 ( 2)  1, 2, 7, 4,12, 5
 ( 3)  1, 3, 2, 7, 8,10 ( 4)  1, 3, 6, 2, 5,14
 ( 5)  1, 5,12, 4, 7, 2 ( 6)  1, 7, 3, 2, 4,14
 ( 7)  1,10, 8, 7, 2, 3 ( 8)  1,13, 6, 4, 5, 2
 ( 9)  1,14, 4, 2, 3, 7 (10)  1,14, 5, 2, 6, 3
共有以上10个解

注意：

• 所输出的解中没有出现重复整数，其和均为31，且满足“完全满足”的要求，其中第3个解的数码珠串排列如图所示；不妨以此图解展示其部分和（从小到大）“完全覆盖”的特性：
  1，2，3，1+3，3+2，1+3+2，7，8，2+7，10，10+1，3+2+7，1+3+2+7，10+1+3，7+8，16~30为以上部分和的“补部分和”，31为序列所有整数之和；

• 同时观察到，这10个解两两配对，互为顺时针与逆时针关系，例如其中第1个解与第8个解是一对等；

拓广到n个整数和为s的全覆盖

一般地，求解圆环上的n个整数序列，其和为s，沿环的部分和完全覆盖区间[1,s]上的所有整数；

下面采用回溯设计求解；

1.说明：

（1）、数组设置；

设置a数组做标记，起点为a（0）=0，约定a（1）-a（0）为第1个数，a（2）-a（1）为第2个数，……，一般地a（i）-a（i-1）为第i个数，因为共n个数，显然刻度a（n）=s且与起点a（0）重合；

因为n个数中至少有一个数为1（否则不能覆盖1），不妨设第1个数为1，即a（1）=1；

圆环上的n个数的每一个数都可以与（约定顺时针方向）相连的1，2，……，n-1个数组成部分和，为构造部分和方便，定义a（n+1）与a（1）重合，即a（n+1）=s+a（1）；a（n+2）与a（2）重合，即a（n+2）=s+a（2）；……；最后有a（2n-1）与a（n-1）重合，即a（2n-1）=s+a（n-1）；

（2）、判别完全覆盖；

设置b数组存储部分和，变量u统计b数组覆盖区间[1,s]中数的个数，若u=s-1（s本身显然覆盖，出去不计），即完全覆盖，输出和为时的序列解，

（3）、取数与回溯；

若i< n-1，i增1后a[i]=a[i-1]+1后继续探索；

当i>1时a（i）增1继续，至a（i）=s-n+i时回溯；

变量s与n的值从键盘输入，运行程序时，选择s是从n（n-1）+1开始，逐渐取值输入，最先所得解为对应n的s最大值，然后再从这些解中选取没有相同整数的解；

2.程序设计：

#include<stdio.h>
int main()
{
   int c,d,i,j,k,t,u,s,n,a[30],b[300];
   printf("n个整数和为s，部分和完全覆盖s，请确定s，n:");
   scanf("%d,%d",&s,&n);
   a[0]=0;
   a[1]=1;
   a[n]=s;
   i=2;
   a[i]=2;
   c=0;
   while(1)
   {
      if(i<n-1)
      {
         i++;
         a[i]=a[i-1]+1;
         continue;
      }
      else
      {
         for(k=n+1;k<=2*n-1;k++)
            a[k]=s+a[k-n];
         for(t=0,k=0;k<=n-1;k++)
            for(j=k+1;j<=k+n-1;j++)  /*序列部分和赋值给b数组*/
            {
               t++;
               b[t]=a[j]-a[k];
            }
         for(u=0,d=1;d<=s-1;d++)
            for(k=1;k<=t;k++)
               if(b[k]==d)  /*检验b数组取1~s有多少个*/
               {
                  u++;
                  k=t;
               }
         if(u==s-1)         /*b数组值包括1~s所有整数*/
         {
            c++;
            printf("%2d:1",c);
            for(k=2;k<=n;k++)
               printf(",%4d",a[k]-a[k-1]);   /*输出串珠上的数码*/
            printf("\n");
         }
      }
      while(a[i]==s-n+i && i>1)   /*调整或回溯*/
         i--;
      if(i>1)
         a[i]++;
      else
         break;
   }
}

3.程序运行示例及其注意事项：

n个整数和为s，部分和完全覆盖s，请确定s，n:21,5
 1:1,   3,  10,   2,   5
 2:1,   5,   2,  10,   3

容易验证，圆环上的5个数组成的部分和为21个，“完全覆盖”的实现说明了所有21个部分和没有重复的；

最后指出，“古尺神奇”是在长度为s的直尺上分布的n条刻度分割的n+1个整数（段长）对s的全覆盖，而“数码串珠”是在圆环上分布的和为s的n个整数对s的全覆盖，后者是对前者的引申，实际上是环序列对一般序列的引申；

就构成部分和而言，在环上的整数利用率高些，因此后者的覆盖效率高于前者；