SRM 527 DIV 2

 

 550pt

 有一些结点，给出度数的权值，问可以构建最大权值和的一棵树。

 假设给出的scores[]数组的长度是n，那么点数就是n+1.实际上可以转化为这样的

一个问题。

有n+1个数，a1，a2，a3，...........................a(n+1)  ( ai>=1 && ai<=n)

且 a1+a2+a3+....................+an=2*n。 2*n是度数和。

求Max（scores[a1-1]+scores[a2-1]+scores[a3-1]+............+scores[a(n+1)-1]）

实际上是一个背包问题。这里由于n比较小，直接三个循环暴力解决。

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <cmath>
using namespace std;
int dp[55][155];

class P8XGraphBuilder
{
public:
	int solve(vector<int> scores)
	{
       int n = scores.size();
	   memset(dp,0,sizeof(dp));
       for(int i=1;i<=n;i++)
		   dp[1][i]=scores[i-1];

	   for(int i=2;i<=n+1;i++)
	   {
          for(int j=1;j<=n;j++)
		  {
		     for(int k=j+1;k<=2*n;k++)
			 {
				 if(dp[i-1][k-j]==0)
					 continue;
			     if(dp[i][k]<dp[i-1][k-j]+scores[j-1])
					 dp[i][k]=dp[i-1][k-j]+scores[j-1];
			 }
		  }
	   }

	   return dp[n+1][2*n];

	}
};

 补上 950pt  的题解.

先把coins_sum用二进制数表示出来，二进制中1的个数 msum 就是所需的最小硬币的数量，如果 msum>coins_count ,那么必然会无解。

注意到1个 2^k 可以分解为 2个 2^(k-1) ,  把一个 2^k,化为2个 2^(k-1) , 那么硬币数就会增加一个，按照题目的最小字典序的要求，只要在最

高位不断地向低位转化就行了，用完高位才用低位。

代码写得比较ws，各种if else来判断，各种边界问题，debug N久，还好TC给出测试数据。。。。。。。。。。（果然圣诞夜不适宜拍代码）

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <cmath>
using namespace std;

class P8XCoinChangeAnother
{
public:
    vector<long long> solve(int N, long long coins_sum, long long coins_count)
	{
         vector<long long>ans;
		 vector<long long>emp;
		 emp.clear();
		 ans.clear();
		 long long tmp = coins_sum;
		 long long msum=0;
		 while(tmp>0)
		 {
			 if(tmp%2==1)
				 msum+=1;
             ans.push_back(tmp%2);
			 tmp/=2;
		 }
         if(msum>coins_count)
			 return emp;
         long long p = coins_count-msum;
         for(int i=ans.size()-1;i>=0;i--)
		 {
            if(p>=ans[i] && p!=0)
			{
				p-=ans[i];
				if(i-1>=0)
					ans[i-1]+=2*ans[i];
				else
					return emp;
				ans[i]=0;
			}
			else
			{
				if(i+1<=N)
				{
					if(p==0)
					{
						while(ans.size()<N)
							ans.push_back(0);
						return ans;
					}
					if(i-1>=0)
					  ans[i-1]+=2*p;
					else 
					  return emp;
					ans[i]-=p;
					while(ans.size()<N)
						ans.push_back(0);
					return ans;
				}
				else
		            return emp;
			}
			if(i+1>N)
			   ans.pop_back();
		 }
		 return emp;
	}
};