給定一個天平和n個砝碼，每個砝碼都有一個重量，求出從1到這些砝碼的總和之間不能被天平表示的重量。天平可以兩端放砝碼。

動態規劃做法，看網上都是母函式，真心不懂。。

dp[i]如果是0表示這些砝碼不能稱重i重量，如果是1表示能稱重i重量。

對於每個砝碼，假設當前砝碼重量是b[i]，那麼j從最大值開始，減小到b[i]，

如果存在一個dp[j-b[i]]為1，說明當前的j能被組成。

j逆著迴圈的原因是由於每個砝碼只有 一個，類似於01揹包與完全揹包的樣子，

如果正向迴圈會導致每個物品可能使用多次，逆向迴圈則不會出現這個問題。

其實舉個例子就能看出來了。

因為天平是可以兩邊放的，因此可以從大的數中減去小的數，方法就是對於每個砝碼重量b[i]，

遍歷在dp陣列中為真的並且比b[i]那些j，那麼dp[j-b[i]]也一定為真，這個乍一看不靠譜，但經過分析好像是對的。

如果b[i]被重複使用了怎麼辦？即dp[j]已經使用了b[i]了，你還要減去b[i]，但它只有一個啊。

此時如果dp[j]已經使用了b[i]，那麼dp[j-b[i]]早已經為真了，即由別的砝碼早可以組成dp[j-b[i]]了。

如果是多個砝碼減2個砝碼怎麼辦？不會漏掉嗎？其實在第一個砝碼的時候就記錄了多個砝碼減第一個砝碼的結果，

到第二個砝碼的時候會用到這個結果。這樣就不會漏了。

其實這也是dp，這個dp的j要正向進行，逆向進行就會導致砝碼重複使用。

#include<bitset>
#include<map>
#include<vector>
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<stack>
#include<queue>
#include<set>
#define inf 0x3f3f3f3f
#define mem(a,x) memset(a,x,sizeof(a))

using namespace std;

typedef long long ll;
typedef pair<int,int> pii;

inline int in()
{
    int res=0;
    char c;
    while((c=getchar())<'0' || c>'9');
    while(c>='0' && c<='9')res=res*10+c-'0',c=getchar();
    return res;
}

const int N=100006;
int dp[N];    //注意要大一些, 因為範圍是砝碼的總和
int b[2006];

int ans[20000];

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        mem(dp,0);
        int mx=0;
        for(int i=0;i<n;i++)
        {
            b[i]=in();
            mx+=b[i];
        }

        dp[0]=1;
        for(int i=0;i<n;i++)
        {
            for(int j=mx;j>=b[i];j--)
            {
                if(dp[j-b[i]]) dp[j]=1;
            }
        }
        for(int i=0;i<n;i++)
        {
            for(int j=b[i];j<=mx;j++)
            {
                if(dp[j])dp[j-b[i]]=1;  //每個比當前砝碼大的，減去當前砝碼的重量。
            }
        }
        int p=0;
        for(int i=1;i<=mx;i++)if(!dp[i])ans[p++]=i;
        printf("%d\n",p);
        for(int i=0;i<p-1;i++)
        {
            printf("%d ",ans[i]);
        }
        if(p>0)printf("%d\n",ans[p-1]);  //當時又漏了p>0


    }
    return 0;
}