P1284 三角形牧场

P1284 三角形牧场

题目描述

和所有人一样，奶牛喜欢变化。它们正在设想新造型的牧场。奶牛建筑师Hei想建造围有漂亮白色栅栏的三角形牧场。她拥有N(3≤N≤40)块木板，每块的长度Li(1≤Li≤40)都是整数，她想用所有的木板围成一个三角形使得牧场面积最大。

请帮助Hei小姐构造这样的牧场，并计算出这个最大牧场的面积。

输入输出格式

输入格式：

 

第1行：一个整数N

第2..N+1行：每行包含一个整数，即是木板长度。

 

输出格式：

 

仅一个整数：最大牧场面积乘以100然后舍尾的结果。如果无法构建，输出-1。

 

输入输出样例

输入样例#1：

5
1
1
3
3
4

输出样例#1：

692

说明

样例解释：692=舍尾后的（100×三角形面积），此三角形为等边三角形，边长为4。

 

---

 

分析：

海伦公式：pi:=(a+b+c)/2;

S:=sqrt(pi*(pi-a)*(pi-b)*(pi-c))

 

1、dp

一道背包型DP的好题！

首先爆搜没话说肯定超时，然后我们来研究这道题的dp解法

发现当面积最大时必须要所有木板都用上

已知两条边i,j，和周长sum，第三条边简单出来sum-i-j

既然是dp就要有dp的样子，

状态怎么写？

令dp[i,j]表示i,j长用在两条边上可不可以。boolean型

转移怎么写？

由于每种木板只有一块，容易想到01背包

dp[i,j]:=dp[i,j] or dp[i-d[k],j] or dp[i,j-d[k]];

转移的时候枚举每块木板就可以了，注意01背包要倒着循环

只要dp[i,j]=true证明这样可以，我们就可以累加答案了。

海伦公式和三边能否组成三角形就不用赘述了。

 

var ans:double;
    i,j,k,sum,n:longint;
    d:array[1..100000]of longint;
    dp:array[0..1000,0..1000]of boolean;
function max(a,b:double):double;
begin
 if a<b then exit(b)
 else exit(a);
end;
function solve(a,b,c:longint):double;
var p:double;
begin
 p:=(a+b+c)/2;
 if (c<=0)or(a<=0)or(b<=0) then exit(-1);
 if (a+b<=c)or(b+c<=a)or(a+c<=b) then exit(-1);
 exit(sqrt(p*(p-a)*(p-b)*(p-c)));
end;
begin
 ans:=0;
 readln(n);
 for i:=1 to n do begin read(d[i]); inc(sum,d[i]); end;
 fillchar(dp,sizeof(dp),false);
 dp[0,0]:=true;
 for k:=1 to n do
  for i:=sum downto 0 do
   for j:=sum downto 0 do begin
  if i>=d[k] then dp[i,j]:=dp[i,j] or dp[i-d[k],j];
  if j>=d[k] then dp[i,j]:=dp[i,j] or dp[i,j-d[k]];
  if dp[i,j] then ans:=max(ans,solve(i,j,sum-i-j));
 end;
 if ans=0 then writeln(-1)
 else writeln(trunc(ans*100));
end.

 

2、记忆化搜索

来一发记(chun)忆(bao)化(li)搜索

我们把三角形的三条边当做搜索的变量。

那么当我们知道其中两个边的长度的话，就可以推出第三条边的长度。

对于每一个木棒，我们都有三种策略

1.加到第一条边yi+a[i],er,sum-(yi+a[i]+er)

2.加到第二条边yi,er+a[i],sum-(yi+er+a[i])

3.加到第三条边yi,er,sum-(yi+er)

然后记忆化搜索就好了!

注意一个问题，这题需要用hash判重，

我们将各个边都乘上一个不同切不会重复的权值就好

（用map会超时。数组要开大！）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<algorithm>
#include<map>
#define lli long long int 
using namespace std;
const int MAXN=10000001;
void read(int &n)
{
    char c='+';int x=0;bool flag=0;
    while(c<'0'||c>'9')
    {c=getchar();if(c=='-')flag=1;}
    while(c>='0'&&c<='9')
    {x=x*10+(c-48);c=getchar();}
    flag==1?n=-x:n=x;
}
int n;
int fi,se;
int vis[MAXN];
int sum=0;
int a[MAXN];
int happen[MAXN];
double ans=-1;
map<string,bool>mp;
double calc(double yi,double er,double san)
{
    if(min(min(yi,er),min(er,san))+min(min(yi,er),min(er,san))>max(max(yi,er),max(er,san)))
    {
        double p=(yi+er+san)/2;
        return sqrt(p*(p-yi)*(p-er)*(p-san));    
    }
    else
    return -1;
}
int comp(const int a,const int b)
{
    return a<b;
}
void dfs(int yi,int er,int san)
{
    if(happen[yi*1500+er*150+san])
        return ;
    happen[yi*1500+er*150+san]=1;
    if(yi+er+san==sum&&yi!=0&&er!=0&&san!=0)
    {
        double hh=calc(yi,er,san);
        if(hh>ans)
        ans=calc(yi,er,san);
    }
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==0)
        {
            vis[i]=1;
            dfs(yi+a[i],er,sum-(yi+a[i]+er));
            dfs(yi,er+a[i],sum-(yi+er+a[i]));
            vis[i]=0;
            dfs(yi,er,sum-(yi+er));
        }
    }
}
int main()
{
    read(n);
    for(int i=1;i<=n;i++)
    {
        read(a[i]); sum+=a[i];    
    }
    sort(a+1,a+n+1,comp);// 排序是为了方便调试 
    dfs(0,0,0);
    if(ans==-1)
    { printf("-1"); return 0;}
    ans=ans*100.0;
    printf("%d",(int)ans);
    return 0;
}

 

3、贪心+随机化

赤裸裸的贪心。加上随机化就能AC。

因为三边越接近，面积就最大。所以可以用贪心来AC。

下面的代码旁有注解的。很好理解

var
  b:array[1..3] of longint;
  i,n,p,t,j,k,top,max:longint;
  a:array[0..100000] of longint;
function jisuan(x,y,z:longint):longint;
var
  k,c:real;
  t:longint;
begin
  c:=(x+y+z)/2;
  if (c-x<=0) or (c-y<=0) or (c-z<=0) then exit(-1);
  k:=sqrt((c-x)*(c-y)*(c-z)*c)*100;
  t:=trunc(k);
  exit(t);
end;
procedure suiji;
var
  i,t:longint;
begin
  for i:=1 to n do begin
    t:=random(n);//随机化
    a[0]:=a[t];
    a[t]:=a[i];
    a[i]:=a[0];
  end;
end;
begin
  max:=-2;
  randomize;
  readln(n);
  for i:=1 to n do begin
    readln(a[i]);
  end;
  for i:=1 to 100000 do begin
    suiji;
    b[1]:=a[1];
    b[2]:=a[2];
    b[3]:=a[3];
    k:=3;
    while k<=n do begin
      for j:=1 to 2 do begin
        for t:=2 to 3 do begin
          if b[j]>b[t] then begin
            p:=b[j]; b[j]:=b[t]; b[t]:=p;
          end;
        end;
      end;
      inc(k);
      b[1]:=b[1]+a[k];
    end;
    top:=jisuan(b[1],b[2],b[3]);//贪心
    if top>max then max:=top;
  end;
  writeln(max);
end.