四边形优化dp

理解：

题目总结：

http://www.cnblogs.com/ronaflx/archive/2011/03/30/1999764.html

下摘自：http://www.cnblogs.com/zxndgv/archive/2011/08/02/2125242.html

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------

最有代价用d[i,j]表示

d[i,j]=min{d[i,k-1]+d[k+1,j]}+w[i,j]

当中w[i,j]=sum[i,j]

四边形不等式

     w[a,c]+w[b,d]<=w[b,c]+w[a,d](a<b<c<d) 就称其满足凸四边形不等式

决策单调性

     w[i,j]<=w[i',j']   ([i,j]属于[i',j']) 既 i'<=i<j<=j'

于是有下面三个定理

定理一：假设w同一时候满足四边形不等式和决策单调性 ,则d也满足四边形不等式

定理二：当定理一的条件满足时，让d[i,j]取最小值的k为K[i,j]，则K[i,j-1]<=K[i,j]<=K[i+1,j]

定理三：w为凸当且仅当w[i,j]+w[i+1,j+1]<=w[i+1,j]+w[i,j+1]

由定理三知推断w是否为凸即推断 w[i,j+1]-w[i,j]的值随着i的添加是否递减

于是求K值的时候K[i,j]仅仅和K[i+1,j] 和 K[i,j-1]有关。所以能够以i-j递增为顺序递推各个状态值终于求得结果将O(n^3)转为O(n^2)

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------

注意：

注意决策单调性顺序，既要符合决策调性，也要符合题意 (!!!!)

注意枚举顺序，依据dp方程和决策单调性方程

注意初始化，防止訪问到无效状态或没处理的状态。

dp和s边界初始化，尤其是决策的上届和下届初始化。

例题1：

石子合并问题：hdu 3506

dp[i][j] = min{dp[i][k] + dp[k + 1][j] + cost[i, j] }, i <= k <= j - 1 , cost[i][j] = sum[j] - sum[i - 1]

s[i][j - 1] <= s[i][j] <= s[i + 1][j]

//#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 FE(i, a, b) for(int i = (a); i <= (b); ++i)

#define FD(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++)

//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 RS(s) scanf("%s", s)

//OUTPUT

#define WI(n) printf("%d\n", n)

#define WS(s) printf("%s\n", s)

typedef long long LL;

const int INF = 1000000007;

const double eps = 1e-10;

const int maxn = 2010;

int dp[maxn][maxn], s[maxn][maxn];

int w[maxn][maxn];

int n, m;

int val[maxn];

int sum[maxn];

///求dp最小值

///枚举 区间 由小到大

void solve()

{

//    memset(dp, 0, sizeof(dp));///初始化无效值

    FE(i, 1, 2 * n)

    {

        dp[i][i] = 0;

        s[i][i] = i;/// 初始化决策下届,为0

    }

    FE(len, 2, n)

    {

        for (int i = 2 * n - len; i >= 1; i--)

        {

            int j = i + len - 1;

            dp[i][j] = INF;

            int a = s[i][j - 1], b = s[i + 1][j];

            int cost = sum[j] - sum[i - 1];

            for (int k = a; k <= b; k++)

            {

                if (dp[i][j] > dp[i][k] + dp[k + 1][j] + cost)

                {

                    dp[i][j] = dp[i][k] + dp[k + 1][j] + cost;

                    s[i][j] = k;

                }

            }

        }

    }

}

int main ()

{

    while (~RI(n))

    {

        FE(i, 1, n) RI(val[i]), val[i + n] = val[i];;

        FE(i, 1, 2 * n) sum[i] = sum[i - 1] + val[i];

//        pre();

        solve();

        int ans = INF;

        FE(i, 1, n)

        {

            if (ans > dp[i][n + i - 1])

                ans = dp[i][n + i - 1];

        }

        printf("%d\n", ans);

    }

    return 0;

}

例题2：邮局问题：

id=1160">poj 1160

1:注意此法的 i 和 j 顺序与寻常不同

此时决策区间为：s[i - 1][j] <= s[i][j] <= s[i][j + 1] (!!!)

详细见凝视:

//#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 FE(i, a, b) for(int i = (a); i <= (b); ++i)

#define FD(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++)

//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 RS(s) scanf("%s", s)

//OUTPUT

#define WI(n) printf("%d\n", n)

#define WS(s) printf("%s\n", s)

typedef long long LL;

const int INF = 1000000007;

const double eps = 1e-10;

const int maxn= 1000010;

int dp[33][333], s[33][333];

int w[333][333];

int n, m;

int val[333];

int sum[333];

///dp[i][j] = min{dp[i - 1][k] + w[k + 1][j]}, i - 1 <= k <= j - 1

///一般要求 i <= j （！！）

///s[i - 1][j] <= s[i][j] <= s[i][j + 1] （！

！

）

///注意决策单调性顺序，既要符合决策调性，也要符合题意 (!!!!)

///注意枚举顺序，依据dp方程和决策单调性方程

///注意初始化，防止訪问到无效状态或没处理的状态。dp和s边界初始化。尤其是决策的上届和下届初始化。

void pre()

{

    for(int i = 1; i <= n; i ++) //这里有一个递推公式能够进行预处理

    {

        w[i][i] = 0;

        for(int j = i + 1; j <= n; j ++)

        {

            int mid = (j + i) >> 1;

            w[i][j] = w[i][j - 1] + val[j] - val[mid];

//            int x = sum[j] - sum[mid] - val[mid] * (j - mid);

//            x += val[mid] * (mid - i) - (sum[mid - 1] - sum[i - 1]);

        }

    }

}

///求dp最小值

///枚举i从小到大

///再枚举j从大到小

void solve()

{

    memset(dp, 0, sizeof(dp));///初始化无效值

    FE(i, 1, n)

    {

        dp[1][i] = w[1][i];

        s[1][i] = 0;/// 初始化决策下届,为0

    }

    FE(i, 2, m)

    {

        //s[1][i] = 0;

        s[i][n + 1] = n;///初始化决策上届

        for (int j = n; j >= i; j--)

        {

            int tmp = dp[i][j] = INF;///初始化最优值

            int a = s[i - 1][j], b = s[i][j + 1];

            //a = max(a, i - 1); b = min(b, j - 1); // i - 1 <= k <= j - 1

            for (int k = a; k <= b; k++) ///保证枚举到的都是有效状态，且都已计算过

            {

                if (tmp > dp[i - 1][k] + w[k + 1][j])

                {

                    tmp = dp[i - 1][k] + w[k + 1][j];

                    s[i][j] = k;

                }

            }

            dp[i][j] = tmp;

        }

    }

}

int main ()

{

    while (~RII(n, m))

    {

        FE(i, 1, n) RI(val[i]), sum[i] = sum[i - 1] + val[i];

        pre();

        solve();

        printf("%d\n", dp[m][n]);

    }

    return 0;

}

2:-详细见凝视

此时决策区间为：s[i][j - 1] <= s[i][j] <= s[i + 1][j] (!!!)

//#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 FE(i, a, b) for(int i = (a); i <= (b); ++i)

#define FD(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++)

//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 RS(s) scanf("%s", s)

//OUTPUT

#define WI(n) printf("%d\n", n)

#define WS(s) printf("%s\n", s)

typedef long long LL;

const int INF = 1000000007;

const double eps = 1e-10;

const int maxn= 1000010;

int dp[333][33], s[333][33];

int w[333][333];

int n, m;

int val[333];

int sum[333];

///dp[i][j] = min{dp[k][j - 1] + w[k + 1][j]}, j - 1 <= k <= i - 1

///此处i>=j

///s[i][j - 1] <= s[i][j] <= s[i + 1][j] （！！

）

///注意决策单调性顺序，既要符合决策调性，也要符合题意 (!!!!)

///注意枚举顺序。依据dp方程和决策单调性方程

///注意初始化。防止訪问到无效状态或没处理的状态。

dp和s边界初始化，尤其是决策的上届和下届初始化。

void pre()

{

    for(int i = 1; i <= n; i ++) //这里有一个递推公式能够进行预处理

    {

        w[i][i] = 0;

        for(int j = i + 1; j <= n; j ++)

        {

            int mid = (j + i) >> 1;

            w[i][j] = w[i][j - 1] + val[j] - val[mid];

        }

    }

}

///求dp最小值

///枚举i从小到大

///再枚举j从大到小

void solve()

{

    memset(dp, 0, sizeof(dp));///初始化无效值

    FE(i, 1, n)

    {

        dp[i][1] = w[1][i];

        s[i][1] = 0;/// 初始化决策下届,为0

    }

    FE(i, 2, m)

    {

        //s[i][1] = 0;

        s[n + 1][i] = n;///初始化决策上届

        for (int j = n; j >= i; j--)

        {

            int tmp = dp[j][i] = INF;///初始化最优值

            int a = s[j][i - 1], b = s[j + 1][i];

            //a = max(a, i - 1); b = min(b, j - 1);

            for (int k = a; k <= b; k++) ///保证枚举到的都是有效状态，且都已计算过

            {

                if (tmp > dp[k][i - 1] + w[k + 1][j])

                {

                    tmp = dp[k][i - 1] + w[k + 1][j];

                    s[j][i] = k;

                }

            }

            dp[j][i] = tmp;

        }

    }

}

int main ()

{

    while (~RII(n, m))

    {

        FE(i, 1, n) RI(val[i]);

        pre();

        solve();

        printf("%d\n", dp[n][m]);

    }

    return 0;

}

四边形优化dp的更多相关文章

HDU 2829 Lawrence(四边形优化DP O（n^2）)
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2829 题目大意:有一段铁路有n个站,每个站可以往其他站运送粮草,现在要炸掉m条路使得粮草补给最小,粮草 ...
HDOJ 3516 Tree Construction 四边形优化dp
原题链接:http://acm.hdu.edu.cn/showproblem.php?pid=3516 题意: 大概就是给你个下凸包的左侧,然后让你用平行于坐标轴的线段构造一棵树,并且这棵树的总曼哈顿 ...
hdu2829 四边形优化dp
Lawrence Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total S ...
[NOI2009]诗人小G 四边形优化DP
题目传送门 f[i] = min(f[j] + val(i,j); 其中val(i,j) 满足四边形dp策略. 代码: #include<bits/stdc++.h> using nam ...
zoj 2860 四边形优化dp
Breaking Strings Time Limit: 2 Seconds Memory Limit: 65536 KB A certain string-processing lan ...
HDU3507 Print Article(斜率优化dp)
前几天做多校,知道了这世界上存在dp的优化这样的说法,了解了四边形优化dp,所以今天顺带做一道典型的斜率优化,在百度打斜率优化dp,首先弹出来的就是下面这个网址:http://www.cnblogs. ...
hdu 2829 Lawrence(四边形不等式优化dp)
T. E. Lawrence was a controversial figure during World War I. He was a British officer who served in ...
BZOJ1563/洛谷P1912 诗人小G 【四边形不等式优化dp】
题目链接洛谷P1912[原题,需输出方案] BZOJ1563[无SPJ,只需输出结果] 题解四边形不等式什么是四边形不等式? 一个定义域在整数上的函数\(val(i,j)\),满足对\(\for ...
HDU 3506 (环形石子合并)区间dp+四边形优化
Monkey Party Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 131072/65536 K (Java/Others)Tot ...

随机推荐

spring boot get和post请求,以及requestbody为json串时候的处理
GET.POST方式提时, 根据request header Content-Type的值来判断: application/x-www-form-urlencoded, 可选(即非必须,因为这种情况的 ...
虚拟机之openVZ简单基础
OpenVZ的是免费的开源软件,基于GNU GPL协议. OpenVZ的是基于Linux的容器虚拟化. OpenVZ在一台服务器上能够创建创建多个安全隔离的Linux容器(也称为虚拟环境或的VPS), ...
TCP、UDP、HTTP、SOCKET之间的区别与联系
IP:网络层协议: TCP和UDP:传输层协议: HTTP:应用层协议: SOCKET:TCP/IP网络的API. TCP/IP代表传输控制协议/网际协议,指的是一系列协议. TCP和UDP使用IP协 ...
react篇章-React Props
state 和 props 主要的区别在于 props 是不可变的,而 state 可以根据与用户交互来改变.这就是为什么有些容器组件需要定义 state 来更新和修改数据. 而子组件只能通过 pro ...
Python并发编程系列之常用概念剖析：并行串行并发同步异步阻塞非阻塞进程线程协程
1 引言并发.并行.串行.同步.异步.阻塞.非阻塞.进程.线程.协程是并发编程中的常见概念,相似却也有却不尽相同,令人头痛,这一篇博文中我们来区分一下这些概念. 2 并发与并行在解释并发与并行之前 ...
hdu-5023线段树刷题
title: hdu-5023线段树刷题 date: 2018-10-18 13:32:13 tags: acm 刷题 categories: ACM-线段树概述这道题和上次做的那道染色问题一样, ...
批量ssh登录，获取操作系统、CPU、内存、硬盘信息<shell>
说明:该脚本读取machine.txt文件中的机器名,然后批量ssh登录,获取每台机器的操作系统,CPU,内存,硬盘等信息. 使用方法:将文件保存为sh,chmod +x filename 为该sh文 ...
解决python2.x文件读写编码问题
转自: https://xrlin.github.io/%E8%A7%A3%E5%86%B3python2.x%E6%96%87%E4%BB%B6%E8%AF%BB%E5%86%99%E7%BC%96 ...
python语法（一）
Python是一种面向对象.直译式电脑编程语言,也是一种功能强大的通用型语言,已经具有近二十年的发展历史,成熟且稳定.在近几年,大数据,人工智能火起来之后也是水涨船高,被越来越多的人知道,并且越来越多 ...
[BZOJ5298][CQOI2018]交错序列(DP+矩阵乘法)
https://blog.csdn.net/dream_maker_yk/article/details/80377490 斯特林数有时并没有用. #include<cstdio> #in ...

四边形优化dp

四边形优化dp的更多相关文章

随机推荐

热门专题