usaco——subset sums

Subset Sums
JRM

For many sets of consecutive integers from 1 through N (1 <= N <= 39), one can partition the set into two sets whose sums are identical.

For example, if N=3, one can partition the set {1, 2, 3} in one way so that the sums of both subsets are identical:

• {3} and {1,2}

This counts as a single partitioning (i.e., reversing the order counts as the same partitioning and thus does not increase the count of partitions).

If N=7, there are four ways to partition the set {1, 2, 3, ... 7} so that each partition has the same sum:

• {1,6,7} and {2,3,4,5}
• {2,5,7} and {1,3,4,6}
• {3,4,7} and {1,2,5,6}
• {1,2,4,7} and {3,5,6}

Given N, your program should print the number of ways a set containing the integers from 1 through N can be partitioned into two sets whose sums are identical. Print 0 if there are no such ways.

Your program must calculate the answer, not look it up from a table.

PROGRAM NAME: subset

INPUT FORMAT

The input file contains a single line with a single integer representing N, as above.

SAMPLE INPUT (file subset.in)

7

OUTPUT FORMAT

The output file contains a single line with a single integer that tells how many same-sum partitions can be made from the set {1, 2, ..., N}. The output file should contain 0 if there are no ways to make a same-sum partition.

SAMPLE OUTPUT (file subset.out)

4

这道题让我郁闷了。

自己一开始写的超时了。

应该是前面stupid search惯了。

网上的牛们说是dp，找了好半天，才知道是dynamic programming。

之前是做过这种题的。比如那道三角的。

这道题没想到那么做。

找了找别人的方法。

就两种：

一个是一维dp，一个是二维dp。

二维dp有个递推公式： a[i][j]=a[i-1][j-i]+a[i-1][j];

这里j是总和sum的意思，i表示前面有1到i，i个连续的数，a[i][j]就是前面某些数相加等于j的组合数。组合数包含两类，含有i的和不含i的。

代码：

#include <iostream>   
7.#include <memory.h>   
8.using namespace std;   
9.#define _max_ 40   
10.  
11.int main() {       
12.    freopen("subset.in", "r", stdin);   
13.    freopen("subset.out", "w", stdout);    
14.    int num ;   
15.    cin >> num ;   
16.    int part_sum = (num * (num + 1) ) >> 1 ;   
17.    if( part_sum & 1 ){   
18.        cout << 0 << endl ;   
19.        return 0 ;   
20.    }   
21.    part_sum = part_sum>>1 ;   
22.    int sum_num[_max_][((_max_*(_max_+1))>>2)+1] ;   
23.    memset(sum_num, 0, sizeof(sum_num));   
24.    sum_num[1][1]=1 ;   
25.    for( int i=2; i<=num; i++ ){   
26.        for(int j=1; j<=part_sum; j++ ){   
27.            sum_num[i][j] += i-1>=1 ? sum_num[i-1][j] + ( j-i>=1 ? sum_num[i-1][j-i] : 0 ) : 0 ;   
28.        }   
29.    }   
30.    cout << sum_num[num][part_sum] << endl ;   
31.    return 0;   
32.}  

一维的解释在代码里了：

　　#include <fstream>
　　using namespace std;
　　const unsigned int MAX_SUM = 1024;
　　int n;
　　unsigned long long int dyn[MAX_SUM];
　　ifstream fin ("subset.in");
　　ofstream fout ("subset.out");
　　int main() {
　　fin >> n;
　　fin.close();
　　int s = n*(n+1);
　　if (s % 4) {
　　fout << 0 << endl;
　　fout.close ();
　　return 0;
　　}
　　s /= 4;
　　int i, j;
　　dyn [0] = 1;
/*可以把dyn每个元素想成一个背包。随着i的增加，我们动态的看能让背包dyn【s】盛满s的种数。这里的公式是a[s]=∑a[s-i],我刚开始看的时候，有点儿迷惑，这不就有很多重复吗？其实第一层的for，已经消除了，dp很讲究顺序的。包里的元素可以这么说，是小的先进，大的后进。拿n=3来说吧，可以有12--3,和3——12.一开始i=1；就是说n=1的情况。a【3】+=a【2】,但是a【2】=0；因为n=1时，不可能会有3.就这样子，只会有i=2是，12——3才计一次数。*/
　　for (i = 1; i <= n; i++)              
　　for (j = s; j >= i; j--)             
　　dyn[j] += dyn[j-i];
　　fout << (dyn[s]/2) << endl;
　　fout.close();
　　return 0;
　　} 

最后把我的代码也贴上，为了保存一下：

#include <fstream>
using namespace std;

int sum=1;
int hfSum;
int N;
int cnt;

void core(int a,int lengh)
{
 sum+=lengh+a;
 if(sum==hfSum) {++cnt;sum-=lengh+a; return; }
 if(sum>hfSum) {sum-=lengh+a;return;}
 for(int i=1; a+lengh+i+sum<hfSum+1&&a+lengh+i<N+1; ++i)
    {core(a+lengh,i);}
 sum-=lengh+a;
}
int main()
{
  ifstream fin("subset.in");
  ofstream fout("subset.out");
  fin>>N;
  hfSum=(N+1)*N/4;
  if(!((N+1)*N/2%2))
     {for(int i=1; i+1+1<N+1&&i+2<hfSum+1; ++i)
      core(1,i);
      fout<<cnt<<endl;
     }
  else
  fout<<0<<endl;

}