【洛谷题单】区间与环形动态规划

已于 2022-02-02 23:57:07 修改
阅读量600 收藏
点赞数 2
分类专栏： 刷题 文章标签： 算法
于 2022-02-02 23:42:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y13438985462/article/details/122768993
版权

P1220 关路灯

思路：
令 f [ i ] [ j ] f[i][j] f[i][j] 表示区间 [ i [i [i ~ j ] j] j] 内的灯已经被打开时所耗费的最小功率。那么在更新这个区间时，由于可以折返去关闭另头的灯，当前状态无法表示折返这一操作，所以应当对其分类讨论。

  1. 老王在位置 [ i + 1 ] [i + 1] [i+1] 关闭了位置 [ i ] [i] [i] 的灯
  2. 老王在位置 [ j ] [j] [j] 关闭了位置 [ i ] [i] [i] 的灯
  3. 老王在位置 [ j − 1 ] [j - 1] [j−1] 关闭了位置为 [ j ] [j] [j] 的灯
  4. 老王在位置 [ i ] [i] [i] 关闭了位置为 [ j ] [j] [j] 的灯

所以我们再设一个状态，为 f [ i ] [ j ] [ 0 / 1 ] f[i][j][0/1] f[i][j][0/1] [0] 表示当前老王位于区间端点 i i i 处， [ 1 ] [1] [1] 表示当前位于区间端点 [ j ] [j] [j] 处，所以根据上述讨论，状态转移方程为：
更新端点 [ i + 1 ] [i + 1] [i+1] 为 [ i ] [i] [i] 时，可以是上述的 情况 1 1 1 或者情况 2 2 2
f[i][j][0] = min(f[i + 1][j][0] + (a[i + 1] - a[i]) * (p[i] + p[n] - p[j]), f[i + 1][j][1] + (a[j] - a[i]) * (p[i] + p[n] - p[j]));
更新端点 [ j − 1 ] [j -1] [j−1] 为 [ j ] [j] [j] 时，可以是上述的 情况 3 3 3 或者情况 4 4 4
f[i][j][1] = min(f[i][j - 1][1] + (a[j] - a[j - 1]) * (p[i - 1] + p[n] - p[j - 1]), f[i][j - 1][0] + (a[j] - a[i]) * (p[i - 1] + p[n] - p[j - 1]));
其中p[i] 为路灯功率的前缀和

初始化：因为是求最小值，所有情况初始化为最大值，老王最初所在的路灯可以直接被关掉，所以初始 f [ c ] [ c ] [ 0 ] = f [ c ] [ c ] [ 1 ] f[c][c][0] = f[c][c][1] f[c][c][0]=f[c][c][1]
代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int a[N], p[N];
int f[N][N][2]; //区间(i, j) [1]表示在区间又右边端点 [0]表示在区间左端点

int main() {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("D:/Cpp/program/Test.in", "r", stdin);
    freopen("D:/Cpp/program/Test.out", "w", stdout);
#endif
    int n, c;
    cin >> n >> c;
    for(int i = 1; i <= n; i ++) {
        cin >> a[i] >> p[i];
        p[i] += p[i - 1];
    }
    memset(f, 0x3f, sizeof f);
    f[c][c][0] = f[c][c][1] = 0;
    for(int l = 2; l <= n; l ++ ) {
        for(int i = 1; i + l - 1 <= n; i ++) {
            int j = i + l - 1;
            f[i][j][0] = min(f[i + 1][j][0] + (a[i + 1] - a[i]) * (p[i] + p[n] - p[j]), 
            f[i + 1][j][1] + (a[j] - a[i]) * (p[i] + p[n] - p[j]));
            f[i][j][1] = min(f[i][j - 1][1] + (a[j] - a[j - 1]) * (p[i - 1] + p[n] - p[j - 1]),
            f[i][j - 1][0] + (a[j] - a[i]) * (p[i - 1] + p[n] - p[j - 1]));
        }
    }

    cout << min(f[1][n][0], f[1][n][1]) << '\n';

}

P3205 [HNOI2010]合唱队

思路：
同上题，该题也可以从左边或者右边加入数字，需要表示所有状态的话，需要用 f [ i ] [ [ j ] [ 0 / 1 ] f[i][[j][0/1] f[i][[j][0/1] 表示区间 [ i [i [i ~ j ] j] j] 已经排好，并且最后插入的数字是从左边 [ 0 ] [0] [0] 或者 右边 [ 1 ] [1] [1] 插入的
分类讨论：
可以从左侧插入的情况：

  1. 上一个数字从左侧插入 并且 a [ i ] < a [ i + 1 ] a[i] < a[i + 1] a[i]<a[i+1] f[i][j][0] += f[i + 1][j][0]
  2. 上一个数字从右侧插入 并且 a [ i ] < a [ j ] a[i] < a[j] a[i]<a[j] f[i][j][0] += f[i + 1][j][1]

可以从右侧插入的情况：
3. 上一个数字从左侧插入且 a [ i ] < a [ j ] a[i] < a[j] a[i]<a[j] f[i][j][1] += f[i][j - 1][0]
4. 上一个数字从右侧插入且 a [ j − 1 ] < a [ j ] a[j - 1] < a[j] a[j−1]<a[j] f[i][j][1] += f[i][j - 1][1]

初始化：
只有一个数字时，从左侧插入和从右侧插入是同一种情况，如果初始化为 f [ i ] [ j ] [ 0 ] = f [ i ] [ j ] [ 1 ] = 1 f[i][j][0] = f[i][j][1] = 1 f[i][j][0]=f[i][j][1]=1 这样是将一种统计为两种，所以只需呀初始化其中任意一个为 1 1 1 即可

代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 2010, mod = 19650827;
int f[N][N][2]; //(i, j)  [0] 表示从左边放入 [1]表示从右边放入 比较上一个放入与这个放入的数的大小
int a[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("D:/Cpp/program/Test.in", "r", stdin);
    freopen("D:/Cpp/program/Test.out", "w", stdout);
#endif
    int n;
    cin >> n;
    memset(f, 0, sizeof f);
    for(int i = 1; i <= n; i ++) {
        cin >> a[i];
        f[i][i][0] = 1;
    }

    for(int l = 2; l <= n; l ++) {
        for(int i = 1; i + l - 1 <= n; i ++) {
            int j = i + l - 1;
            if(a[i] < a[i + 1]) f[i][j][0] += f[i + 1][j][0];
            if(a[i] < a[j]) f[i][j][0] += f[i + 1][j][1];
            if(a[j] > a[i]) f[i][j][1] += f[i][j - 1][0];
            if(a[j] > a[j - 1]) f[i][j][1] += f[i][j - 1][1];
            f[i][j][0] %= mod;
            f[i][j][1] %= mod;
        }
    }

    cout << (f[1][n][0] + f[1][n][1]) % mod << '\n';
}

P1880 [NOI1995] 石子合并
很经典的区间 D p Dp Dp 例题
思路：
用 f [ i ] [ j ] f[i][j] f[i][j] 表示区间 [ i [i [i ~ j ] j] j] 的数字已经合并好时的最大(小)价值，当我们枚举区间长度为 3 3 3 及以上时，我们并不知道是用前面几个数合并后的结果去合并后面的数得到的结果最优(比如长度为 3 3 3 是用前两个数合并最后一个数还是用第一个数合并最后两个数) ，所以我们需要枚举一个中间量 k k k ,来表示应当是哪个区间与哪个区间合并。
合并一个区间的代价就是这两个区间的值的总和，所以需要预处理一个前缀和
状态转移方程(以求最大值为例)：
合并两个区间可以表示为把两个已经合并好的区间再次合并，可以表示为：
f[i][j] = max(f[i][k] + f[k + 1][j] + s[j] - s[i - 1])
s[i] 为石子值的前缀和
预处理：
长度为 1 1 1 的区间合并代价为 0 0 0 预处理所有 f[i][i] = 0
因为本题是一个环形的石子合并，只需将当前长度为 n n n 的所有数复制一份接成为长度为 2 n 2n 2n 的区间，这样操作之后，在这个 2 n 2n 2n 的区间上找一个长度为 n n n 的区间的最优解就是最终答案
代码

#include <bits/stdc++.h>
using namespace std;
const int N = 110 * 2;
int f_max[N][N], f_min[N][N];
int a[N], s[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("D:/Cpp/program/Test.in", "r", stdin);
    freopen("D:/Cpp/program/Test.out", "w", stdout);
#endif
    int n;
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> a[i], a[i + n] = a[i];
    for(int i = 1; i <= 2 * n; i ++) s[i] = s[i - 1] + a[i];
    memset(f_max, -0x3f, sizeof f_max);
    memset(f_min, 0x3f, sizeof f_min);
    for(int i = 1; i <= 2 * n; i ++) f_max[i][i] = 0, f_min[i][i] = 0;

    for(int l = 2; l <= n; l ++) {
        for(int i = 1; i + l - 1 <= 2 * n; i ++) {
            int j = i + l - 1;
            for(int k = i; k <= j; k ++) {
                f_max[i][j] = max(f_max[i][j], f_max[i][k] + f_max[k + 1][j] + s[j] - s[i - 1]);
                f_min[i][j] = min(f_min[i][j], f_min[i][k] + f_min[k + 1][j] + s[j] - s[i - 1]);
            }
        }
    }
    int ans_min = 0x3f3f3f3f, ans_max = 0;
    for(int i = 1; i <= n; i ++) {
        ans_min = min(ans_min, f_min[i][i + n - 1]);
        ans_max = max(ans_max, f_max[i][i + n - 1]);
    }
    cout << ans_min << '\n' << ans_max << '\n';
}

P1063 [NOIP2006 提高组] 能量项链
思路：
本题和石子合并很像，多了一些细节问题，我们还是令 f [ i ] [ j ] f[i][j] f[i][j] 为区间 [ i [i [i ~ j ] j] j] 合并后得到的最大值，然后就需要枚举是区间里哪两部分进行合并，枚举一个 k k k 在枚举的时候，因为除了最后一次合并，每一次都是三个不一样的数进行合并，所以 k k k 不能等于区间的左右端点。又因为需要一次性选择三个数字，所以区间长度需要为 3 3 3 的时候才可以合并；因为这题是环形的合并，实现环形合并的效果只需将所有数字复制一次然后全部接在最后一个数之后，枚举的时候限制区间长度即可。在最后一次合并时，会将某个数自己与自己相乘一次；所以本题限制的区间长度应当是到 n + 1 n + 1 n+1

状态转移方程：
f[i][j] = max(f[i][k] + f[k][j] + a[i] * a[k] * a[j])
代码

/*
    与石子合并相比，石子合并枚举的是 [1, 2] [3] 合并还是 [1] [2, 3] 合并， 所以 k 可以等于(i|j) 
    该题画出状态后应当知道至少区间长度为 3，才可以进行合并 [1] [2] [3] 三者合并 因而 k != i && k != j 
    并且最后一次合并出的数字应当是 [1] [2] [1] 即自己与自己合并，所以区间长度应为 (n + 1)
*/

#include <bits/stdc++.h>
using namespace std;
const int N = 110 * 2;
int f[N][N];
int a[N];

int main() {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("D:/Cpp/program/Test.in", "r", stdin);
    freopen("D:/Cpp/program/Test.out", "w", stdout);
#endif
    int n;
    cin >> n;
    for(int i = 1 ;i <= n; i ++) cin >> a[i], a[i + n] = a[i];
    
    for(int l = 2; l <= n + 1; l ++) {
        for(int i = 1; i + l - 1 <= 2 * n; i ++) {
            int j = i + l - 1;
            for(int k = i + 1; k <= j - 1; k ++) {
                f[i][j] = max(f[i][j], f[i][k] + f[k][j] + a[i] * a[k] * a[j]);
            }
        }
    }

    int ans = 0;
    for(int i = 1; i <= n; i ++) {
        ans = max(ans, f[i][i + n]);
    }
    cout << ans << '\n';
}

P3146 [USACO16OPEN]248 G

思路：
可以看作有条件的石子合并问题，令 f [ i ] [ j ] f[i][j] f[i][j] 为区间 [ i [i [i ~ j ] j] j] 合并后能产生的最大数字。在一个区间 [ i [i [i ~ j ] j] j] 内对于哪两部分合并之后能产生最大值未知，所以需要枚举一个中间量 k k k 来枚举合并方式。本题需要两个相邻的数相等才能够进行合并，所有本质上只是在石子合并上加了一个限制 只有f[i][k] == f[k + 1][j]时才能让这两个区间的值合并。
初始化：不进行任何合并能得到的最大值是自己本身 f[i][i] = a[i]
代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 310;
int a[N], f[N][N];

int main() {
    ios::sync_with_stdio(false); 
    cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("D:/Cpp/program/Test.in", "r", stdin);
    freopen("D:/Cpp/program/Test.out", "w", stdout);
#endif
    int n;
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> a[i];
    int ans = 0;
    for(int i = 1; i <= n; i ++) f[i][i] = a[i];
    for(int l = 2; l <= n; l ++) {
        for(int i = 1; i + l - 1 <= n; i ++) {
            int j = i + l - 1;
            for(int k = i; k < j; k ++) {
                if(f[i][k] == f[k + 1][j]) {
                    f[i][j] = max(f[i][j], f[i][k] + 1);
                    ans = max(ans, f[i][j]);
                }
            }
        }
    }
    cout << ans << '\n';
    return 0;
}

P4170 [CQOI2007]涂色

思路：
令 f [ i ] [ j ] f[i][j] f[i][j] 为给区间 [ i [i [i ~ j ] j] j] 上色所需要的最小次数。在更新区间时候，从 f [ i + 1 ] [ j ] f[i + 1][j] f[i+1][j] 更新到 f [ i ] [ j ] f[i][j] f[i][j] 时，如果 [ i ] [i] [i] 处的颜色与 [ j ] [j] [j] 处的颜色相同的话，那么这次更新所需涂色的次数应为 0 0 0，如果颜色不同的话，同样我们也是不知道先合并哪两个区间所得到的，枚举一个 k k k 用于枚举区间内哪两个区间合并后能得到最优值。
初始化：
对于每一个格子，给自己上色至少需要一次：f[i][i] = 1
状态转移方程：
f[i][j] = min(f[i + 1][j], f[i][j - 1] (颜色相同)
f[i][j] = min(f[i][k] + f[k + 1][j]) (颜色不同)

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int f[N][N];
char s[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("D:/Cpp/program/Test.in", "r", stdin);
    freopen("D:/Cpp/program/Test.out", "w", stdout);
#endif
    scanf("%s", s + 1);
    int n = strlen(s + 1);
    memset(f, 0x3f, sizeof f);
    for(int i = 1; i <= n; i ++) f[i][i] = 1;
    for(int l = 2; l <= n; l ++) {
        for(int i = 1; i  + l - 1<= n; i ++) {
            int j = i + l - 1;
            if(s[i] == s[j]) { //颜色相同
                f[i][j] = min(f[i + 1][j], f[i][j - 1]);
            } else { // 颜色不同 从哪分隔比较好
                for(int k = i; k < j; k ++) {
                    f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j]);
                }
            }
        }
    }

    cout << f[1][n] << '\n';
}

CF607B Zuma

思路：
令 f [ i ] [ j ] f[i][j] f[i][j] 为区间 [ i [i [i ~ j ] j] j] 被消除所需要的最少次数。

当枚举到的区间两个端点相等时 可以更新： f[i][j] = f[i + 1][j - 1]
当两个端点不同时，枚举一个 k k k 来枚举区间内哪两个部分合并得到的值最优
f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j]);

在去更新回文串长度为 2 2 2 时, f [ i ] [ i + 1 ] f[i][i + 1] f[i][i+1] 在进行上述操作后会变成 f [ i + 1 ] [ i ] f[i + 1][i] f[i+1][i] 没有任何变化，并不是从长度为1更新，所以需要单独预处理。

预处理：
对于每一个数字，都至少需要一次来移除它 f[i][i] = 1
对于长度为 2 的区间，如果相邻两个数相等，那么同时移除这两个数只需一次 f[i][i + 1] = 1 + (a[i] != a[i + 1])

代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int a[N], f[N][N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("D:/Cpp/program/Test.in", "r", stdin);
    freopen("D:/Cpp/program/Test.out", "w", stdout);
#endif
    int n;
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> a[i];
    memset(f, 0x3f, sizeof f);
    for(int i = 1; i <= n; i ++) f[i][i] = 1;

    for(int i = 1; i < n; i ++) {
        if(a[i] == a[i + 1]) f[i][i + 1] = 1;
        else f[i][i + 1] = 2;
    }

    for(int l = 3; l <= n; l ++) {
        for(int i = 1; i + l - 1 <= n; i ++) {
            int j = i + l - 1;
            if(a[i] == a[j]) f[i][j] = f[i + 1][j - 1];
            for(int k = i; k < j; k ++) {
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j]);
            }
        }
    }
    cout << f[1][n] << '\n';
}
Rhyems
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【洛谷5336】成绩单（区间动态规划）
life_as_dream——sagittarius_fjz
01-14 297
题目链接 初看题目，就知道是区间动态规划。那么，我们怎么设计状态呢？ 首先，f[i,j]表示区间[i,j]的最小代价，肯定是不行的，因为不能在O(1)的时间内求出区间[i,j]中最小最大的。所以我们要设计一个四维f[i,j,l,r]代表区间[i,j]删掉部分后留下的数的范围在[l,r]之中。 O(2500000000)会MLE内存要爆，而我们发现N的范围却只有50，这个突破口告诉我们用离散化将10...
语音识别动态分配内存空间--环形buffer
07-10
本话题聚焦于"语音识别动态分配内存空间--环形buffer"，这是一个优化数据处理和通信的关键技术，尤其适用于导航语音识别这样的实时应用。 环形buffer（也称为循环缓冲区）是一种特殊的数据结构，它在内存中划出一块...
洛谷题单【动态规划3】区间与环形动态规划
Tracy_yi的博客
09-12 340
【动态规划3】区间与环形动态规划
区间&环形动态规划
jiahonghao2002的博客
02-20 530
区间&环形动态规划 区间动态规划 主要思路：定义数组dp[i][j]dp[i][j]dp[i][j]为子区间[i,j][i,j][i,j]的最优解，然后建立动态规划方程，枚举的变量一般为距离，也就是j−i+1j-i+1j−i+1。 例题待补充。 环形动态规划 主要思路：定义数组dp[i][j]dp[i][j]dp[i][j]为子区间[i,j][i,j][i,j]的最优解，然后建立动态规划方程，枚举的变量一般为距离，也就是j−i+1j-i+1j−i+1。与区间动态规划不同的是，通常将一个环剪开变成一个
对于洛谷提高试炼场-动态规划篇的爆破
litble的成(tui)长(fei)史
11-05 1643
题外话 由于本蒟蒻的动态规划实在是太弱啦，所以有必要爆破一下洛谷提高试炼场。里面有很多非常好，难度也合适的动态规划题……（然而你还是抄了不少题解） niconiconi！让我们一起开始爆破吧。 lv-1 P1005 矩阵取数游戏 难度评分:※※※ 题目分析: 如果你做过洛谷P2858的话，相信这道题的状态转移方程还是很吼写的。首先把每一行分开考虑，f(i,j)表示取完第i到第j个数的
C++ 算法篇 动态规划----区间动态规划
流年的博客
09-13 1967
区间动态规划的含义与模板解释 区间DP，其实求的就是一个区间内的最优值. 一般这种题目，在设置状态的时候，都可以设f[i][j]为区间i-j的最优值 而f[i][j]的最优值，这有两个小区间合并而来的，为了划分这两个更小的区间，我们则需用用一个循环变量k来枚举，而一般的状态转移方程便是： f[i][j] = max/min (f[i][j] , f[i][k] + f[k][j] + something) 我们则需要根据这个题目的实际含义进行变通即可. 而区间dp的大致模板是： for (..
洛谷 【动态规划3】区间与环形动态规划
weixin_43975891的博客
06-14 281
提单链接 P1220 关路灯 参考《算法竞赛入门经典(Second Edition) P293 UVa1336(Second\ Edition)\ P293 \ UVa1336(Second Edition) P293 UVa1336》 在所有任意时刻，已关的灯一定是一个连续的区间 f[i][j][k]f[i][j][k]f[i][j][k]表示关上了灯[i,j][i,j][i,j]，且当前位置在kkk,k=0k=0k=0表示在左端点i，k=1k
各种类型动态规划详细题目目录（适合初等选手）
04-10
下面是动态规划的详细题目目录，涵盖了背包问题、完全背包问题、混合背包问题、有依赖的背包问题、线性DP、数字三角形、最长上升子序列、最长公共子序列、最短编辑距离、状态机模型、区间DP等多种类型。 背包问题 ...
220kV环形网络的动态无功补偿方案设计
11-09
在220kV这样的高压环形网络中，动态无功补偿更是不可或缺，因为它能够有效地应对电网中的瞬时波动和负荷变化，确保电力供应的稳定。 【220kV环形网络的特点与挑战】 220kV的高压环形网络通常具有较高的传输容量和...
双归属环形网络拓扑规划算法设计
01-19
本文研究了一种高效的双归属环形网络拓扑规划算法，提出了在满环与非满环间调整节点的启发式搜索算法，当节点数在1 500个以内时，本算法都能很快求解，而现有算法通常只能处理几百个节点的中等规模网络。本文首先给...
qt炫丽的动态环形图源码.zip
04-11
在本文中，我们将深入探讨如何使用Qt库创建炫丽的动态环形图，以及与之相关的动态饼状图和动态扇形图。Qt是一个跨平台的C++图形用户界面应用程序开发框架，它提供了丰富的图形视图类，可以方便地创建各种复杂的可视...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 275
算法014：找到字符串中所有字母异位词
36. Adam 算法详解
qq_41238579的博客
07-10 946
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 62
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 105
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
【排序 - 堆排序】
2302_80393814的博客
07-10 473
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
摩尔投票算法
qq_55846232的博客
07-14 164
摩尔投票算法的介绍以及相关例题的讲解
代码随想录算法训练营第33天
m0_62262158的博客
07-10 164
【代码】代码随想录算法训练营第33天。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值