HDU 3392 Pie(滚动数组优化)

Problem Description

A lot of boys and girls come to our company to pie friends. After we get their information, we need give each of them an advice for help. We know everyone’s height, and we believe that the less difference of a girl and a boy has, the better it is. We need to
find as more matches as possible, but the total difference of the matches must be minimum.

Input

The input consists of multiple test cases. The first line of each test case contains two integers, n, m (0 < n, m <= 10000), which are the number of boys and the number of girls. The next line contains n float numbers, indicating the height of each boy. The
last line of each test case contains m float numbers, indicating the height of each girl. You can assume that |n – m| <= 100 because we believe that there is no need to do with that if |n – m| > 100. All of the values of the height are between 1.5 and 2.0.

The last case is followed by a single line containing two zeros, which means the end of the input.

Output

Output the minimum total difference of the height. Please take it with six fractional digits.

Sample Input

2 3
1.5 2.0
1.5 1.7 2.0
0 0

Sample Output

0.000000

Author

[email protected]

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<limits.h>
#include<cmath>
typedef long long LL;
using namespace std;
const int maxn=10000+100;
double A[maxn],G[maxn];
double dp[2][maxn];
int n,m;
int main()
{
    while(~scanf("%d%d",&n,&m)&&(n+m))
    {
        if(n>m)  swap(n,m);
        for(int i=1;i<=n;i++)
            scanf("%lf",&A[i]);
        for(int i=1;i<=m;i++)
            scanf("%lf",&G[i]);
        double *b=A,*g=G;
//        if(n>m)   {swap(n,m);swap(b,g);}
        memset(dp,0,sizeof(dp));
        sort(b+1,b+n+1);
        sort(g+1,g+m+1);
        for(int i=1;i<=n;i++)
        {
            for(int j=i;j<=i+m-n;j++)
            {
                if(i==j)
                   dp[i&1][j]=dp[(i-1)&1][j-1]+fabs(b[i]-g[j]);
                else
                   dp[i&1][j]=min(dp[(i-1)&1][j-1]+fabs(b[i]-g[j]),dp[i&1][j-1]);
            }
        }
        printf("%.6f\n",dp[n&1][m]);
    }
    return 0;
}
/*
2 5
1.0 2.0
0.7 1.5 1.5 1.8 2.8
5 2
0.7 1.5 1.5 1.8 2.8
1.0 2.0
*/

时间: 2024-12-24 12:43:36

HDU 3392 Pie(滚动数组优化)的相关文章

hdu 3392(滚动数组优化dp)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3392 Pie Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 793    Accepted Submission(s): 214 Problem Description A lot of boys and girls come to ou

HDU - 1024 Max Sum Plus Plus(dp+滚动数组优化)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1024 题意:给定n个数字,求其中m段的最大值(段与段之间不用连续,但是一段中要连续) 例如:2 5 1 -2 2 3 -1五个数字中选2个,选择1和2 3这两段. 题解:dp[i][j]从前j个数字中选择i段,然后根据第j个数字是否独立成一段,可以写出 状态转移方程:dp[i][j]=max(dp[i][j-1]+num[j],max(dp[i-1][k])+num[j]) 这里的max(dp[i-

HDU - 1024 Max Sum Plus Plus 滚动数组优化

给定n个数字,求其中m段的最大值(段与段之间不用连续,但是一段中要连续) 例如:2 5 1 -2 2 3 -1五个数字中选2个,选择1和2 3这两段. dp[i][j]从前j个数字中选择i段,然后根据第j个数字是否独立成一段,可以写出 状态转移方程:dp[i][j]=max(dp[i][j-1]+num[j],max(dp[i-1][k])+num[j]) 这里的max(dp[i-1][k])代表的拥有i-1段时的最大值,然后再加上num[j]独立成的一段. 但是题目中没有给出m的取值范围,有可

HDU 3392 Pie(DP+滚动数组)

题意:有一些男生女生,男生女生数量差不超过100 ,男生女生两两配对.要求求出一种配对方法,使每一对的高度差的和最小. 思路:(我是真的笨笨笨!!磨磨唧唧写一堆是因为我笨!我看了别人的博客,思路全是学别人的,轻喷!)设人少的一组人数为n,b[],人多的一组人数为m,g[](b[],g[]先排好序),用dp[i][j]表示n中的前i个人与m中的前j个人配对所得到的最小值. 那么dp[i][j]就是min(dp[i-1][k]+|b[i]-g[k]|),就是n中前i-1个人和m中前1~k个人配对的最

POJ 1159 回文LCS滚动数组优化

详细解题报告可以看这个PPT 这题如果是直接开int 5000 * 5000  的空间肯定会MLE,优化方法是采用滚动数组. 原LCS转移方程 : dp[i][j] = dp[i - 1][j] + dp[i][j -1] 因为 dp[i][j] 只依赖于 dp[i - 1][j] 和 dp[i][j - 1] 所以可以采用滚动数组如下: dp[i % 2][j] = dp[(i - 1) % 2][j] + dp[i % 2][j - 1] 可以实现节省空间的方法 答案存储在 dp[n % 2

POJ 1159 滚动数组优化内存

题意: 输入一个n和长度为n的字符串,求最少需要增加多少个字符,使之成为一个回文(从左到右读和从右到左读是一样的)   (其实就是括号配对的变形) 知识点: 滚动数组内存优化.就像dp[5005][5005] ,占用的内存太大 ,无法编译,利用滚动数组就能很好的解决这个问题,简单来说就是dp[3][5005]来代替dp[5005][5005] ,用dp[i%3][j],dp[(i-1)%3][j], dp[(i+1)%3][j]表示.(其实这一题还可以这样改:用short int dp[5005

字符串匹配dp+bitset,滚动数组优化——hdu5745(经典)

bitset的经典优化,即把可行性01数组的转移代价降低 bitset的适用情况,当内层状态只和外层状态的上一个状态相关,并且内层状态的相关距离是一个固定的数,可用bitset,换言之,能用滚动数组是能用bitset优化的前提 /* dp[i,j][0|1|2]表示p串的第i位,s串的第j位相匹配,pi和pi-1换,pi不换,pi和pi+1换的状态下是否能匹配 dp[i,j][0] = dp[i-1,j-1][2] & p[i-1]==s[j] dp[i,j][1] = (dp[i-1,j-1]

hdu 3450 树状数组优化dp

题意就不说了: hdu2227差不多只不过这道题不是递增  而是相邻差不超过d   其实是为都一样,  也有差别: 这道题没说范围  并且树之间的大小关系对结果有影响,所以树状数组里根据原来id来求,由于数值很大 所以还是用到离散化  这里的离散化感觉和映射差不多,离散化用来查找id: 当num[i]的id是x是,dp[i]表示方案数  很明显dp[i]=sun(dp[j],j<i&&abs(num[j]-num[i])<=d)  这里在树状数组里面就是求sum[1到num[i

HDU 1024 Max Sum Plus Plus --- dp+滚动数组

HDU 1024 题目大意:给定m和n以及n个数,求n个数的m个连续子系列的最大值,要求子序列不想交. 解题思路:<1>动态规划,定义状态dp[i][j]表示序列前j个数的i段子序列的值,其中第i个子序列包括a[j], 则max(dp[m][k]),m<=k<=n 即为所求的结果 <2>初始状态: dp[i][0] = 0, dp[0][j] = 0; <3>状态转移: 决策:a[j]自己成为一个子段,还是接在前面一个子段的后面 方程: a[j]直接接在前面