线段树扫描线问题（HDU - 1255 POJ - 1177 HDU 1542等等）

最新推荐文章于 2019-08-28 21:06:38 发布
最新推荐文章于 2019-08-28 21:06:38 发布
阅读量350 收藏 3
点赞数
分类专栏： 算法竞赛 线段树 文章标签： 扫描线 HDU - 1255 POJ - 1177 HDU 1542

 

博主真的很厉害，写得非常好，我学到了很多知识，感激博主，我直接转载了这个博客，以后用来做模板。

博客转自：https://blog.csdn.net/lwt36/article/details/48908031；

HDU 1542 [POJ 1151] Atlantis （矩形面积并）

  • 题意:

    求N<=100个矩形的面积并

  • 分析:

    • 离散化: 这些技巧都是老生常谈的了, 不然浮点数怎么建树, 离散化x坐标就可以了
    • 扫描线: 首先把矩形按y轴分成两条边, 上边和下边, 对x轴建树, 扫描线可以看成一根平行于x轴的直线. 
      从y=0开始往上扫, 下边表示要计算面积+1, 上边表示已经扫过了−1, 直到扫到最后一条平行于x轴的边 
      但是真正在做的时候, 不需要完全模拟这个过程, 一条一条边地插入线段树就好了
    • 线段树: 用于动态维护扫描线在往上走时, xx轴哪些区域是有合法面积的
    • ps:这种线段树是不用lazylazy的, 因为不用push_down, 为啥不用push_down, 因为没有查询操作

  • 扫描线扫描的过程（建议配合代码模拟）

    ps:无论说的再好,都不如自己在纸上模拟一遍扫描的过程,我自己学的时候模拟了很多遍ps:无论说的再好,都不如自己在纸上模拟一遍扫描的过程,我自己学的时候模拟了很多遍 
    以下图转载自@kk303的博客

初始状态

初始状态

这里写图片描述

扫到最下边的线, 点1→3更新为1

这里写图片描述

扫到第二根线, 此时S=l*h, 得到绿色的面积, 加到答案中去, 随后更新计数

这里写图片描述

同上, 将黄色的面积加到答案中去

这里写图片描述

同上, 将灰色的面积加到答案中去

这里写图片描述

同上, 将紫色的面积加到答案中去

这里写图片描述

同上, 将蓝色的面积加到答案中去

  • 代码 
    #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl
const int N = 205, INF = 0x3f3f3f3f, MOD = 1e9 + 7;

int n;
struct Seg {
    double l, r, h; int d;
    Seg() {}
    Seg(double l, double r, double h, int d): l(l), r(r), h(h), d(d) {}
    bool operator< (const Seg& rhs) const {return h < rhs.h;}
} a[N];

int cnt[N << 2]; //根节点维护的是[l, r+1]的区间
double sum[N << 2], all[N];

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

void push_up(int l, int r, int rt) {
    if(cnt[rt]) sum[rt] = all[r + 1] - all[l];
    else if(l == r) sum[rt] = 0; //leaves have no sons
    else sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void update(int L, int R, int v, int l, int r, int rt) {
    if(L <= l && r <= R) {
        cnt[rt] += v;
        push_up(l, r, rt);
        return;
    }
    int m = l + r >> 1;
    if(L <= m) update(L, R, v, lson);
    if(R > m) update(L, R, v, rson);
    push_up(l, r, rt);
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    int kase = 0;
    while(scanf("%d", &n) == 1 && n) {
        for(int i = 1; i <= n; ++i) {
            double x1, y1, x2, y2;
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            a[i] = Seg(x1, x2, y1, 1);
            a[i + n] = Seg(x1, x2, y2, -1);
            all[i] = x1; all[i + n] = x2;
        }
        n <<= 1;
        sort(a + 1, a + 1 + n);
        sort(all + 1, all + 1 + n);
        int m = unique(all + 1, all + 1 + n) - all - 1;

        memset(cnt, 0, sizeof cnt);
        memset(sum, 0, sizeof sum);

        double ans = 0;
        for(int i = 1; i < n; ++i) {
            int l = lower_bound(all + 1, all + 1 + m, a[i].l) - all;
            int r = lower_bound(all + 1, all + 1 + m, a[i].r) - all;
            if(l < r) update(l, r - 1, a[i].d, 1, m, 1);
            ans += sum[1] * (a[i + 1].h - a[i].h);
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n", ++kase, ans);
    }
    return 0;
}

     

HDU 1255 覆盖的面积 （矩形面积交）

  • 题意:

    求N<=1000个矩形覆盖至少两次区域的面积,也就是矩形面积交

  • 分析

    • 前面的与矩形面积并类似, 不同的是push_up的时候要考虑至少覆盖一次one和至少覆盖两次two的更新 
      尤其是当前被覆盖了一次的时候, 由于没有push_down操作, 父亲节点的信息是没有同步到儿子节点的, 这样的话push_up就要考虑了.
    • 父亲被记录覆盖了一次, 但是如果儿子被覆盖过, 这些操作都是在这个父亲这个大区间上的, 就相当于父亲区间被覆盖了至少两次, 所以two和one都要更新

  • 代码

    #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl
const int N = 2e3 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;

int n;
struct Seg {
    double l, r, h; int d;
    Seg() {}
    Seg(double l, double r, double h, double d): l(l), r(r), h(h), d(d) {}
    bool operator< (const Seg& rhs) const {
        return h < rhs.h;
    }
} a[N];

int cnt[N << 2];
double one[N << 2], two[N << 2], all[N];

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

void push_up(int l, int r, int rt) {
    if(cnt[rt] >= 2) two[rt] = one[rt] = all[r + 1] - all[l];
    else if(cnt[rt] == 1) {
        one[rt] = all[r + 1] - all[l];
        if(l == r) two[rt] = 0;
        else two[rt] = one[rt << 1] + one[rt << 1 | 1];
    } else {
        if(l == r) one[rt] = two[rt] = 0;
        else {
            one[rt] = one[rt << 1] + one[rt << 1 | 1];
            two[rt] = two[rt << 1] + two[rt << 1 | 1];
        }
    }
}

void update(int L, int R, int v, int l, int r, int rt) {
    if(L <= l && r <= R) {
        cnt[rt] += v;
        push_up(l, r, rt);
        return;
    }
    int m = l + r >> 1;
    if(L <= m) update(L, R, v, lson);
    if(R > m) update(L, R, v, rson);
    push_up(l, r, rt);
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    int t; scanf("%d", &t);
    while(t--) {
        scanf("%d", &n);
        for(int i = 1; i <= n; ++i) {
            double x1, y1, x2, y2;
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            a[i] = Seg(x1, x2, y1, 1);
            a[i + n] = Seg(x1, x2, y2, -1);
            all[i] = x1; all[i + n] = x2;
        }
        n <<= 1;
        sort(a + 1, a + 1 + n);
        sort(all + 1, all + 1 + n);
        int m = unique(all + 1, all + 1 + n) - all - 1;

        memset(cnt, 0, sizeof cnt);
        memset(one, 0, sizeof one);
        memset(two, 0, sizeof two);

        double ans = 0;
        for(int i = 1; i < n; ++i) {
            int l = lower_bound(all + 1, all + 1 + m, a[i].l) - all;
            int r = lower_bound(all + 1, all + 1 + m, a[i].r) - all;
            if(l < r) update(l, r - 1, a[i].d, 1, m, 1);
            ans += two[1] * (a[i + 1].h - a[i].h);
        }
        printf("%.2f\n", ans);
    }
    return 0;
}

     

HDU 1828 [POJ 1177] Picture（矩形周长并）

  • 题意:

    求N<=5000个矩形的轮廓长度,也就是矩形周长并

  • 分析一:

    可以用类似矩形面积并的办法, 不过这次我们不乘高, 不算面积罢了. 
    需要注意的是, 由于周长的线会被重复覆盖, 我们每次需要和上一次的作差. 
    但是这样仅仅是x轴的, 不过我可以再yy轴做一次加起来就可以了

  • 演示x轴求长度和的部分 
    这里写图片描述

  • 代码一:

    #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl
const int N = 1e4 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;

int n, m[2];
int sum[N << 2], cnt[N << 2], all[2][N];
struct Seg {
    int l, r, h, d;
    Seg() {}
    Seg(int l, int r, int h, int d): l(l), r(r), h(h), d(d) {}
    bool operator< (const Seg& rhs) const {return h < rhs.h;}
} a[2][N];

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

void push_up(int p, int l, int r, int rt) {
    if(cnt[rt]) sum[rt] = all[p][r + 1] - all[p][l];
    else if(l == r) sum[rt] = 0;
    else sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}

void update(int p, int L, int R, int v, int l, int r, int rt) {
    if(L <= l && r <= R) {
        cnt[rt] += v;
        push_up(p, l, r, rt);
        return;
    }

    int m = l + r >> 1;
    if(L <= m) update(p, L, R, v, lson);
    if(R > m) update(p, L, R, v, rson);
    push_up(p, l, r, rt);
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    while(scanf("%d", &n) == 1) {
        for(int i = 1; i <= n; ++i) {
            int x1, y1, x2, y2;
            scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
            all[0][i] = x1, all[0][i + n] = x2;
            all[1][i] = y1, all[1][i + n] = y2;
            a[0][i] = Seg(x1, x2, y1, 1);
            a[0][i + n] = Seg(x1, x2, y2, -1);
            a[1][i] = Seg(y1, y2, x1, 1);
            a[1][i + n] = Seg(y1, y2, x2, -1);
        }
        n <<= 1;
        sort(all[0] + 1, all[0] + 1 + n);
        m[0] = unique(all[0] + 1, all[0] + 1 + n) - all[0] - 1;
        sort(all[1] + 1, all[1] + 1 + n);
        m[1] = unique(all[1] + 1, all[1] + 1 + n) - all[1] - 1;
        sort(a[0] + 1, a[0] + 1 + n);
        sort(a[1] + 1, a[1] + 1 + n);

//      for(int i = 0; i < 2; ++i){
//          for(int j = 1; j <= m[i]; ++j) cout << all[i][j] <<' '; cout << endl;
//      } cout << endl;

        int ans = 0;
        for(int i = 0; i < 2; ++i) {
            int t = 0, last = 0;
            memset(cnt, 0, sizeof cnt);
            memset(sum, 0, sizeof sum);
            for(int j = 1; j <= n; ++j) {
                int l = lower_bound(all[i] + 1, all[i] + 1 + m[i], a[i][j].l) - all[i];
                int r = lower_bound(all[i] + 1, all[i] + 1 + m[i], a[i][j].r) - all[i];
                if(l < r) update(i, l, r - 1, a[i][j].d, 1, m[i], 1);
                t += abs(sum[1] - last);
                last = sum[1];
            }
            ans += t;
        }
        printf("%d\n", ans);
    }
    return 0;
}

     

  • 分析二:

    当然我们也可只对xx轴做一次扫描线, 只要同时维护y轴竖线(就是求矩形面积并的时候的高)的个数, vtl记录竖线的个数 
    需要的注意的是竖线重合的情况, 需要再开变量lbd,rbd来判断重合, 避免重复计算

  • 代码二:

    #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>

using namespace std;
#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl
const int N = 2e4 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;

int n;
int sum[N << 2], cnt[N << 2], vtl[N << 2];
bool lbd[N << 2], rbd[N << 2];
struct Seg {
    int l, r, h, d;
    Seg() {}
    Seg(int l, int r, int h, int d): l(l), r(r), h(h), d(d) {}
    bool operator< (const Seg& rhs) const {return h < rhs.h;}
} a[N];

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

void push_up(int l, int r, int rt) {
    if(cnt[rt]) {
        lbd[rt] = rbd[rt] = true;
        sum[rt] = r + 1 - l;
        vtl[rt] = 2;
    }
//叶子节点的下面的节点也是0 不这样也可以(那就要数组开大 小心RE)
    else if(l == r) sum[rt] = vtl[rt] = lbd[rt] = rbd[rt] = 0;
    else {
        lbd[rt] = lbd[rt << 1];
        rbd[rt] = rbd[rt << 1 | 1];
        sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
        vtl[rt] = vtl[rt << 1] + vtl[rt << 1 | 1];
        if(rbd[rt << 1] && lbd[rt << 1 | 1]) vtl[rt] -= 2; //两条线重合
    }
}

void update(int L, int R, int v, int l, int r, int rt) {
    if(L <= l && r <= R) {
        cnt[rt] += v;
        push_up(l, r, rt);
        return;
    }
    int m = l + r >> 1;
    if(L <= m) update(L, R, v, lson);
    if(R > m) update(L, R, v, rson);
    push_up(l, r, rt);
}

int main() {
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt","w",stdout);
#endif
    ios_base::sync_with_stdio(0);

    while(scanf("%d", &n) == 1) {
        int Min = 1e4, Max = -1e4;
        for(int i = 1; i <= n; ++i) {
            int x1, y1, x2, y2;
            scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
            Min = min(Min, x1);
            Max = max(Max, x2);
            a[i] = Seg(x1, x2, y1, 1);
            a[i + n] = Seg(x1, x2, y2, -1);
        }
        n <<= 1;
        sort(a + 1, a + 1 + n);

//      memset(sum, 0, sizeof sum); 所有覆盖最后都被清除了 不需要初始化了
//      memset(cnt, 0, sizeof cnt);
//      memset(lbd, false, sizeof lbd);
//      memset(rbd, false, sizeof rbd);

        int ans = 0, last = 0;
        for(int i = 1; i <= n; ++i) {
            if(a[i].l < a[i].r) update(a[i].l, a[i].r - 1, a[i].d, Min, Max - 1, 1);
            ans += vtl[1] * (a[i + 1].h - a[i].h);
            ans += abs(sum[1] - last);
            last = sum[1];
        }
        printf("%d\n", ans);
    }
    return 0;
}

     

菜菜魁
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
hdu 1828(poj 1177)Picture(线段树+扫描线)(轮廓线)
Darkarts
06-14 440
PictureProblem Description A number of rectangular posters, photographs and other pictures of the same shape are pasted on a wall. Their sides are all vertical or horizontal. Each rectangle can be par
HDU-1542（POJ-1151） Atlantis(线段树+扫描线)
From now on...的Blogs
08-22 161
题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=1542 或 http://poj.org/problem?id=1151 Atlantis There are several ancient Gree...
扫描线，线段树，HDU 1542 HDU 4419 HDU 1255 HDU 1828
KXL5180的博客
03-03 195
我是看这个博客看懂的https://www.cnblogs.com/whywhy/p/4214353.html； 扫描线就是线段树； 先看看最简单的应用（下面我觉得讲得不好，如果不想看直接看下面的注意或者模板吧） 计算图示图形的面积，我们可以上下扫描，也可以左右扫描，图示分成的三部分就是，左右扫描，把他每一个矩形的边都记录下来，并标记是左右边或者上下边关系。左右扫描的时候，线段树维护...
扫描线+离散化+线段树HDU1255&POJ1177
rgndao的博客
08-28 136
首先我们要对扫描线算法建立一个形象的认识，可以参考链接。大概就是，对于某个由多个矩形覆盖重叠形成的不规则几何体的面积，可以转化为从下往上一系列小矩形，有点像垒砖，层数为线段数-1，也就是矩形数*2-1。 在这个算法里，线段树维护整个区间被覆盖的，有效的“长”，它是由一小段一小段的线段组成，我们对于每条线段添加一个flag成员变量，当该线段被某矩形的下边包含，该线段flag+1，上边则-1。如果该...
线段树扫描线总结，求面积，求周长（hdu1542，poj1177）
m0_37579232的博客
10-18 150
这两天学了扫描线相关内容，特来总结一下： 求面积： 假设是从下往上扫描 （1）离散横坐标 （2）对数组由高度从小到大排序 （3）对每一条横线都进行更新，sum[1]表示的是区间横坐标覆盖的长度，比如说离散化后更新[1,4]区间，实际上调用的是update(1,3)，这里是因为我们在push_up的时候，可以求出正确结果sum[rt]=x[r+1]-x[l]，这样就可以求出[1,4] （...
线段树扫描线——HDU1542&&POJ1151-Atlantis
hahaAll的博客
09-29 343
Atlantis Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 11407    Accepted Submission(s): 4841 Problem Description There are several an
HDU-1542-Atlantis，POJ-1151-Atlantis（扫描线+线段树）
永远鲜红の幼月的博客
08-24 205
这是一道题，同样的代码都能AC。 题目链接：http://poj.org/problem?id=1151 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1542 题目大意：给你n个矩形，求出它们总共的覆盖面积。 思路：扫描线+线段树板子题，由于只用维护一次以上的区间覆盖面积，因此只要被覆盖了就可以刷新节点覆盖长度。 ACCode： //...
#线段树，扫描线，离散#poj 1151 hdu 1542 Atlantis
lemondinosaur的博客
08-22 179
题目 给出一些可能重叠的矩形，求矩形的面积 分析 其实这道题用离散+朴素O(n2)O(n2)O(n^2)慢不了多少，但是为了推行线段树O(nlogn)O(nlogn)O(nlogn)的方法，只是随便搞搞，用扫描线维护横坐标，并用线段树进行纵坐标的区间修改 代码 #include &lt;cstdio&gt; #include &lt;cstring&gt; #include ...
【解题报告】hdu1255 线段树+扫描线
Desico的博客
04-14 493
这道题是紧跟着POJ1151做的，这道题和Atlantis唯一的区别就在于这道题求的是覆盖两次的面积。因为刚刚学习了扫描线，想着如何在原先的模板上进行一些修改来做这道题。我自己的想法是，原先求扫描线实际长度的时候，判断覆盖次数c>0，那么这次只要改为c>1即可。但是在实际操作中遇到了一些困难，因为原先计算的时候，如果线段1的y是从1到5，则我加入线段树的时候只会更新到最大的那个区间，不会一直更新到
HDU-2000-2099.rar_hdu
09-19
这个名为"HDU-2000-2099.rar_hdu"的压缩包包含了该平台从2000到2099共100道题目的源代码。这些题目涵盖了初级到高级的各种算法，对于学习和提升编程技能非常有帮助。 首先，我们来看看这些题目可能涉及到的基础知识...
HDU-2000-2099.zip_hdu2000
09-23
【标题】"HDU-2000-2099.zip_hdu2000" 是一个包含杭电（Hangzhou Dianzi University）ACM竞赛题目解题报告的压缩包，覆盖了编号从2000到2099的题目。这个资源对于学习算法、提高编程技巧以及准备ACM/ICPC（国际大学...
HDU-ACM_java.rar_hdu
09-22
【标题】"HDU-ACM_java.rar" 是一个针对杭州电子科技大学（HDU）ACM竞赛的资源压缩包，其中包含的是使用Java语言编写的算法解决方案。这个压缩包主要面向那些参与或准备参与ACM国际大学生程序设计竞赛（ICPC）的参赛...
kechengsheji2021.zip
07-30
kechengsheji2021.zip
1cfa8b474c28bb76433ab12fc99ee5ad.jpeg
最新发布
07-30
1cfa8b474c28bb76433ab12fc99ee5ad.jpeg
TwineCompile571GetItSetup.7z
07-30
JomiTech TwineCompile 是一款集成在 C++Builder IDE 中的插件，旨在通过多种技术显著减少 C++ 编译、构建和生成的时间。以下是 TwineCompile 的一些关键能力和特点： 集成编译优化：TwineCompile 通过多线程、文件缓存和自动后台编译等技术，直接集成到 C++Builder IDE 中，优化编译过程。 编译器封装：它不是 C++ 编译器，而是将 Embarcadero 经典和 CLANG 编译器封装在一个构建系统中，优化文件和项目的构建方式。 IDE 支持：TwineCompile 通过 GetIt 包管理器提供，支持安装它的 IDE。对于旧版 IDE 或没有活跃更新订阅的 IDE，可以购买许可证以获得支持。 版本兼容性：TwineCompile 5.x 支持 C++Builder 10.2 至 C++Builder 12.0，而 TwineCompile 4.x 支持 C++Builder 5 至 C++Builder 10.1。
SCI一区】淘金算法GRO-CNN-BiLSTM-Mutilhead-Attention多变量时序预测含源码 5642.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-BiLSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-BiLSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-BiLSTM-Mutilhead-Attention回归预测
植物大战僵尸纯js版本
07-30
用本地资源编写的css+js+html纯手撸版植物大战僵尸,使用vs code即可运行,不需要其他插件,快来下载试试吧(支持自定义阳光,僵尸刷新出现时间),支持自定义全部,有其他想法欢迎来私信共同探讨
博弈问题解析：HDU Online Judge与Poj1067的石子游戏策略
这篇资源主要涉及的是博弈问题的解决方法，特别是关于HDU Online Judge上的几道题目，包括HDU 2516, POJ 1067, HDU 1527, HDU 2177以及HDU 2176。这些题目都是关于石子游戏的，玩家需要在一定的规则下决定如何取石子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值