最长k可重区间集问题

本文介绍了一种解决区间跳过最短路径问题的方法,通过构建数轴模型和使用最大流最小费用算法来求解最优路径。具体实现包括离散化处理、建立边集和应用SPFA算法进行迭代优化。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目描述

题解:

当然上来就离散咯。

先建一条数轴,每个点向后一个点建容量为$k$的边;

然后对于每一个区间,左端点向右端点建容量为$1$的边,费用为离散之前的$l-r$。代表可以跳过这段区间。

代码:

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 1050
const int inf = 0x3f3f3f3f;
inline int rd()
{
    int f=1,c=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){c=10*c+ch-'0';ch=getchar();}
    return f*c;
}
int n,m,hed[N],cnt=-1,S,T,tot=0;
struct seg
{
    int l,r,w;
}s[N];
struct Pair
{
    int x,id,k;
    Pair(){}
    Pair(int x,int i,int k):x(x),id(i),k(k){}
}p[N];
bool cmp(Pair a,Pair b)
{
    return a.x<b.x;
}
struct EG
{
    int to,nxt,w,c;
}e[N*N*4];
void ae(int f,int t,int w,int c)
{
    e[++cnt].to = t;
    e[cnt].nxt = hed[f];
    e[cnt].w = w;
    e[cnt].c = c;
    hed[f] = cnt;
}
void AE(int f,int t,int w,int c)
{
    ae(f,t,w,c);
    ae(t,f,0,-c);
}
int dep[N],fl[N];
int pre[N],fa[N];
bool vis[N];
queue<int>q;
bool spfa()
{
    memset(dep,0x3f,sizeof(dep));
    dep[S] = 0,fl[S] = inf,vis[S] = 1;
    q.push(S);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(int j=hed[u];~j;j=e[j].nxt)
        {
            int to = e[j].to;
            if(e[j].w&&dep[to]>dep[u]+e[j].c)
            {
                dep[to] = dep[u]+e[j].c;
                fl[to] = min(fl[u],e[j].w);
                pre[to] = j,fa[to] = u;
                if(!vis[to])
                {
                    vis[to] = 1;
                    q.push(to);
                }
            }
        }
        vis[u] = 0;
    }
    return dep[T]!=inf;
}
int mcmf()
{
    int ret = 0;
    while(spfa())
    {
        ret+=fl[T]*dep[T];
        int u = T;
        while(u!=S)
        {
            e[pre[u]].w-=fl[T];
            e[pre[u]^1].w+=fl[T];
            u = fa[u];
        }
    }
    return ret;
}
int main()
{
    n = rd(),m = rd();
    S = 0,T = 1030;
    memset(hed,-1,sizeof(hed));
    int k = 0;
    for(int i=1;i<=n;i++)
    {
        s[i].l=rd(),s[i].r=rd(),s[i].w=s[i].r-s[i].l;
        p[++tot] = Pair(s[i].l,i,0);
        p[++tot] = Pair(s[i].r,i,1);
    }
    sort(p+1,p+1+tot,cmp);
    for(int las=-1,i=1;i<=tot;i++)
    {
        if(las!=p[i].x)
        {
            las = p[i].x;
            k++;
        }
        if(!p[i].k)s[p[i].id].l = k;
        else AE(s[p[i].id].l,k,1,-s[p[i].id].w);
    }
    AE(S,1,m,0);AE(k,T,m,0);
    for(int i=1;i<k;i++)
        AE(i,i+1,m,0);
    printf("%d\n",-mcmf());
    return 0;
}

 

转载于:https://www.cnblogs.com/LiGuanlin1124/p/10256747.html

### 区间动态规划 区间动态规划是一种特殊的动态规划形式,适用于解决涉及一段连续区间的最优化问题。其核心思想是将整个区间划分为若干小子区间,并逐步扩展这些子区间来构建全局最优解。 #### 基本原理 在区间动态规划中,通常会定义一个二维数组 `dp[i][j]` 来表示从位置 `i` 到位置 `j` 的某个属性的最优值。通过枚举中间点 `k`,可以将区间 `[i, j]` 分割成两个子区间 `[i, k]` 和 `[k+1, j]` 进行递推计算[^3]。 #### 应用实例 经典的区间动态规划问题是矩阵链乘法问题。给定一系列矩阵 `{A1, A2, ..., An}`,目标是以最少的操作数完成它们的连乘积。可以通过如下方式实现: ```python def matrix_chain_order(p): n = len(p) - 1 dp = [[0]*n for _ in range(n)] for l in range(2, n+1): # 子链长度 for i in range(n-l+1): j = i + l - 1 dp[i][j] = float('inf') for k in range(i, j): q = dp[i][k] + dp[k+1][j] + p[i]*p[k+1]*p[j+1] if q < dp[i][j]: dp[i][j] = q return dp[0][-1] ``` 上述代码实现了基于区间动态规划的矩阵链乘法最小代价计算。 --- ### 树状动态规划 树状动态规划是指在树形结构上进行动态规划的一种方法。它常用于处理树有关的各种最优化问题,比如最大独立、最小支配问题。 #### 基本思路 对于一棵树而言,可以从根节点出发自顶向下或者自底向上地遍历整棵树,在此过程中维护某些状态并更新相应的 DP 数组。一般情况下,设 `dp[u][state]` 表示以结点 `u` 为根的子树满足某种条件下的最优值。 #### 实现方法 以下是关于如何在一个无向图中的二叉树上执行树状动态规划的例子——寻找该树的最大权值路径和: ```python from collections import defaultdict class TreeNode: def __init__(self, val=0): self.val = val self.children = [] def max_path_sum(root): def dfs(node): nonlocal res current_max = node.val for child in node.children: gain = dfs(child) if gain > 0: current_max += gain res = max(res, current_max) return current_max res = float('-inf') dfs(root) return res ``` 在这个例子中,我们采用深度优先搜索 (DFS),并通过累积每条边带来的收益最大化整体路径权之和。 --- ### 总结对比 | 特性 | 区间动态规划 | 树状动态规划 | |--------------------|---------------------------------------|-----------------------------------| | **适用范围** | 处理线性序列上的分段操作 | 针对具有层次关系的数据结构 | | **状态转移方向** | 自下而上 | 可能是从叶子到根或相反 | | **典型应用场景** | 矩阵链乘法、石子合并 | 最大树高、最长路径求解等 | ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值