POJ 1948 （Triangular Pastures）二维背包 DP/DFS

题意：有N个木棒，全部使用使得面积最大。输出面积.

本来打算对于背包问题只写一篇文章，但是做开题后发现根本不是这么回事。很多要注意的地方、

这道题的二维0-1背包不同之处在于：对同一个属性进行两个维度的“背包”

这道题用到的三角形性质：

1.构成三角形：两边之和大于第三边。在DFS过程中直接规定A>=B ,B>=C

2.面积计算，海伦公式：s=sqrt(p*(p-a)*(p-b)*(p-c))，p=(a+b+c+0.0)/2;

dfs要注意的就是判重。因为已经设定了搜索的A>=B，A<=sum/2。flag[A][B]这种情况排除。

dfs:

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<functional>
using namespace std;
#define INF -999999999
#define N 400010
#define pos 100
#define max(a,b) (a)>(b)?(a):(b)
#define fr(a,b,c) for(a=b;a<c;a++)
int sum;
int ans;
int a[pos],vis[100];
int flag[1700][1700];
int n;
int cal(int a,int b,int c)
{
	double p=(a+b+c+0.0)/2;
	double s=sqrt(p*(p-a)*(p-b)*(p-c));
	int ans=s*100;
	return ans;
}
void dfs(int A , int B){
	int i;
    if(flag[A][B]||B>A||A>sum/2) return;
    int C=sum-A-B;  flag[A][B]=1;
    if(A>=B&&B>=C){
        double temp=cal(A,B,C);
        ans=max(ans,temp);
    }
    fr(i,0,n){
        if(vis[i]) continue;
        vis[i]=1;
        dfs(A+a[i],B);
        vis[i]=0;
    }
    fr(i,0,n){
        if(vis[i]) continue;
        vis[i]=1;
        dfs(A,B+a[i]);
        vis[i]=0;
    }
}

int main()
{
   int i,j,k;

   while(~scanf("%d",&n))
   {
	   sum=0;ans=0;
	   memset(flag,0,sizeof(flag));
	   memset(vis,0,sizeof(vis));
	   for(i=0;i<n;i++)
		   scanf("%d",a+i),sum+=a[i];
	   dfs(0,0);

	   if(ans==0)printf("-1\n");
	   else printf("%d\n",ans);
   }
   return 0;
}

DP:

dp[0][0]=1

dp[j][k]=能否组成长为j,k两条边的三角形。也默认是k<=j

dp[j][k]=1   if     j >= x[i] && dp[j - x[i]][k] || k >= x[i] && dp[j][k - x[i]]

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
using namespace std;
int x[41], n, tot = 0, ans = -1, half;
bool dp[801][801];
int main()
{int i;
    scanf("%d", &n);
    for( i = 1; i <= n; i++)
    {
        scanf("%d", &x[i]);
        tot += x[i];
    }
    memset(dp, 0, sizeof(dp));
    dp[0][0] = 1, half = tot >> 1;
    for( i = 1; i <= n; i++)
        for(int j = half; j >= 0; j--)
            for(int k = j; k >= 0; k--)
                if (j >= x[i] && dp[j - x[i]][k] || k >= x[i] && dp[j][k - x[i]])
                    dp[j][k] = 1;
    for( i = half; i >= 1; i--)
        for(int j = i; j >= 1; j--)
            if (dp[i][j])
            {
                int k = tot - i - j;
                if (i + j > k && i + k > j && j + k > i)
                {
                    double p = (i + j + k) * 1.0 / 2;
                    int temp = (int)(sqrt(p * (p - i) * (p - j) * (p - k)) * 100);
                    if (temp > ans)
                        ans = temp;
                }
            }
    cout << ans << endl;
    return 0;
}

DP2:

思路：从三角形的两边出发，设dp[i][j][k]表示用前i根木棍能否组成一边长度为j，另一边长度为k的边，容易发现该状态具有最优子结构性质，递推关系为：

dp[i][j][k] = dp[i-1][j][k] | dp[i-1][j-len[i]][k] |dp[i-1][j][k-len[i]];

#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;

int len[45], n;
bool dp[45][1000][1000];

double cul (int a, int b, int c)
{
double p = (a + b + c) / 2.0;
return sqrt (p * (p - a) * (p - b) * (p - c));
}
int main ()
{
int i, j, k, s;
int bound, sum = 0;
double tmp, area = 0;

scanf ("%d", &n);
for (i = 1; i <= n; i++)
{
   scanf ("%d", &len[i]);
   sum += len[i];
}
bound = sum / 2;
dp[0][0][0] = true;
for (i = 1; i <= n; i++)
   for (j = 0; j <= bound; j++)
    for (k = 0; k <= bound; k++)
     dp[i][j][k] = dp[i-1][j][k] | (len[i] <= j && dp[i-1][j-len[i]][k])
      | (len[i] <= k && dp[i-1][j][k-len[i]]);
for (j = 1; j <= bound; j++)
   for (k = 1; k <= bound; k++)
   {
    s = sum - j - k;
    if (dp[n][j][k] && j + k > s && j + s > k && k + s > j &&(tmp = cul (j, k, s)) > area)
     area = tmp;
   }
if (area == 0) printf ("-1\n");
else printf ("%d\n", int (area * 100));
return 0;
}