BZOJ1099 POI2007 树Drz

最新推荐文章于 2020-03-03 20:43:07 发布
最新推荐文章于 2020-03-03 20:43:07 发布
阅读量2.2k 收藏
点赞数 2
分类专栏： BZOJ 线段树 文章标签： poi 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fuxey/article/details/50637651
版权

第一页结束之前的一道槛……

从中文题解到波兰文题解 ， 折腾些时间才弄懂-_-# 。希望这篇题解能帮助后来者 ， 不要浪费过多的时间捣鼓在google 翻译和晦涩难懂的文字之间……

提示：
1. 本题目前没有一个可行的贪心策略 ， 每一次我们都需要考虑所有情况。
2. 在求i 的答案的时候我们先尝试去枚举每一个j , 你会发现 ， 只会有那么几种情况。 而每一种情况把绝对值表达式拆开的最终形式都是一样的 ， 这提示我们对于每一种情况最小值是可以维护的……
3. 你可能需要用一种数据结构去办到这一点。

详细题解在代码后：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <deque>
#include <stack>
#include <algorithm>

using namespace std;
typedef long long ll;

const ll INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 51000;

__inline int re() { int n; scanf("%d" , &n); return n; }


int n;
ll h[maxn] , res[maxn] ,  ori;
ll l[maxn] , r[maxn] , pl[maxn] , pr[maxn] , to[maxn];

void tension(ll& a , ll b) { a = min(a, b); }

ll cal(int x,int y)
{
     if (x==y) return ori;
     if (x>y) swap(x,y);
     if (x==1&&y==n) return ori-abs(h[1]-h[2])-abs(h[n-1]-h[n])+abs(h[n]-h[2])+abs(h[1]-h[n-1]);
     if (x==1&&y==2) return ori-abs(h[2]-h[3])+abs(h[1]-h[3]);
     if (x==n-1&&y==n) return ori-abs(h[n-1]-h[n-2])+abs(h[n-2]-h[n]);
     if (x+1==y) return ori-abs(h[x-1]-h[x])-abs(h[y+1]-h[y])+abs(h[x]-h[y+1])+abs(h[y]-h[x-1]);
     long long Sum=ori;
     if (x!=1) Sum=Sum-abs(h[x-1]-h[x])+abs(h[x-1]-h[y]);
     Sum=Sum-abs(h[x+1]-h[x])+abs(h[x+1]-h[y]);
     Sum=Sum-abs(h[y-1]-h[y])+abs(h[y-1]-h[x]);
     if (y!=n) Sum=Sum-abs(h[y+1]-h[y])+abs(h[y+1]-h[x]);
     return Sum;
}


bool cmp(int i , int j) { return h[i] < h[j]; }
int id[maxn] , id1[maxn] , id2[maxn];
vector<ll> dic;
void init()
{
    for(int i=1;i<=n;i++)  dic.push_back(h[i]) , id[i] = i;

    sort(id+1, id+1+n, cmp);
    sort(dic.begin(), dic.end());

    for(int i=2;i<n;i++) l[i] = min(h[i-1] , h[i+1]) , r[i] = max(h[i-1], h[i+1]);  
    for(int i=1;i<=n;i++) to[id[i]] = i;
    for(int i=2;i<n;i++) pl[i] = upper_bound(dic.begin(), dic.end(), l[i])-dic.begin();
    for(int i=2;i<n;i++) pr[i] = upper_bound(dic.begin(), dic.end(), r[i])-dic.begin();
}

ll v[maxn*4][3];
int in[maxn];
ll A[3];

void update(int o , int l , int r , int k)
{
    if(l==r) for(int i=0;i<3;i++) v[o][i] = A[i];
    else 
    {
        int mid = (l+r)/2;
        if(to[k]<=mid) update(o*2, l, mid, k);
        else update(o*2+1, mid+1, r, k);
        for(int i=0;i<3;i++) v[o][i] = min(v[o*2][i] , v[o*2+1][i]);
    }
}

ll query(int o , int l , int r , int L , int R , int k)
{
    if(L<=l && r<=R) return v[o][k];
    int mid = (l+r)/2;
    ll res = INF;

    if(L<=mid) res = min(res , query(o*2, l, mid, L, R, k));
    if(R> mid) res = min(res , query(o*2+1, mid+1, r, L, R, k));
    return res;
}

void clear()
{
    for(int i=0;i<=n*4;i++) v[i][0] = v[i][1] = v[i][2] = INF;
    for(int i=0;i<=n;i++) id[i] = id1[i] = id2[i] = i;
    for(int i=0;i<=n;i++) in[i] = 0;
}

bool cmp1(int i , int j)  { return h[i] > h[j]; }
bool cmp2(int i , int j)  { return l[i] > l[j]; }

ll pointValue(int i){ return abs(h[i]-h[i-1])+abs(h[i]-h[i+1]); }

int sum[maxn][3];
void giveINF() { A[0] = A[1] = A[2] = INF; }
void giveOri(int k) { for(int i=0;i<3;i++) A[i] = sum[k][i]; }

void print(ll* a) { for(int i=1;i<=n;i++) cout<<a[i]<<" "; cout<<endl; }
void print(int* a) { for(int i=1;i<=n;i++) cout<<a[i]<<" "; cout<<endl; }

void perform1()
{
    clear();
    sort(id+1, id+n+1 , cmp1);
    sort(id1+1, id1+n+1, cmp2);

    int cnt = 1;
    for(int i=1;i<=n;i++) if(id[i]!=1 && id[i]!=n)
    {
        while(cnt<=n && l[id1[cnt]] >= h[id[i]]) 
        {
            int k = id1[cnt];
            if(k==1 || k==n) { cnt++; continue; }
            ll vnow = h[k-1]+h[k+1]-pointValue(k);
            sum[k][0] = A[0] = vnow - 2*h[k];
            sum[k][1] = A[1] = vnow;
            sum[k][2] = A[2] = vnow + 2*h[k];
            update(1, 0, n, k);
            in[k] = 1;
            cnt++;
        }

        int k = id[i];
        if(in[k-1]) giveINF() , update(1, 0, n, k-1);
        if(in[k]) giveINF() , update(1, 0, n, k);
        if(in[k+1]) giveINF() , update(1, 0, n, k+1);

        ll vnow = ori-2*h[k] - pointValue(k);
        tension(res[k], query(1, 0, n, 0, pl[k], 0)+vnow+l[k]+r[k]);
        tension(res[k], query(1, 0, n, pl[k], pr[k], 1)+vnow+r[k]-l[k]);
        tension(res[k], query(1, 0, n, pr[k], n, 2)+vnow-r[k]-l[k]);

        if(in[k-1]) giveOri(k-1) , update(1, 0, n, k-1);
        if(in[k]) giveOri(k) , update(1, 0, n, k);
        if(in[k+1]) giveOri(k+1) , update(1, 0, n, k+1);
    }
}

bool cmp3(int i , int j) { return h[i]<h[j]; }
bool cmp4(int i , int j) { return r[i]<r[j]; } 
void perform2()
{
    clear();
    sort(id+1, id+n+1 , cmp3);
    sort(id1+1, id1+n+1, cmp4);

    int cnt = 1;
    for(int i=1;i<=n;i++) if(id[i]!=1 && id[i]!=n)
    {
        while(cnt<=n && r[id1[cnt]] <= h[id[i]]) 
        {
            int k = id1[cnt];
            if(k==1 || k==n) { cnt++; continue; }
            ll vnow =-h[k-1]-h[k+1]-pointValue(k);
            sum[k][0] = A[0] = vnow - 2*h[k];
            sum[k][1] = A[1] = vnow;
            sum[k][2] = A[2] = vnow + 2*h[k];
            update(1, 0, n, k);
            in[k] = 1;
            cnt++;
        }

        int k = id[i];
        if(in[k-1]) giveINF() , update(1, 0, n, k-1);
        if(in[k]) giveINF() , update(1, 0, n, k);
        if(in[k+1]) giveINF() , update(1, 0, n, k+1);

        ll vnow = ori+2*h[k] - pointValue(k);
        tension(res[k], query(1, 0, n, 0, pl[k], 0)+vnow+l[k]+r[k]);
        tension(res[k], query(1, 0, n, pl[k], pr[k], 1)+vnow+r[k]-l[k]);
        tension(res[k], query(1, 0, n, pr[k], n, 2)+vnow-r[k]-l[k]);

        if(in[k-1]) giveOri(k-1) , update(1, 0, n, k-1);
        if(in[k]) giveOri(k) , update(1, 0, n, k);
        if(in[k+1]) giveOri(k+1) , update(1, 0, n, k+1);
    }
}

bool cmp5(int i , int j) { return l[i]<l[j]; }
void perform3()
{
    clear();
    sort(id+1, id+n+1 , cmp3);
    sort(id1+1, id1+n+1, cmp5);
    sort(id2+1, id2+n+1, cmp4);

    int cnt = 1 , cnt1 = 1;
    for(int i=1;i<=n;i++) if(id[i]!=1 && id[i]!=n)
    {
        while(cnt<=n && l[id1[cnt]] <= h[id[i]]) 
        {
            int k = id1[cnt];
            if(k==1 || k==n) { cnt++; continue; }
            ll vnow = r[k]-l[k]-pointValue(k);
            sum[k][0] = A[0] = vnow - 2*h[k];
            sum[k][1] = A[1] = vnow;
            sum[k][2] = A[2] = vnow + 2*h[k];
            update(1, 0, n, k);
            in[k] = 1;
            cnt++;
        }
        while(cnt1<=n && r[id2[cnt1]] <= h[id[i]])
        {
            int k = id2[cnt1];
            if(k==1 || k==n) { cnt1++; continue; }
            giveINF();
            update(1, 0, n, k);
            in[k] = 0;
            cnt1++;
        }

        int k = id[i];
        if(in[k-1]) giveINF() , update(1, 0, n, k-1);
        if(in[k]) giveINF() , update(1, 0, n, k);
        if(in[k+1]) giveINF() , update(1, 0, n, k+1);

        ll vnow = ori-pointValue(k);
        tension(res[k], query(1, 0, n, 0, pl[k], 0)+vnow+l[k]+r[k]);
        tension(res[k], query(1, 0, n, pl[k], pr[k], 1)+vnow+r[k]-l[k]);
        tension(res[k], query(1, 0, n, pr[k], n, 2)+vnow-r[k]-l[k]);

        if(in[k-1]) giveOri(k-1) , update(1, 0, n, k-1);
        if(in[k]) giveOri(k) , update(1, 0, n, k);
        if(in[k+1]) giveOri(k+1) , update(1, 0, n, k+1);
    }
}

int main(int argc, char *argv[]) {

    n = re();
    for(int i=1;i<=n;i++) h[i] = re();
    for(int i=2;i<=n;i++) ori += abs(h[i]-h[i-1]);

    if(n<=2) { for(int i=1;i<=n;i++) printf("%lld\n" , ori); exit(0); }
    for(int i=1;i<=n;i++) res[i] = ori;

    for(int i=1;i<n;i++) tension(res[i], cal(i, i+1));
    for(int i=2;i<=n;i++) tension(res[i], cal(i, i-1));
    for(int i=2;i<=n;i++) tension(res[1], cal(1, i)) , tension(res[i], cal(1, i));
    for(int i=1;i<n;i++) tension(res[n], cal(n, i)) , tension(res[i], cal(n , i));

    init();
    perform1();
    perform2();
    perform3();
    for(int i=1;i<=n;i++) printf("%lld\n" , res[i]);

    return 0;
}

我们可以分类讨论再用线段树维护……（如果看到这里不想看了 ， 完全可以弃坑写 O(n2) 的暴力）

请按照我的提示2先枚举求一些答案 ， 这样下面的思路会自然些：

现在我们正在求i 的答案 ， 枚举到另一个数 j , 现在我们要交换i , j的值。 i , j原来在序列里和4个值有关(这个题头尾我们都进行特判 ， 而且我们不考虑i , j相邻的情况 ， 降低编程复杂度) ， i , j交换后只有这4个值可能发生变化。

这4个值以前的值都是固定的 ， 所以我们只考虑它们变化后的形式 ， 我们先定义几个量。
hi→原来i位置上的值
Mini=min(hi−1,hi+1)
Maxi=max(hi−1,hi+1)

绝对值最后的展开形式与 ， hi与Minj,Maxj关系 和 hj与Mini,Maxi关系 有关
可能的情况： hi<Minj;Minj≤hi<Maxj;Maxj≤hi
对于j 是类似的。

那么 ， 根据乘法原理 ， 总共有9种情况。

这9个情况的总体思路都是类似的 ， 根据 hi与Minj,Maxj 的关系 ， 逐渐把符合要求的加入一棵线段树中 ， 再根据 hj与Mini,Maxi 的关系 ， 在这棵线段树中查找符合条件的j。

下文中我们把 hi与Minj,Maxj 称作第一个关系 ， hj与Mini,Maxi 称作第二个关系。

强调刚刚提到的几个地方：

  • “逐渐加入” ： 因为对于每一个i , 并不是所有j 能够满足第一个关系。 只要我们经过适当的排序 ， 这个满足这个条件的j 随着i 的变化是逐渐变多的 ， 且前面满足条件的j 后面也一定满足。
  • 这里有两个关系的限制 ， 但线段树只能控制一个关系， 我们让他控制第二个关系 ， 所以第一个关系我们是通过逐渐加入来体现的。

由于加入条件由第一个关系控制 ， 所以第一个关系相同的情况可以一起讨论 ， 这样就有了代码中的perform1 , perform2 , perform3. 分别对应第一个关系的三种情况。

几个实现的细节：

  • 我们需要把中途查询需要的量预处理离散化 ， 方便找到这个点在线段树的位置。
  • 线段树中到底存什么 ， 取决于你在讨论第几种情况。 当你把每种情况展开时 ， 你会发现对于同一个i , 所有下标为i的量都是常量 ， 对于每一个j 我们真正关心的就是剩下的量。 把它们存在j所对应的线段树中的位置就可以啦！

最后再说明一下 ， 这份代码中有很多特判的地方 ， 我们在线段树中不讨论头尾和相邻的情况。

Fuxey
关注
专栏目录
BZOJ 3829 Poi2014 FarmCraft 树形DP+贪心
世界
03-04 2083
题目大意：给定一棵树，从1号节点出发对树进行欧拉遍历，每到达一个点这个点就开始装MC，每个点装MC的时间不同，最后回到1号节点装MC，求所有人都能联机的最少时间 令f[x]为对第x个节点进行欧拉遍历的时间，g[x]为对第x个节点进行欧拉遍历并完成所有节点的装机的最小时间 那么在每个节点以什么顺序遍历每棵子树呢？ 我们发现装机多出来的时间 即g[x]-f[x]可以用来遍历其它子树 那么显然要从
bzoj1105 [POI2007]石头花园SKA
老臣
05-08 546
题意略过。感觉这种题目还是需要找结论，一开始想的怎么用算法固定套，想了半天感觉好像可以直接做，， 结论就是，，为了保证周长最短，肯定要把所有的点放在一边，即y=x的左边或者右边，然后四种情况一一枚举找最小代价就好了。#include<cstdio> #include<algorithm> #include<cstring> #include<iostream> #define fo(i,a,b)
BZOJ1099 : [POI2007]树Drz
weixin_33701294的博客
06-30 125
首先1与i交换，n与i交换，i与i+1交换的可以$O(n)$算出。 然后只需要考虑i与x交换(1&lt;i,x&lt;n且|i-x|&gt;1)。   设 a[i]=h[i-1] b[i]=h[i+1] f[i]=|h[i-1]-h[i]|+|h[i+1]-h[i]| c[i]=min(a[i],b[i]) d[i]=max(a[i],b[i])   则交换i与x对答案的贡献为...
BZOJ 1099([POI2007]树Drz-9次线段树&分类讨论+线段树与插入顺序维护2个参数)
nike0good |Oier&ACMer | 熟能生巧
12-31 2173
1099: [POI2007]树Drz Time Limit: 15 Sec  Memory Limit: 162 MB Submit: 142  Solved: 55 [Submit][Status] Description CDQZ是一个偏远的小学校，FGD在学校里中了一排树。他却不喜欢这些树的顺序，因为他们高高矮矮显得那么参差不齐。 FGD定义这些树的不整齐程度为相邻两树的高度
bzoj1099
guoshiyuan484的博客
09-06 432
此题代码很长待我闲的蛋疼的时候再来写。。。。 思路： 首先我们考虑一个3元组q(hj,min(h[j-1],h[j+1]),max(h[j+1],h[j-1]); 然后我们复制一个数组记为k[],原数组记为h[]; 每个数组代表的是三元组不只是一个高度。 稍微分析一下交换h[i],与h[k]的话只有|h[i-1]-h[i]|,h[i+1]-h[i]|,对于k同理，所以只有4个值受影响。一
poi2007--drz。
mznanan的专栏
12-23 1656
<br />好开心，一次就ac了。。（其实。。这就是一道10k左右的线段树水题。。）<br /> <br /><br /> {ps：很囧。。。我想了差不多两小时都没想出来。最后看了一下题解- -|ca。。。波兰文的- -|显然我不是<br /><br /> 语言帝我是看不懂的- -|中文题解又有bug- -然后看了一下那些式子- -差不多懂了- -|。。<br /> 好吧。。跟上次那道物理题一样。。既然是计算机竞赛题目- -就不要像我一样太往数学方面想，。一开始一直想如何贪心活着数学方法什么的。<br
bzoj1103 [POI2007]大都市meg
weixin_30576859的博客
12-03 100
Description 在经济全球化浪潮的影响下,习惯于漫步在清晨的乡间小路的邮递员Blue Mary也开始骑着摩托车传递邮件了。不过，她经常回忆起以前在乡间漫步的情景。昔日，乡下有依次编号为1..n的n个小村庄，某些村庄之间有一些双向的土路。从每个村庄都恰好有一条路径到达村庄1（即比特堡）。并且，对于每个村庄，它到比特堡的路径恰好只经过编号比它的编号小的村庄。另外，对于所有道路而言，它们都...
BZOJ 2525 Poi2011 Dynamite 二分答案+树形贪心
世界
06-06 2024
题目大意：给定一棵树，有一些点是关键点，要求选择不超过mm个点，使得所有关键点到最近的选择的点距离最大值最小 二分答案，问题转化为： 给定一棵树，有一些点是关键点，要求选择最少的点使得每个关键点到选择的点的距离不超过limitlimit 然后我们贪心DFS一遍 对于以一个节点为根的子树，有三种状态：0.这棵子树中存在一个选择的点，这个选择的点的贡献还能继续向上传递 1.这棵子树中存在一个未
BZOJ2080 POI2010 Railway & NOIP2008 双栈排序
Kanosword的博客
09-26 1845
BZOJ2080 POI2010 Railway & NOIP2008 双栈排序
BZOJ4379 POI2015 Modernizacja autostrady
Kanosword的博客
11-12 835
BZOJ4379 POI2015 Modernizacja autostrady
[POI2007]MEG-Megalopolis (树状数组,Dfs序)
weixin_30367543的博客
07-15 74
题目描述 Solution 这道题考试的时候竟然没有仔细想,结果只拿了暴力分... 其实就是一个 DFS序+树状数组。 我们先把用 DFS 把它变成一个序列,同时记录它们的 \(siz\)。 那么我们每一次连一条边之后就是对它的子树产生影响。 在树状数组里面维护就好了。 代码 #include<bits/stdc++.h> using namespace std; const in...
BZOJ 1099 树网的核
sdfzsyq的博客
07-08 227
题面 解题思路 搞了三个多小时，最后bzoj还是T，我能说什么。。。 noip数据很水，直接暴力n^3过。 我们考虑优化，首先可以贪心，我们要在直径上选肯定越插长越好，所以n^2其实就可以解决。但这还不够，根据直径的最长性，我们可以用一个单调队列优化。可以做到O（n），但bzoj T了，可能是我太弱了吧。 代码 #include&amp;amp;lt;iostream&amp;amp;gt; #include...
BZOJ 1103 [POI 2007] dfs序+树状数组 解题报告
onepointo
07-20 299
1103: [POI2007]大都市megDescription在经济全球化浪潮的影响下,习惯于漫步在清晨的乡间小路的邮递员Blue Mary也开始骑着摩托车传递邮件了。不过，她经常回忆起以前在乡间漫步的情景。昔日，乡下有依次编号为1..n的n个小村庄，某些村庄之间有一些双向的土路。从每个村庄都恰好有一条路径到达村庄1（即比特堡）。并且，对于每个村庄，它到比特堡的路径恰好只经过编号比它的编号小的村庄
“玲珑杯”Round #11
welcome to 浩·C's blog
03-04 304
D -- 萌萌哒的第四题 Time Limit：2s Memory Limit：128MByte Submissions：274Solved：182 DESCRIPTION 给一个数x，定义一个函数f(x)的结果是x的各位数字的平方和，若经过无数次递归操作之后若结果为1，也就是f(f(f(...f(x)...)))=1，那么这个数被认为是一个特别的数
bzoj1103 [POI2007]大都市meg（树+差分+树状数组）
Icefox的博客
01-10 345
给出一棵树，每次查询一个点到根的路径边权和，有边修改。直接差分+树状数组。
[POI2007]ZAP-Queries
青烟绕指柔的博客
03-03 215
题目链接：[POI2007]ZAP-Queries 式子挺简单的，因为有T组，不能O(n)去计算。于是可以预处理μ的前缀和，反演时把每段n/i的值相等的部分一起算（即分块计算） 可以通过n/(n/i)找到值相等的一段的段末位置 AC代码： #pragma GCC optimize("-Ofast","-funroll-all-loops") #include<bits/stdc++.h&...
VIJOS 1362 树网的核
快到碗里来
11-06 924
描述 设T=(V, E, W) 是一个无圈且连通的无向图（也称为无根树），每条边到有正整数的权，我们称T为树网（treebetwork），其中V，E分别表示结点与边的集合，W表示各边长度的集合，并设T有n个结点。 路径：树网中任何两结点a，b都存在唯一的一条简单路径，用d(a, b)表示以a, b为端点的路径的长度，它是该路径上各边长度之和。我们称d(a, b)为a, b两结点间的距离。
[BZOJ1103][POI2007]大都市meg（树状数组维护树上差分）
私は Mocha!!
10-31 728
树状数组+树上差分+dfs序
BZOJ 1101: [POI2007]Zap
L_0_Forever_LF的专栏
11-02 451
∑na=1∑mb=1[gcd(a,b)=D]−>\sum_{a=1}^n\sum_{b=1}^m[gcd(a,b)=D]-> ∑Na=1∑Mb=1[gcd(a,b)=1] (N=⌊n/D⌋) (M=⌊m/D⌋)−>\sum_{a=1}^N\sum_{b=1}^M[gcd(a,b)=1] \ (N=\lfloor n/D\rfloor) \ (M=\lfloor m/D\rfloor) -> ∑
bzoj 1040 zjoi2008 骑士 树形dp
最新发布
08-08
题目描述 有一个 $n$ 个点的棋盘，每个点上有一个数字 $a_i$，你需要从 $(1,1)$ 走到 $(n,n)$，每次只能往右或往下走，每个格子只能经过一次，路径上的数字和为 $S$。定义一个点 $(x,y)$ 的权值为 $a_x+a_y$，求所有满足条件的路径中，所有点的权值和的最小值。 输入格式 第一行一个整数 $n$。 接下来 $n$ 行，每行 $n$ 个整数，表示棋盘上每个点的数字。 输出格式 输出一个整数，表示所有满足条件的路径中，所有点的权值和的最小值。 数据范围 $1\leq n\leq 300$ 输入样例 3 1 2 3 4 5 6 7 8 9 输出样例 25 算法1 (树形dp) $O(n^3)$ 我们可以先将所有点的权值求出来，然后将其看作是一个有权值的图，问题就转化为了在这个图中求从 $(1,1)$ 到 $(n,n)$ 的所有路径中，所有点的权值和的最小值。 我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子都被遍历过了，那么我们就可以计算出从它的左儿子到它的右儿子的路径中，所有点的权值和的最小值，然后再将这个值加上当前节点的权值，就可以得到从根节点到当前节点的路径中，所有点的权值和的最小值。 时间复杂度 树形dp的时间复杂度是 $O(n^3)$。 C++ 代码 算法2 (动态规划) $O(n^3)$ 我们可以使用动态规划来解决这个问题，具体来说，我们可以定义 $f(i,j,s)$ 表示从 $(1,1)$ 到 $(i,j)$ 的所有路径中，所有点的权值和为 $s$ 的最小值，那么我们就可以得到如下的状态转移方程： $$ f(i,j,s)=\min\{f(i-1,j,s-a_{i,j}),f(i,j-1,s-a_{i,j})\} $$ 其中 $a_{i,j}$ 表示点 $(i,j)$ 的权值。 时间复杂度 动态规划的时间复杂度是 $O(n^3)$。 C++ 代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值