7-29 修理牧场

7-29 修理牧场

题目大意，总长度L的木板，分为n块，每块ai长度。切割的酬劳等于被切木板长度。

例如，要将长度为20的木头锯成长度为8、7和5的三段，第一次锯木头花费20，将木头锯成12和8；第二次锯木头花费12，将长度为12的木头锯成7和5，总花费为32。

 

一开始想了个错误的方法，排序之后，递归的分割木板。每次把木板尽量均匀的切分两段。

#include <cstdio>
#include <algorithm>

int a[10001];
int total=0;

int cal( int L, int H, int length)
{
	int num = H-L; //这个区间有几段木头 
	if( num == 3)	return a[L] + a[L+1] + length; 
	if( num == 2) 	return  length;
	if( num <= 1)	return  0;
	
	int mid, leftLen=0;
	for( mid=L; mid<H && leftLen<length/2; mid++ )
		leftLen += a[mid];
	
	if (  leftLen > (a[mid-1]+length)/2)
	{
		mid--; 
		leftLen -= a[mid];
	}
	
	return length+ cal(L, mid, leftLen) + cal(mid, H, length - leftLen);
}


int main()
{
	int n;
	scanf("%d", &n);
	for(int i=0; i<n; i++)
	{
		scanf("%d", a+i);
		total += a[i];
	}
	std::sort( a, a+n );
	printf("%d\n", cal( 0, n, total) );
	return 0;
}
/* 测试例子
7
1 2 3 4 5 6 9

8
1 1 1 1 1 1 1 1

6
6 6 6 9 9 9

6
6 6 7 9 9 9
*/

 

这方法只能近似的得到最佳方案，可以获得很多情况下的最佳，但是有一些情况下不能，例如

6
6 6 7 9 9 9

最佳应该是 120，第一步切分为 6679，99。

但是按照上面的代码会得到122，因为第一步为了尽量均匀，木板被切为  667， 999。

 

那么最佳的方法是什么？哈夫曼树非叶节点求和。

求总开销的过程中，注意到每块小木板长度都被重复一次，直到被切为单独的一块。

这个过程和哈夫曼建树完全一样。 木板长度就是叶子权重。 权重越大的就应该越接近根节点。

 

上面的代码是自顶向下的，从完整的木板开始逐步切分。

而哈夫曼的做法则是自底向上，每次选择最短的两个木板拼合成大一点的木板，直到只有一个木板为止。

用最小堆就好了。

 

#include <cstdio>
#include <algorithm>

int a[10001];
int total=0, size;

void adjust( int cur, int n )//这个操作，把堆中cur位置元素下沉到合适位置
{
	int child= cur*2+1, tmp = a[cur];
	 
	while( child < n ) //还有子的时候才需要调整 
	{
		if( child+1 < n && a[child+1] < a[child] )
			child++;
		if( a[child] < tmp )  //这里还有一种写法，不停的swap(cur, child), 无需在循环外填上tmp
		{
			a[cur] = a[child];
			cur = child;
			child = cur*2+1;
		}
		else
			break;
	}
	a[cur] = tmp;
}

void minheapify( int n)
{
	for( int i=n/2; i>=0; i-- ) //这地方 n/2 还是 n/2-1?   N/2保险一点。。 
		adjust( i, n);
}

void replace(int n, int v)
{
	a[0] = v;
	adjust(0, n);
}

void pop(int &size)
{
	a[0] = a[--size];
	adjust(0, size);
}
int calWPL(  ) //哈夫曼树的weight path length
{
	int ret=0, length=0;
	while( size > 1 )
	{
		length = a[0];
		pop(size);
		length += a[0];
		ret += length;
		//printf("%d %d %d %d==========\n", size, length, length-a[0], a[0]);
		replace( size, length);
	}
	return ret;
}

int main()
{
	int n;
	scanf("%d", &n);
	for(int i=0; i<n; i++)
		scanf("%d", a+i);
	
	//std::sort( a, a+n ); //排序其实是nlogn建堆的方法
	minheapify(n);
	size = n;
	printf("%d\n", calWPL( ) );
	return 0;
}