hdu 2829 Lawrence， hdu 3045 Picnic Cows，hdu 3480 Division ， 斜率dp

斜率优化DP算法解析
最新推荐文章于 2019-07-17 00:26:39 发布
原创 最新推荐文章于 2019-07-17 00:26:39 发布 · 950 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#斜率dp

本文介绍了斜率优化动态规划算法的应用案例，包括hdu2829、hdu3045和hdu3480三道题目。通过这些实例展示了如何使用斜率优化技巧来提高动态规划算法效率，特别关注于如何利用单调队列进行优化。

斜率dp的几题.

hdu2829

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")
//HEAD
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//LOOP
#define FF(i, a, b) for(int i = (a); i < (b); ++i)
#define FD(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FED(i, b, a) for(int i = (b); i>= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(A,value) memset(A,value,sizeof(A))

#define RI(n) scanf("%d", &n)
#define RII(n, m) scanf("%d%d", &n, &m)
#define RIII(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define RIV(n, m, k, p) scanf("%d%d%d%d", &n, &m, &k, &p)
#define RV(n, m, k, p, q) scanf("%d%d%d%d%d", &n, &m, &k, &p, &q)
#define RS(s) scanf("%s", s)
//OUTPUT
#define WI(n) printf("%d\n", n)
#define WS(s) printf("%s\n", s)
typedef long long LL;
typedef vector <int> VI;
const int INF = 1000000000;
const double eps = 1e-10;
const int MAXN = 1005;

int n, m;
int s[MAXN];
int a[MAXN];
int tol;
int q[MAXN], be, ed;
int dp[MAXN][MAXN];

int getUp(int i, int j, int k)
{
//    return -1 * dp[k - 1][j] + s[j] * s[j] - (-1 * dp[k - 1][i] + s[i] * s[i]);
    return s[j] * s[j] - dp[k - 1][j] - (s[i] * s[i] - dp[k - 1][i]);
}

int getDown(int i, int j)
{
    return s[j] - s[i];
}

void solve()
{
    FE(i, 1, m)
    {
        be = 1;
        ed = 0;
        q[++ed] = i;
        FE(j, i + 1, n)
        {
            while (be < ed)
            {
                int p1= q[be];
                int p2 = q[be + 1];
                int x1 = getDown(p1, p2);
                int y1 = getUp(p1, p2, i);
                if (y1 <= s[j] * x1) be++;
                else break;
            }
            int p = q[be];
            dp[i][j] = dp[i - 1][p] + s[p] * (s[j] - s[p]);

            while(be < ed)
            {
                int p1 = q[ed - 1];
                int p2 = q[ed];
                int x1 = getDown(p1, p2);
                int x2 = getDown(p2, j);
                int y1 = getUp(p1, p2, i);
                int y2 = getUp(p2, j, i);
                if (y1 * x2 >= y2 * x1) ed--;
                else break;
            }
            q[++ed] = j;
        }
    }
    printf("%d\n", tol - dp[m][n]);
}

int main ()
{
    while (~RII(n, m) && (n || m))
    {
        s[0] = 0;
        FE(i, 1, n)
        {
            RI(a[i]);
            s[i] = s[i - 1] + a[i];
        }
        tol = 0;
        FED(i, n, 2)
        {
            tol += a[i] * s[i - 1];
        }
        CLR(dp, 0);
        solve();
    }
    return 0;
}

hdu3045 

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")
//HEAD
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//LOOP
#define FF(i, a, b) for(int i = (a); i < (b); ++i)
#define FD(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FED(i, b, a) for(int i = (b); i>= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(A,value) memset(A,value,sizeof(A))


//INPUT
#define RI(n) scanf("%d", &n)
#define RII(n, m) scanf("%d%d", &n, &m)
#define RIII(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define RIV(n, m, k, p) scanf("%d%d%d%d", &n, &m, &k, &p)
#define RV(n, m, k, p, q) scanf("%d%d%d%d%d", &n, &m, &k, &p, &q)
#define RS(s) scanf("%s", s)
//OUTPUT
#define WI(n) printf("%d\n", n)
#define WS(s) printf("%s\n", s)
typedef long long LL;
typedef vector <int> VI;
const int INF = 1000000000;
const double eps = 1e-10;
const int MAXN = 400005;


int q[MAXN];
LL dp[MAXN];
LL a[MAXN], s[MAXN];
int be, ed;
int n, k;


LL getUp(int i, int j)
{
    return dp[j] - s[j] + j * a[j + 1] - (dp[i] - s[i] + i * a[i + 1]);
}


LL getDown(int i, int j)
{
    return a[j + 1] - a[i + 1];
}


void solve()
{
    CLR(dp, 0);///
    be = 1;
    ed = 0;
    q[++ed] = 0;
    FE(i, k, n)///
    {
        while (be < ed)
        {
            int p1 = q[be];
            int p2 = q[be + 1];
            LL x1 = getDown(p1, p2);
            LL y1 = getUp(p1, p2);
            if (y1 <= i * x1) be++;
            else break;
        }
        int p = q[be];
        dp[i] = dp[p] + s[i] - s[p] - (i - p) * a[p + 1];
        int j = i - k + 1;


        if (j < k) continue;///!!!!!!!!!!!!!!!!!!!!!!!!!
        while (be < ed)
        {
            int p1 = q[ed - 1];
            int p2 = q[ed];
            LL x1 = getDown(p1, p2);
            LL x2 = getDown(p2, j);
            LL y1 = getUp(p1, p2);
            LL y2 = getUp(p2, j);
            if (y1 * x2 >= y2 * x1) ed--;
            else break;
        }
        q[++ed] = j;
    }
    printf("%I64d\n", dp[n]);
}
int main ()
{
    while (~RII(n, k))
    {
        FE(i, 1, n) scanf("%I64d", &a[i]);
        sort(a + 1, a + 1 + n);
        s[0] = 0;
        FE(i, 1, n) s[i] = s[i - 1] + a[i];
        solve();
    }
    return 0;
}

hdu3480 

//#pragma warning (disable: 4786)
//#pragma comment (linker, "/STACK:16777216")
//HEAD
#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <string>
#include <set>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
//LOOP
#define FF(i, a, b) for(int i = (a); i < (b); ++i)
#define FD(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define FE(i, a, b) for(int i = (a); i <= (b); ++i)
#define FED(i, b, a) for(int i = (b); i>= (a); --i)
#define REP(i, N) for(int i = 0; i < (N); ++i)
#define CLR(A,value) memset(A,value,sizeof(A))
#define CPY(a, b) memcpy(a, b, sizeof(a))
#define FC(it, c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
//STL
#define SZ(V) (int)V.size()
#define PB push_back
#define EQ(a, b) (fabs((a) - (b)) <= 1e-10)
#define ALL(c) (c).begin(), (c).end()
//INPUT
#define RI(n) scanf("%d", &n)
#define RII(n, m) scanf("%d%d", &n, &m)
#define RIII(n, m, k) scanf("%d%d%d", &n, &m, &k)
#define RIV(n, m, k, p) scanf("%d%d%d%d", &n, &m, &k, &p)
#define RV(n, m, k, p, q) scanf("%d%d%d%d%d", &n, &m, &k, &p, &q)
#define RS(s) scanf("%s", s)
//OUTPUT
#define WI(n) printf("%d\n", n)
#define WS(s) printf("%s\n", s)
typedef long long LL;
typedef unsigned long long ULL;
typedef vector <int> VI;
const int INF = 1000000000;
const double eps = 1e-10;
const int MAXN = 10005;

int q[MAXN], be, ed;
int a[MAXN];
int dp[5005][MAXN];
int n, m;
int getUp(int i, int j, int k)
{
    return dp[k - 1][j] - dp[k - 1][i] + a[j + 1] * a[j + 1] - a[i + 1] * a[i + 1];
}

int getDown(int i, int j)
{
    return a[j + 1] - a[i + 1];
}

int solve()
{
    FE(i, 1, n)
        dp[1][i] = (a[i] - a[1]) * (a[i] - a[1]);
    FE(i, 2, m)
    {
        be = 1;
        ed = 0;
        q[++ed] = i - 1;
        FE(j, i, n)
        {
            while (be < ed)
            {
                int p1 = q[be];
                int p2 = q[be + 1];
                int x1 = getDown(p1, p2);
                int y1 = getUp(p1, p2, i);
                if (y1 <= 2 * a[j] * x1) be++;
                else break;
            }
            int p = q[be];
            dp[i][j] = dp[i - 1][p] + (a[j] - a[p + 1]) * (a[j] - a[p + 1]);
            while (be < ed)
            {
                int p1 = q[ed - 1];
                int p2 = q[ed];
                int p3 = j;
                int x1 = getDown(p1, p2);
                int x2 = getDown(p2, p3);
                int y1 = getUp(p1, p2, i);
                int y2 = getUp(p2, p3, i);
                if (x1 * y2 <= x2 * y1) ed--;
                else break;
            }
            q[++ed] = j;
        }
    }
    printf("%d\n", dp[m][n]);
}

int main ()
{
    int T;
    RI(T);
    int iCase = 1;
    while (T--)
    {
        RII(n, m);
//        a[0] = 0;
        FE(i, 1, n)
            RI(a[i]);
        sort(a + 1, a + 1 + n);
//        CLR(dp, 0);
        printf("Case %d: ",iCase++);
        solve();
    }
    return 0;
}


dp斜率优化 Hdu 3480 Division 题解
Monica
05-17 1151
累加器传送门：：http://blog.youkuaiyun.com/NOIAu/article/details/71775000题目传送门：https://vjudge.net/problem/HDU-3480题目：Little D is really interested in the theorem of sets recently. There’s a problem that confused him
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
标题中的“DP.rar”表明这是一个关于动态规划的资料压缩包，而“DP_hdu”暗示了这些题目可能来自杭州电子科技大学（HDU）的在线编程平台。动态规划通常用于解决那些可以通过子问题的最优解来构建原问题最优解的问题...
HDU-2829 Lawrence 【斜率优化DP】【四边形不等式优化】
babao9492的博客
02-26 201
题目链接 题意 背景故事大概是说一战时一个英国间谍Lawrence要指挥突击队去炸毁奥斯曼帝国的一些铁轨。铁轨上有n个火车站，按线性排列，每个火车站上有一个权值，最后整个铁路的价值就是每一段联通铁路段上的火车站权值两两相乘的和加起来（联通段上只有一个车站就是0）。Lawrence有m次炸毁两个车站之间铁路的机会，求Lawrence最终可以使得这段铁路价值变成的...
Lawrence HDU - 2829 （斜率优化dp）
untilyouydc
10-07 351
思路：还是先列出普通的dp方程，dp[i][j]=min(dp[k][j-1]+s(i,k+1))  表示到前i个站点，用了j次爆炸，得到的最小值，其中s(i,k+1)表示从k+1到i的连乘积。 直接做必然是n^3 因为需要枚举k。考虑到dp[i][j]，当j为定值，它随着i单调递增的，所以考虑使用斜率优化来做。 在分析之前先处理一下任意区间的连乘积问题： 有两种解决方案： 1. 记录前缀和...
HDU - 2829 Lawrence
ACVevtor的博客
10-07 389
题目：将一个序列分成m+1段，每段的价值定义为任意两个数的乘积之和，求总的最小价值 思路： cost[i][j]表示i到j成为一段的价值 设dp[i][j]表示前j个数分成i段的最小价值 dp[i][j]=min{dp[i-1][k]+cost[k+1][j]} cost[1][i]=cost[1][k]+cost[k+1][i]+sum[k]*(sum[i]-sum[k]) 将cos
HDU-2829 Lawrence
slass-mot-odet
07-17 312
T. E. Lawrence was a controversial figure during World War I. He was a British officer who served in the Arabian theater and led a group of Arab nationals in guerilla strikes against the Ottoman Empir...
HDU-2829-Lawrence
z309241990的专栏
09-12 833
这个题是DP，但要用四边形定理进行优化，好像用斜率也可以优化。
HDU上的专题训练
Inkbamboo专栏
04-23 1588
转载自:http://blog.youkuaiyun.com/wconvey/article/details/7460909 HDU上的专题训练（背包问题-线段树+树状数组+DP优化+网络流+字符匹配+最短路+矩阵乘法+搜索专题++） 就是DIY上的专题训练 【背包问题】 2602 Bone Collector      1114 Piggy-Bank
hdu 2829 lawrence 斜率优化dp
06-28
hdu 2829 Lawrence 斜率优化dp 这道题是一道经典的斜率优化dp题目，需要用到单调队列的思想。 题目大意是给定一个序列a，求出一个序列b，使得b[i]表示a[1]~a[i]中的最小值，且满足b[i] = min{b[j] + (i-j)*k}，...
HDU_2010.rar_hdu 2010_hdu 20_hdu acm20
09-14
【标题】"HDU_2010.rar"是一个压缩包文件，其中包含了与"HDU 2010"相关的资源，特别是针对"HDU ACM20"比赛的编程题目。"hdu 2010"和"hdu 20"可能是该比赛的不同简称或分类，而"hdu acm20"可能指的是该赛事的第20届...
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
HDU - 2829 Lawrence [ 斜率优化dp ]
Acer12138的博客
09-27 371
题目链接 : HDU - 2829 题意 : 给出一条笔直无分叉的铁路上有n个仓库，每个仓库有一个v[i]代表价值； 每两个仓库之间算作一段铁路，现在有m次攻击机会，一次攻击可以炸毁一段铁路； m次攻击后，剩余的总价值为：Σ(v[i]*v[j])，i和j为所有任意两个互相可到达的仓库。 现要求选定m段铁路进行攻击炸毁，然后使得总价值最小。 思路 : 正常的思路，首先想到用滚动数组，用dp[i][j...
HDU 2829 Lawrence （斜率优化DP/ 四边形优化）
咸鱼有梦想
01-23 353
Lawrence Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4703    Accepted Submission(s): 2167 Problem Description T. E. Lawrence was a
zujt ZJUT 1423 地下迷宫 高斯消元法 概率DP
冰
10-26 7157
参考： http://www.cnblogs.com/kuangbin/archive/2012/10/02/2710606.html 第二个高斯消元解概率dp，1ac /* 地下迷宫 Description: 由于山体滑坡，DK被困在了地下蜘蛛王国迷宫。为了抢在DH之前来 到TFT，DK必须尽快走出此迷宫。此迷宫仅有一个出口，而由于大BOSS 的力量减弱影响到了DK，使D
Uva 11270 Tiling Dominoes 轮廓线dp入门题
冰
11-15 2975
Tiling Dominoes, Uva 11270, 轮廓线dp入门题 将n*m的网格分成n*m个阶段 每个阶段i*j有2^m个状态 dp[n][m][1 对于每个阶段的每个状态有3种转移方式 （1）不放 （2）竖放 （3）横放 转移条件见注释 //#pragma comment(linker, "/STACK:1024000000,1024000000") #include
hdu 4804 Campus Design （2013 南京 轮廓线dp）
冰
11-30 2752
hdu 4804 Campus Design （2013 南京 ） 水轮廓线dp，有一个类似的题目 Uva 11270 Tiling Dominoes 本题是在其基础上加了一些东西而已， （1）可以放1*2的块、1*1的块，分别根据其特点转移即可 （2） 1*1的块有个数要求；增加一维表示用的1* 1块个数即可 （3）有些格子不能放，有些格子能
四边形优化dp
冰
10-14 1662
理解： http://blog.renren.com/share/263498909/1064362501 http://www.cnblogs.com/ronaflx/archive/2011/03/30/1999764.html http://yomean.blog.163.com/blog/static/189420225201272864127683/
hdu4085 Peach Blossom Spring （斯坦纳树，状态dp）spfa
冰
10-29 1558
（1）集合中元素表示（1 （2）注意dp[i][ss] = min(dp[i][ss], dp[i][rr | s[i]] + dp[i][(ss ^ rr) | s[i]]);，后面的要 |s[i],保证状态的正确 （3）INF初始化CLR（dp， 0x3f） （4）注意斯坦纳树状态理解，分层松弛的理解 参考：http://endlesscount.blog.163.com/blog/s
cf235，D Roman and Numbers（状态压缩dp）引发对dp中几种状态类型的思考
冰
03-20 1476
由本题思考到dp问题的几种状态类型： 对于数据保存在数组a[n]，求解关于这n个数的相关的最优解或计数问题. （1）线性dp，每个状态表示为一个下标i（或者说是一个固定起点的区间[0, i]）（可以说是起点固定的区间dp） （2）区间dp，每个状态表示为一个区间[i, j];（枚举的过程考虑的整个区间的所有组合情况(区间组合的顺序)。） （3）状态压缩dp（集合上的dp），每个状态表示一个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值