[看了官方的题解后发现原来是可以用最小环解这题的,转化为图的时候,把木板看成边,然后木板的每个端点都看成一个独立的端点,这样的话,如果两块木板相连,就把他们的端点相连,并且权为0,木板代表的边权值为木板的长度,这样的话,就可以比较好的转化成最小环问题了,具体的可以看这里的附件]
于是只能再想办法了,我想的是硬搜,不过不知道能不能过,但是一时没什么其他的好办法,就想这样写吧,思路如下:
dfs(now,use,l)其中now代表当前点,use表示哪个端点可用,l表示当前的长度.那么就比较好实现了,代码如下,当然第一次我没加注释掉的那一句
if(l[这个是字母l] >= min) continue;然后死在第7组数据上,死了之后就想能在哪优化不,突然发现可以加上这句,因为如果当前的已经大于等于最优值了,那么这个周长就不可能比最优值还短,改了之后就过了。不过这个优化应该第一次就想到的 - -||惭愧     我当时还有一个想法,就是记录下那些"环"已经算过,那么在这个"环"上的以其他边为起点的就不用算了,比如说1-2-3形成一个环,那么一开始以1为起点算了这个"环"的周长了,这样的话,就不用算以2 3为起点的这个"环"的长度了,不过我想不出有什么好的记录方法,所以就没加了,如果那个有什么想法的话,可以在下面写出来。

   我过的是比较幸运的。首先我用一个二维数组f[][]存下某些状态,其中f[i][j]表示长度为i,1的个数不超过j的数目。然后如果某个数小于2^L,那么肯定输出原数,如果不是再特殊处理,找到第一个f[i][L]比I大的i。然后比较I和f[i][L],f[i-1][L]其中哪个近,离哪个近就从那边开始搜。一直搜到结果为止,这样能过,但是险过。有一组数据用时0.9+S。其中还有一些要注意的就是用long long。也就是如果测试数据有31 31的话,不用long long 会超数据范围。(我大致算了下,我这种写法,极限数据应该会超过1S,那样的话必挂无疑。但是好像usaco的数据没这种)

   官方的：首先也是处理一个和我的一样的二维数组。不过后面明显比我的要好,标称是用递归写的,直接输出。

void printbits(int nbits, int nones, double index)

   {/*nbits 表示剩下的要处理的长度  nones 表示剩下的1的个数  index表示第多少个*/     

       double s;     

       if(nbits == 0)/*处理完成*/

           return;     

       s = sizeofset[nbits-1][nones];/*得到f[bits-1][nones]*/

       if(s <= index) 

        {/*如果index大于这个f值*/

          fprintf(fout, "1");/*那么这位肯定是1 */       

           printbits(nbits-1, nones-1, index-s);/*改变相应的状态 继续输出  长度-1,1的个数-1 index-s 这里这个index-s有点像10进制化2进制*/   

        } 

      else

        {  

          fprintf(fout, "0"); /*小于这个f值这位肯定为0*/ 

          printbits(nbits-1, nones, index);/*改变相应的状态继续输出  长度-1 1的个数不减 index也不变*/

        }

   }

这题可以用搜索，但是肯定会超时，毕竟最多100盏灯，10000次按压。这些可不是小数目，不过我们可以知道，对于每一盏灯，按压两次的效果和不按压的效果是一样的。这样一共才四盏灯，也就是我们只要枚举16种情况就OK了。当然达到目标状态后，我们还得看剩下的次数能否是灯的状态不发生改变。通过观察发现，可以没盏灯两次所有的灯的状态不发生改变，还有就是可以改变1,2,3这三盏灯，所有灯的状态也不会发生改变。然后我们看剩下的灯是不是可以由n个2和m个3(n,m可以为0)相加得到。如果可以的话，那么这个状态就可以，记录下来。最后我们要先排序，由于qsort函数对二维数组排序不熟，所有采用的是冒泡排序，不过这最多也就是16个元素，所以还是很快的。

     看了Analysis之后发现可以简化到只考虑前6盏灯，因为LCM(1,2,2,3)=6.也就是开关1影响的是每次加1的灯，相应的2 2 3.所以超过6的都可以由前6盏灯得到。这样的话应该还可以把6位二进制转化成10进制然后用qsort快排一下。输出也好办，一般循环输出前6种状态直到输出n位为止。
   相应的可以看nocow上的题解

       for i = 2 to n

          f[i][i] =1;/*这选自己*/

          j = i – 1;

         for k = 0  to (j+1)*j/2  /*f[i][k] <----f[i-1][k] f[i][i+k] <-----f[i-1][k]*/

            if(f[j][k] > 0)

               f[i][k] += f[j][k];

               f[i][k+i] += f[j][k];

最后还有一点就是N = 39时结果很大要用long long或者__int64存

翻译者：timgreen

转载自：OIBH

一个等差数列是一个能表示成a, a+b, a+2b,..., a+nb (n=0,1,2,3,...)
在这个问题中a是一个非负的整数，b是正整数。
写一个程序来找出在双平方数集合S中长度为n的等差数列。
双平方数集合是所有能表示成p2＋q2的数的集合。

PROGRAM NAME: ariprog

INPUT FORMAT

第一行:  N(3<= N<=25),要找的等差数列的长度。 
第二行:  M(1<= M<=250),搜索双平方数的上界0 <= p,q <= M。

SAMPLE INPUT (file ariprog.in)
5
7

OUTPUT FORMAT
如果没有找到数列,输出`NONE'。
如果找到了，输出一行或多行, 每行由于二个整数组成:a,b
这些行应该先按b排序再按a排序。
将不会有只多于10,000个等差数列。

SAMPLE OUTPUT (file ariprog.out)
1 4
37 4
2 8
29 8
1 12
5 12
13 12
17 12
5 20
2 24
这题的思路应该说还是比较容易想的，不过要已开始就想到不TLE的就有点难了，可以把形 如p^2+q^2的数都存起来，后来就可以直接去数组里面取了。
接下来就是找适合的a和b了。
我一开始的代码是最原始的，就是一个一个找，
for(int i = 0;i < index1-n+1;i++)
     {
      a = num[i];
      for(int j = i+1;j < index1;j++)
        {
         b = num[j]-a;
         now = a+b;
         count = 2;
         if(a + b*(n-1) > max_num)//这里是表示不可能找到满足条件的a和b
           continue;
        for(int k = j+1;k < index1;k++)
           {
            if(now+b == num[k])
              {
                now = num[k];
                count++;
                if(n == count)//如果找到，就退出
                   {
                    node[index2].a = a;
                    node[index2++].b = b;
                    break;
                   }
              }
              if(num[k] > now + b)//表示不可能找到合适的a和b
                 break;
           }        
     }

Notice that the order in which we apply moves is irrelevant, and that applying a move four times is the same as applying it not at all.

Thus there are only 4⁹ = 262144 move sequences that need to be tried, so we might as well just try them all.

We don't generate them shortest first, but looking at sequences of the same length, we generate the lesser ones before the greater ones, so we only need to keep track of the shortest working sequence we've found.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#define INF 60000	/* bigger than longest possible path */
char *movestr[] = { "abde", "abc", "bcef", "adg", "bdefh", "cfi", "degh",
"ghi", "efhi" };
int movedist[9][9];
int clock[9];
int bestmove[9];
int nbestmove;
/* translate move strings into array "movedist" of which clocks change on each move */
void  mkmove(void)
{
int i;
char *p;
for(i=0; i<9; i++)
for(p=movestr[i]; *p; p++)
movedist[i][*p-'a'] = 3;
}
/* apply some number of each move from k to 9 */
/* move contains the number of times each move is applied */
void  solve(int *move, int k)
{
int i, j, n, rep;
if(k == 9) {
for(j=0; j<9; j++)
if(clock[j]%12 != 0)
return;
/* we have a successful sequence of moves */
n = 0;
for(j=0; j<9; j++)
n += move[j];
if(nbestmove == 0 || n < nbestmove) {
nbestmove = n;
for(j=0; j<9; j++)
bestmove[j] = move[j];
}
return;
}
/*
* the for loop counts down so we
* generate smaller numbers first by
* trying more of small numbered
* moves before we try less of them.
*/
for(rep=3; rep>=0; rep--) {
/* apply move k rep times */
for(i=0; i<rep; i++)
for(j=0; j<9; j++)
clock[j] += movedist[k][j];
move[k] = rep;
solve(move, k+1);
/* undo move */
for(i=0; i<rep; i++)
for(j=0; j<9; j++)
clock[j] -= movedist[k][j];
}
}
void  main(void)
{
FILE *fin, *fout;
int i, j, move[9];
char *sep;
fin = fopen("clocks.in", "r");
fout = fopen("clocks.out", "w");
assert(fin != NULL && fout != NULL);
mkmove();
for(i=0; i<9; i++)
fscanf(fin, "%d", &clock[i]);
solve(move, 0);
sep = "";
for(i=0; i<9; i++) {
for(j=0; j<bestmove[i]; j++) {
fprintf(fout, "%s%d", sep, i+1);
sep = " ";
}
}
fprintf(fout, "\n");
exit(0);
}