HDU6365 （区间DP）

最新推荐文章于 2018-10-14 10:57:49 发布

原创最新推荐文章于 2018-10-14 10:57:49 发布 · 582 阅读

1 ·

CC 4.0 BY-SA版权

DP 同时被 3 个专栏收录

24 篇文章

订阅专栏

HDU

14 篇文章

订阅专栏

区间DP

1 篇文章

订阅专栏

本文介绍了一道算法题目，需要通过发射射线消灭不同防御力的障碍物，并求解所需的最小能量。采用离散化处理和动态规划方法，通过遍历最大防御力的障碍物并更新状态，得到解决问题的有效策略。

题意

以原点(0,0)为中心建立二维坐标轴，在一二象限有一些线段（障碍物）。

障碍物信息（H，L，R，W）分别表示高度、左右端点、和防御力。

现从原点发出一些射线来消灭这些障碍物，每条射线的能量为X，消灭防御力为Wi的障碍物最小的能量是Wi。

并且射线的能量在射穿障碍物是没有能量损耗的。

问最少需要多少能量能够消灭所有的障碍。

题解

1. 只需要考虑像所有障碍物的两个端点去发射射线，就能包含所有的情况，那么一共只有2n种射线。

2. 防御力最大的障碍物最终一定要被射穿，所以可以考虑每次从防御力最大的障碍物开始消灭。发射的射线会把沿途的其他障碍物一起消灭。
基于第一点，将所有端点按极角序进行离散化，端点下标为 1到2n 。

设立状态，dp[L][R]表示消灭端点在[LR]区间的所有线段，所需要花费的最小能量。

基于第二点，用K去遍历[L，R]，每次将区间内所包含的防御力最大的障碍物mv找出来，进行区间DP的转移：

dp[l][r] = min(dp[L][R], dp[L][K - 1] + dp[K + 1][r] + W(mv)); L<=L(mv)<=R(mv)<=R
dp[1][2n]最终的即是答案。

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <queue>
#include <vector>
#include <map>

using namespace std;
typedef long long ll;
const int maxn = 650;

struct Node {
    int x, h;
    Node(){}
    Node(int x, int h): x(x), h(h){}
    bool operator == (const Node& r) const {
        return 1ll*x*r.h - 1ll*r.x*h == 0;
    }
    bool operator < (const Node& r) const {
        return 1ll*x*r.h - 1ll*r.x*h < 0;
    }
}node[maxn];
ll dp[maxn][maxn];
int T, n;
int tot; ///离散化后X坐标的个数

int find(Node P)
{
    return lower_bound(node+1, node+1+tot, P) - node;
}

int w[maxn];
int Li[maxn], Ri[maxn]; ///离散化后的横坐标
int L[maxn], R[maxn], H[maxn];
int main()
{
    for(scanf("%d", &T); T; T--)
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
        {
            scanf("%d%d%d%d", &H[i], &L[i], &R[i], &w[i]);
            node[i*2-1] = Node(L[i], H[i]);
            node[i*2] = Node(R[i], H[i]);
        }
        sort(node+1, node+2*n+1);
        tot = unique(node+1, node+n*2+1)- node - 1; ///离散化去重
        
        for(int i = 1; i <= n; i++) ///在node中找到相应位置
        {
            Li[i] = find(Node(L[i], H[i])); 
            Ri[i] = find(Node(R[i], H[i]));
        }
        for(int len = 1; len <= tot; len++) ///len区间长度
        {
            for(int l = 1; l+len-1 <= tot; l++) ///l区间起点
            {
                int r = l+len-1; ///区间终点
                dp[l][r] = (1ll<<60);
                int mx = -1, mv;///mv障碍物编号
                for(int k = 1; k <= n; k++) 
                {
                    if(l <= Li[k] && Ri[k] <= r) { ///[l,r]找这段区间中全职最大的障碍
                        if(w[k] > mx) {
                            mx = w[k];
                            mv = k;
                        }
                    }
                }
                int s = Li[mv], e = Ri[mv];
                if(mx == -1) dp[l][r] = 0;
                else {
                    for(int k = s; k <= e; k++)
                        dp[l][r] = min(dp[l][r], dp[l][k-1]+dp[k+1][r]+mx);
                }
            }
        }
        printf("%I64d\n", dp[1][tot]);
    }

    return 0;
}