1365. 子集的和/动态规划+优化【leetcode】

1365. 子集的和

对于很多由 1∼N 构成的连续整数集合，我们都可以将其划分为两个子集，并使得两个子集的和相等。

例如，当 N=3 时，我们可以将集合 {1,2,3} 划分为子集 {1,2} 和 {3}，这也是唯一的一种满足条件的划分方式。

当 N=7 时，共有四种满足条件的划分方式，如下所示
{1,6,7} 和 {2,3,4,5}
{2,5,7} 和 {1,3,4,6}
{3,4,7} 和 {1,2,5,6}
{1,2,4,7} 和 {3,5,6}

现在，给定 N，请你计算将 1∼N 构成的连续整数集合划分为和相等的两个子集，共有多少种划分方式。

将一种划分方式的某个子集内部的元素之间进行顺序调整仍看作是同一种划分方式。

输入格式
共一行包含整数 N。

输出格式
输出一个整数，表示划分方案数。
如果无法划分，则输出 0。

数据范围
1≤N≤39

输入样例：
7
输出样例：
4

动态规划+优化

先来一个动态规划没有优化的版本

这里先放一个y总的动态规划的DP分析法
本题dp[m][n]表示前m个数总和为n的方案个数
可以分为包括第i个点和不包括第i个点，则转移方程为
dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[ i - 1 ][ j - i ]

#include<bits/stdc++.h>
using namespace std;
int dp[40][395];
int main()
{
    int n;
    cin>>n;
    int t=(1+n)*n/4;
    if(4*t!=n*(n+1))
    {
        cout<<0<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++) dp[i][0]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=t;j++)
            dp[i][j]=dp[i-1][j];
            if(j-i>=0) dp[i][j]+=dp[i-1][j-i];
    }
    cout<<dp[n][t]/2<<endl;
}

再讲讲优化方法
从dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[ i - 1 ][ j - i ] 可以看出i不需要一个数组来储存，每次只需要使用到i和i-1，dp[ i ][ j ] 可以直接把[ i ]去掉，而dp[ i - 1 ][ j ]可以直接把dp[ i - 1 ]去掉，dp[ j ] = dp[ j ]，就可以表示dp[ i ][ j ]=dp[ i - 1][ j ]，因为dp[ j ] = dp[ j ]实质上是先将右边的dp[ j ]更新，再赋值给左边的，故是可以的。

而dp[ i - 1 ][ j - i ] 直接把[ i - 1 ]删掉就可以了吗？是不行的。
dp[ i - 1 ][ j - i ]表示的是上一行的数，dp[ j - i ]肯定在dp[ j ]前面，若j从小到大遍历，则dp[ j - i ]在dp[ j ]之前已经被遍历过了，已经被操作过了，故其值早已经改变，此时再用到前面的dp[ j - i ]这个值是不行的，故可以从后面往前遍历j，这样用到的前面的dp[ j - i ]仍是有效的。

可以把原来的二维的画出一个表格，每一次都是由上一层的状态转移过来，而变成一维后，如果从后往前遍历，dp[j-i]还未被修改，相当于还是上一层的，所以可以转移，而如果从前往后遍历，那么dp[j-i]在到dp[j]是已经被改了，是这一层而不是上一层的了，所以是错误的。

#include<bits/stdc++.h>
using namespace std;
long long dp[400];
int main()
{
    int n;
    cin>>n;
    int t=(1+n)*n/4;
    if(2*t!=n*(n+1)/2)
    {
        cout<<0<<endl;
        return 0;
    }
    dp[0]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=t;j>=i;j--)
            dp[j]=dp[j]+dp[j-i];
    }
    cout<<dp[t]/2<<endl;
}