这题我采取了两种做法。下面提供两份代码。

前者较为麻烦，但是基于一定的贪心原则， 状态少，效率高。后者写起来方便，速度稍慢。

#include<stdio.h> 
#include<string.h>
#include<algorithm>
using namespace std;
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
typedef long long LL;
const int N=1015,M=4015;
int casenum,casei;
int n,m;
struct A
{
	int l,v,h;
	bool operator < (const A& b)const {return l<b.l;}
}a[N];
int d[N][M];
LL f[M];
template <class T1,class T2>inline void gmax(T1 &a,T2 b){if(b>a)a=b;}
int main()
{
	scanf("%d",&casenum);
	for(casei=1;casei<=casenum;casei++)
	{
		LL ans=0;
		scanf("%d%d",&n,&m);m<<=1;
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d",&a[i].l,&a[i].v);
			a[i].h=a[i].l;
			a[i].l<<=1;
			if(a[i].v>ans)ans=a[i].v;
		}
		sort(a+1,a+n+1);
		while(n>=1&&a[n].l>=m)--n;//优化：长度比一倍还长的筛掉，它们肯定只能放一个

		MS(d,0);
		for(int i=n;i>=1;i--)
		{
			MC(d[i],d[i+1]);
			gmax(d[i][a[i].h],a[i].v);
			for(int j=i+1;j<=n;j++)
			{
				int len=a[i].h+a[j].h;
				if(len>m)break;
				gmax(d[i][len],a[i].v+a[j].v);
			}

			//我们再扫描一遍，维护单调性，使得d[i][j]表示用i及以上的木棍放在两边，占据的空间最大为j条件下的最大价值
			for(int j=1;j<=m;j++)gmax(d[i][j],d[i][j-1]);
		}
		gmax(ans,d[1][m]);

		MS(f,0);
		for(int i=1;i<=n;i++)
		{
			for(int j=m;j>=a[i].l;j--)
			{
				gmax(f[j],f[j-a[i].l]+a[i].v);
				gmax(ans,f[j]+d[i+1][m-j]);
			}
		}
		printf("Case #%d: %lld\n",casei,ans);
	}
	return 0;
}
/*
【trick&&吐槽】
这题的题意杀了我好久，本来是1个多小时就能AC的，结果被我拖到了4个多小时才完成ACQwQ
看来读题的时候一定要确保下题意。有些实在不清楚的地方哪怕是枚举下题意也是可以的。
这题中有一句——No gold segment was allowed to be overlapped.
对于关键性的话不要忽略。
对于关键性的单词不要脑补。
No gold segment was allowed to be overlapped.
overlap被我理解成了溢出，就是容器是以整数为单位呈一段段，放进去的木棍也要恰好是卡成一段段。
然而事实上overlap的意思是重叠。于是就可以有
input
2 3
3 1
3 1
output
2
的对应输入输出了。
事实上，如果我枚举题意，也不会卡这么久QwQ

【题意】
给你一个长度为m（[1,2000]）的长条状容器。
然后我们有n（[1,1000]）段木棒。
第i段木棒有一个长度a[i].l和价值a[i].v。
我们希望把尽可能大价值的木棒放到容器中，使得所有木棒的重心都在容器内
要求木棒不能重叠。

【类型】
DP+贪心

【分析】
一条木棍的话，不管它有多长，总有方案使得重心落在容器范围内，一定是可以的。
然而，如果是多条木棍呢？

对于既有选择又有顺序的DP，我们可以先简化问题。
我们可以先假设，假设我们已经得到了最后选择的木棒的集合是什么，现在只是对这些木棍决定放置方案。
那么，有两种可能——
1，没有木棍悬在外面，
2，有1根或者2根木棍悬在外面。
对于情况1，我们可以直接用传统的"f[前i个木棍][长度为j]"这样的DP算得结果。
对于情况2，放在外面的木棍是什么呢？
我们发现，如果目前是短的木棍悬在外面，长的木棍在里面。方案合法。
假设长的木棍长度是ll，短的木棍长度是l，如果交换位置，
1,我们会多空闲(ll-l)的内部空间，
2,我们会多需要(ll-l)/2的空间悬放这个木棍。
显然多空闲出的空间比多需要的空间要大，这个方案也一定是合法的。
于是我们就这样得到了一个贪心结论——
对于一个合法的方案，一定是选择最长的木棍悬在外面。

于是，我们先把所有木棍按照边从大到小做排序，
然后用d[i][j]求出——用编号在i或i以上的木棍，悬挂在两边，占据的空间为最大为j条件下的最大价值。
因为这里可能是1根或2根木棍溢出。所以我们需要用一个O(n^2)复杂度下枚举的DP就能维护d[][]

然后我们在做关于情况1的DP的时候，我们能求出用：
放在中间的木棍都来之前i个木棍中，占据的长度为j条件下的最大价值，记为f[i][j]
然而，我们再额外算上放在两边的木棍，这最多2根悬挂木棍要求都是来自于i+1~n的木棍中。
于是可以用f[i][j]+d[i+1][m-j]更新答案。

这里的最后一个问题是：
我们可能重心是落在非整点位置，对于这个情况，我们要怎么办呢？
对于有意义的决策，既是重心不落在非整点位置，那也肯定是落在0.5位置。
所以我们把原容器长度*=2，
然后对于内部摆放的DP，通过原长度*2展开，
对于外部的DP，则用原长度展开（因为要有一半嵌在内部）。
这样就避免的小数的情况，保证了题目能够顺利AC~~

【时间复杂度&&优化】
O(n^2)

【数据】
input
2 3
3 1
3 1

output
2
*/

#include<stdio.h> 
#include<string.h>
#include<algorithm>
using namespace std;
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
typedef long long LL;
const int N=1015,M=4015;
int casenum,casei;
int n,m;
struct A
{
	int l,v,h;
	bool operator < (const A& b)const{return l<b.l;}
}a[N];
LL f[M][3];
template <class T1,class T2>inline void gmax(T1 &a,T2 b){if(b>a)a=b;}
int main()
{
	scanf("%d",&casenum);
	for(casei=1;casei<=casenum;casei++)
	{
		LL ans=0;
		scanf("%d%d",&n,&m);m<<=1;
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d",&a[i].l,&a[i].v);
			a[i].h=a[i].l;
			a[i].l<<=1;
			if(a[i].v>ans)ans=a[i].v;
		}

		//优化：长度比一倍还长的筛掉，它们肯定只能放一个
		sort(a+1,a+n+1);
		while(n>=1&&a[n].h>=m)--n;

		MS(f,0);
		for(int i=1;i<=n;i++)
		{
			for(int j=m;j>=a[i].h;j--)
			{
				for(int u=0;u<=2;u++)
				{
					if(j>=a[i].l)gmax(f[j][u],f[j-a[i].l][u]+a[i].v);
					if(u)gmax(f[j][u],f[j-a[i].h][u-1]+a[i].v);
				}
			}
		}
		gmax(ans,f[m][2]);
		printf("Case #%d: %lld\n",casei,ans);
	}
	return 0;
}
/*
【分析】
这题还有另外一个解题方法。
用f[i][j][u]表示现在处理到前i根木棍，它们在容器内占据的长度为j，且有u条木棍悬挂在外的最大价值。
这个DP多加了一个维度u，显然u的取值范围是[0,2]
同样采取使得half=原长len，使得len=原长len的2倍的避免小数的策略。
那么我们有状态转移方程
gmax(f[i][j][u],f[i-1][j-a[i].len][u]+a[i].val);
gmax(f[i][j][u],f[i-1][j-a[i].half][u-1]+a[i].val);
这样从所有的子状态中更新答案。

注意，我们可以使用三维数组表示空间，这里也可以下降为只有[j][u]，第一维度的i可以省略。
这样压缩空间的做法需要注意保证拓扑序。要无环，要避免同一个木棍多次更新状态。
我们只要改变枚举顺序，使得j降序。
因为每个物品的空间都至少为1，所以不论u的顺序，这里就可以保证，一定不会重复更新。

【时间复杂度&&优化】
O(n^2)

*/