二维矩阵 动态求最小和求和问题 分块+线段树乱搞

最新推荐文章于 2023-12-24 18:05:30 发布
最新推荐文章于 2023-12-24 18:05:30 发布
阅读量295 收藏 1
点赞数
分类专栏： 算法 分块 线段树 文章标签： 分块 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44627639/article/details/88542501
版权
算法 同时被 3 个专栏收录
23 篇文章 0 订阅
订阅专栏
线段树
4 篇文章 0 订阅
订阅专栏
分块
2 篇文章 0 订阅
订阅专栏

对于列，直接分块，用线段树维护纵坐标
时间复杂度 O ( n l o g 2 W + m W l o g 2 W ) O(nlog_2W+m\sqrt Wlog_2W) O(nlog2​W+mW ​log2​W)
n个查询操作，m个修改单点操作
当修改操作十分稀疏时候，我们可以给线段树加上lazy优化，对于一个size只有1的子树，我们可以不用建出来，而是把要建的节点保存在该点。
优化可以直接过 [BOI2007]Mokia 摩基亚

#include <bits/stdc++.h>
#define mid ((l + r) >> 1)
using namespace std;
inline void read(int &x){
    x = 0; int f = 1; char ch = getchar();
    while (!(ch >= '0' && ch <= '9')){if (ch == '-') f = -1; ch = getchar();}
    while (ch >= '0' && ch <= '9'){x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}
const int N = 1e7;
const int M = 2e6 + 10;
struct Node{int l, r, lz, val;} T[N];
int tot, blo, bel[M], w, opt, rt[N];
inline void pushdown(int p, int l, int r){
    if (!T[p].lz || l == r) return;
    if (T[p].lz <= mid){
        T[p].l = ++tot; T[tot].lz = T[p].lz; T[tot].val = T[p].val;
    }else{
        T[p].r = ++tot; T[tot].lz = T[p].lz; T[tot].val = T[p].val;
    }
    T[p].lz = 0;
}
inline void modify(int &p, int x, int v, int l = 1, int r = w){
    if (!p){p = ++tot; T[p].lz = x; T[p].val = v; return;}
    pushdown(p, l, r); T[p].val += v;//注意顺序
    if (l == r) return;
    if (x <= mid) modify(T[p].l, x, v, l, mid);
    else modify(T[p].r, x, v, mid + 1, r);
}
inline int query(int p, int x, int l = 1, int r = w){
    if (!p || !x) return 0;
    if (l == r) return T[p].val;
    if (T[p].lz) return x >= T[p].lz ? T[p].val : 0;
    int ans = T[T[p].l].val * (x >= mid);
    if (x < mid) ans += query(T[p].l, x, l, mid);
    else if (x > mid) ans += query(T[p].r, x, mid + 1, r);
    return ans;
}
int main(){
    read(opt), read(w);
    blo = sqrt(w) * 1.5 + 2;
    for (int i = 1; i <= w; i++) bel[i] = (i - 1) / blo + 1;
    tot = w + bel[w] + 2;
    while (scanf("%d", &opt)){
        if (opt == 3) break;
        if (opt == 1){
            int x, y, A; read(x), read(y), read(A);
            modify(rt[x], y, A);
            modify(rt[w + bel[x]], y, A);
        }else{
            int x1, y1, x2, y2, ans = 0; read(x1), read(y1), read(x2), read(y2);
            int mn = min(bel[x1] * blo, x2);
            for (int i = x1; i <= mn; i++)
                ans += query(rt[i], y2) - query(rt[i], y1 - 1);
            if (bel[x1] != bel[x2])
            for (int i = (bel[x2] - 1) * blo + 1; i <= x2; i++)
                ans += query(rt[i], y2) - query(rt[i], y1 - 1);
            for (int i = bel[x1] + 1; i <= bel[x2] - 1; i++)
                ans += query(rt[w + i], y2) - query(rt[w + i], y1 - 1);
            printf("%d\n", ans);
        }
    }
    return 0;
}

poj上Mobile phones差不多，只是可以有(0,0)节点

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#define mid ((l + r) >> 1)
using namespace std;
inline void read(int &x){
    x = 0; int f = 1; char ch = getchar();
    while (!(ch >= '0' && ch <= '9')){if (ch == '-') f = -1; ch = getchar();}
    while (ch >= '0' && ch <= '9'){x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}
const int N = 1e6;
const int M = 2e6 + 10;
struct Node{int l, r, lz, val;} T[N];
int tot, blo, bel[M], w, opt, rt[N];
inline void pushdown(int p, int l, int r){
    if (!T[p].lz || l == r) return;
    if (T[p].lz <= mid){
        T[p].l = ++tot; T[tot].lz = T[p].lz; T[tot].val = T[p].val;
    }else{
        T[p].r = ++tot; T[tot].lz = T[p].lz; T[tot].val = T[p].val;
    }
    T[p].lz = 0;
}
inline void modify(int &p, int x, int v, int l = 1, int r = w){
    if (!p){p = ++tot; T[p].lz = x; T[p].val = v; return;}
    pushdown(p, l, r); T[p].val += v;//注意顺序
    if (l == r) return;
    if (x <= mid) modify(T[p].l, x, v, l, mid);
    else modify(T[p].r, x, v, mid + 1, r);
}
inline int query(int p, int x, int l = 1, int r = w){
    if (!p || !x) return 0;
    if (l == r) return T[p].val;
    if (T[p].lz) return x >= T[p].lz ? T[p].val : 0;
    int ans = T[T[p].l].val * (x >= mid);
    if (x < mid) ans += query(T[p].l, x, l, mid);
    else if (x > mid) ans += query(T[p].r, x, mid + 1, r);
    return ans;
}
int main(){
    read(opt), read(w); ++w;
    blo = sqrt(w) * 1.5 + 2;
    for (int i = 1; i <= w; i++) bel[i] = (i - 1) / blo + 1;
    tot = w + bel[w] + 2;
    while (scanf("%d", &opt)){
        if (opt == 3) break;
        if (opt == 1){
            int x, y, A; read(x), read(y), read(A); ++x, ++y;
            modify(rt[x], y, A);
            modify(rt[w + bel[x]], y, A);
        }else{
            int x1, y1, x2, y2, ans = 0; read(x1), read(y1), read(x2), read(y2);
            ++x1, ++y1, ++x2, ++y2;
            int mn = min(bel[x1] * blo, x2);
            for (int i = x1; i <= mn; i++)
                ans += query(rt[i], y2) - query(rt[i], y1 - 1);
            if (bel[x1] != bel[x2])
            for (int i = (bel[x2] - 1) * blo + 1; i <= x2; i++)
                ans += query(rt[i], y2) - query(rt[i], y1 - 1);
            for (int i = bel[x1] + 1; i <= bel[x2] - 1; i++)
                ans += query(rt[w + i], y2) - query(rt[w + i], y1 - 1);
            printf("%d\n", ans);
        }
    }
    return 0;
}

静态子矩阵最小值 Matrix Searching

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define mid ((l + r) >> 1)
using namespace std;
inline void read(int &x){
    x = 0; int f = 1; char ch = getchar();
    while (!(ch >= '0' && ch <= '9')){if (ch == '-') f = -1; ch = getchar();}
    while (ch >= '0' && ch <= '9'){x = x * 10 + ch - '0'; ch = getchar();}
    x *= f;
}
inline void Min(int &x, int y){if (y < x) x = y;}
const int N = 1e6;
const int M = 300 + 10;
const int MAX = 0x7fffffff;
struct Node{int l, r, mn;} T[N];
int n, m, rt[330], TT, blo, bel[M], cnt;
inline int New(){++cnt; T[cnt].l = T[cnt].r = 0; T[cnt].mn = MAX; return cnt;}
inline void modify(int &p, int x, int v, int l = 1, int r = n){
    if (!p) p = New();
    Min(T[p].mn, v);
    if (l == r) return;
    if (x <= mid) modify(T[p].l, x, v, l, mid);
    else modify(T[p].r, x, v, mid + 1, r);
}
inline int query(int p, int ll, int rr, int l = 1, int r = n){
    if (!p) return 0;
    if (l == ll && r == rr) return T[p].mn;
    if (rr <= mid) return query(T[p].l, ll, rr, l, mid);
    else if (ll > mid) return query(T[p].r, ll, rr, mid + 1, r);
    else return (min(query(T[p].l, ll, mid, l, mid), query(T[p].r, mid + 1, rr, mid + 1, r)));
}
int main(){
    read(TT);
    while (TT--){
        cnt = 0;
        memset(rt, 0, sizeof(rt));
        read(n); blo = sqrt(n) * 1.5 + 2;
        for (int i = 1; i <= n; i++) bel[i] = (i - 1) / blo + 1;
        for (int i = 1, x; i <= n; i++)
            for (int j = 1; j <= n; j++) read(x), modify(rt[i], j, x), modify(rt[n + bel[i]], j, x);
        read(m);
        while (m--){
            int x1, y1, x2, y2, ans = MAX; read(x1), read(y1), read(x2), read(y2);
            int mn = min(bel[x1] * blo, x2);
            for (int i = x1; i <= mn; i++) Min(ans, query(rt[i], y1, y2));
            if (bel[x1] != bel[x2])
            for (int i = (bel[x2] - 1) * blo + 1; i <= x2; i++) Min(ans, query(rt[i], y1, y2));
            for (int i = bel[x1] + 1; i <= bel[x2] - 1; i++) Min(ans, query(rt[i + n], y1, y2));
            printf("%d\n", ans);
        }
    }
    return 0;
}
wtyyy!
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵求和（二维数组）（小白一定要看！！！）
Parker20120712的博客
03-16 437
接下来n行，每行m个整数，表示矩阵A的元素。接下来n行，每行m个整数，表示矩阵B的元素。原文链接：https://blog.csdn.net/qq_57813305/article/details/117040223。两个m×n矩阵A和B的和，标记为A+B=C，C也是个m×n矩阵，其内的各元素为A，B矩阵各相对应元素相加后的值。n行，每行m个整数，表示矩阵加法的结果。由m×n个数排列成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。输入两个n行m列的矩阵A和B，输出它们的和A+B。
二维数组-矩阵相加-二维数组每行最大数-杨辉三角
weixin_44435366的博客
07-10 946
二维数组 二维数组是数组的数组，二维数组的元素又一个个一维数组组成。 int[][] arr= {{1,2},{3,4,5},{6,7,8,9}}; arr就是由{1,2},{3,4,5},{6,7,8,9}三个一维数组组成的二维数组 二维数组的定义 数据类型[][] 数组名=new 数据类型[一维数组的个数] |一维数组中元素的个数]; int[][] arr=new int[2][3]; arr数组中存储了2个一维数组 第1个一维数组 arr[0] //长度为2 第2个一维数组 arr[1] //长度为
动态规划之m*n矩阵中不同路径和最小路径和
AndyJ的学习之旅
07-05 1261
LeetCode 62 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。 问总共有多少条不同的路径？ 例如，上图是一个7 x 3 的网格。有多少可能的路径？ 初始化：第一行和第一列都为1 状态转移：dp[i][j]=dp[i-1][j]+dp[i][j-1]，从上面（往下走）或者从左面（往右走）到达该点 动态规划 class Solution: def uni
二维矩阵的元素和
myblog
01-15 2106
矩阵元素和
二维子矩阵的数字之和
最新发布
w17319185551的博客
12-24 451
因为原先sums[row2][col2] - sums[row1-1][col2] - sums[row2][col1-1] + sums[row1-1][col1-1]中row1-1和cow-1可能为负数，而这样在计算时，可以通过sums[i+1][j+1]表示从(0,0) 到(i,j)的部分和，即sums[row2 + 1][col2 + 1] - sums[row1][col2 + 1] - sums[row2 + 1][col1] + sums[row1][col1]。
剑指 Offer II 013. 二维子矩阵的和
Tzecto
09-01 197
剑指 Offer II 013. 二维子矩阵的和 给定一个二维矩阵 matrix，以下类型的多个请求： 计算其子矩形范围内元素的总和，该子矩阵的左上角为 (row1, col1) ，右下角为 (row2, col2) 。 实现 NumMatrix 类： NumMatrix(int[][] matrix) 给定整数矩阵 matrix 进行初始化 int sumRegion(int row1, int col1, int row2, int col2) 返回左上角 (row1, col1) 、右下角 (row2
矩阵多维度求和
CSDN_Lrcx的博客
12-23 3034
import numpy as np x=np.arange(48).reshape(6,8) x.sum(axis=1) x.sum(axis=0) 通常遇到的都是二维矩阵在一个维度上进行求和 看下面这个例子： x=np.arange(48).reshape(2,2,3,4) x.sum(axis=(0,2,3)) 在三个维度上面求和，得到的结果应该是什么？ 前言： 四维矩阵各位置代表的含义： (批量大小，通道，高，宽)，批量大小可以理解为样本的多少 x的形状应该是这个样子的： 使用图形表示可以更好的
nenmen.zip_二维距离_矩阵聚类_聚类树_距离矩阵聚类
07-13
在MATLAB文件“nenmen.m”中，可能实现的功能包括计算二维数据点的欧氏距离，构建距离矩阵，然后使用快速扩展随机生成树算法创建聚类树。这将有助于用户理解数据的分布，发现潜在的模式，并可能为后续的数据分析提供...
使用二维网格和二维块对矩阵求和_cuda矩阵求和_cuda_矩阵求和_cuda并行_
10-03
在这个特定的案例中，"使用二维网格和二维块对矩阵求和"是一种优化的CUDA编程技术，用于提高矩阵求和的效率。 二维网格（2D Grid）是CUDA并行计算的基本组织结构之一，它由多个线程块（Thread Blocks）组成，这些...
Matlab 求二维矩阵的多个峰值
01-06
需要求多个峰值的二维矩阵如下： figure(); % 总功率谱绘图 surf(MatrixA); 绘图结果： 然后求取峰值位置（需要安装图像处理工具箱）： PeaksMap = imregionalmax(MatrixA); 其得到的结果如下，可以看到是峰值的...
Python二维数组实现求出3*3矩阵对角线元素的和示例
09-18
今天小编就为大家分享一篇Python二维数组实现求出3*3矩阵对角线元素的和示例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
矩阵(二维数组)的基本操作：加减乘+从内至外/从外至内的顺/逆时针遍历
该怎么解释？我懒得解释
10-31 2637
文章目录常规唠嗑矩阵的基本遍历矩阵转置矩阵相加减矩阵相乘矩阵的顺时针遍历-从外至内矩阵的逆时针遍历-从外至内矩阵的顺时针遍历-从内至外 常规唠嗑 就一个问题：二维数组是矩阵，这有错吗？感慨一下：程序媛和男妇产科医生，好像都挺惨 的。 我突然知道一个之前的一个业务怎么做更好了。小班同学上课，应该怎么给老师排课？这里边其实有2个固定的轴，一个是周一至周日7天，一个是0-24点24个钟头。把一个老师所有的空余时间排成一个724矩阵A，再把同学们的上课时间要求排成一个724矩阵B，然后两个矩阵相加或者相减，就能得
C语言训练-求矩阵的两对角线上的元素之和
热门推荐
m0_52708559的博客
01-25 1万+
题目描述 求矩阵的两对角线上的元素之和 输入 矩阵的行数N 和一个N*N的整数矩阵a[N][N](N<=10) 输出 所输矩阵的两对角线上的元素之和 样例输入 3 1 2 3 4 5 6 7 8 9 样例输出 25 首先我们先观察一下矩阵（为了方便您的阅读，对角线元素已经加红） 1 1 1阶矩阵和为1 2 1 2 3 4 2阶矩阵和为1+4+2+3=10 3 1 2 3 4 5 6 7 8 9 3阶矩阵和为1+5+9+7+3=25 4 4
python 求矩阵最小值_分配问题和最小矩阵和的计算（Python）
编程故事的地方
03-24 3362
python 求矩阵最小值 考虑以下问题： 由于疏忽，您的房屋急需维修。 当然，您外出并获得有关重塑和修复需要执行的操作的报价。 假设您收到的四个引号如下所示： 考虑到所有因素，这似乎很合理。 我们自然可以选择Susan，因为她为我们提供了最佳的整体价格。 但是，另一种解决方案可能是将我们需要完成的工作分解为单个项目。 然后，我们可以从承包商处获得每个维修项目的价格。 这将通...
剑指offer13：二维矩阵的数字之和
L的博客
09-18 554
题目： 输入一个二维矩阵，如何计算给定左上角坐标和右下角坐标的子矩阵的数字之和？对于同一个二维矩阵，计算子矩阵的数字之和的函数可能由于输入不同的坐标而被反复调用多次。例如，输入下图中的二维矩阵，以及左上角坐标为（2,1）和右下角坐标（4,3）的子矩阵，该函数输出8。 分析： 直接采用蛮力解法，时间复杂度为O（mn），但是输入不同的坐标反复求不同子矩阵的数字之和，因此需要优化代码，尽可能快地实现子矩阵的数字求和。 看上图，想要求黄色部分的子矩阵数字之和需要绿色圈的部分减去两个红色圈的部分再加上一个蓝色圈部
《算法竞赛-训练指南》第一章-1.24-pre_二维矩阵求最小子矩阵（O(n^3)）
李硕
08-03 1526
整整一天都在研究这个题目，也总算弄出了一点头目，还有个三维的就从一维到三维全部都看了。我就记得以前我做过这样的题目，是求最大的子序列的和，不过有限制子序列的个数必须达到的数目，我记得当时做的，是用的贪心的思想做的。其实这种题目用贪心也是可以解决的，而且可以迅速的解决。 一会将我的一维数组的贪心的方法贴出来，现在讲一下二维数组的O(N^3)算法。 主要还是用到了sum（x,y）,表示的是
python中求和时间复杂度最低的_求和算法的时间复杂度
weixin_39583013的博客
01-29 564
编辑：根据关于[：：]的O(n)性能的评论进行的更正。在TL；DR:可能是O(n)，，但您的版本是O(n²)。记住，所有的大O符号都假设“乘以一个常数”。也就是说，O(n)实际上意味着O(k*n)，而O(logn)实际上意味着O(k*logn)。在让我们看看你的第一个例子：def sum(numberSequence):assert (len(numberSequence) > 0)if (...
找数组中与其他数绝对值差和最小的数_每日算法系列【LeetCode 907】子数组的最小值之和...
weixin_39969881的博客
11-27 599
题目描述给定一个整数数组 A，找到 min(B) 的总和，其中 B 的范围为 A 的每个（连续）子数组。由于答案可能很大，因此返回答案模 10^9 + 7。示例1输入： [3,1,2,4] 输出： 17 解释： 子数组为 [3]，[1]，[2]，[4]，[3,1]，[1,2]，[2,4]，[3,1,2]，[1,2,4]，[3,1,2,4]。 最小值为 3，1，2，4，1，1，2，1，1，1，和为...
剑指offer 专项突破版 13、二维子矩阵的和
weixin_45883188的博客
03-04 163
题目链接 思路 正常来说直接BF，遍历然后相加就好，但是题目说可能会多次调用，所以要进行一定的优化。具体的措施在于提前求出二维数组的前缀和 难点在于 如何求和？ 假设要求sum[i][j],那么我们可以用sum[i-1][j]+sum[i][0]+sum[i][1]+······sum[i][j]，也就是对应的上一行的子矩阵的和加上这一行的前缀和 如何利用前缀和求出对应的子矩阵？看图即可时空复杂度 时间复杂度：设m行n列，最开始求和为O(mn)，后面每一次调用函数时间都是O(1) 空间复杂度：需要额外的
给定一个四维矩阵如何求的二维矩阵的和
05-05
如果你想求一个四维矩阵在某个维度上的和，可以使用`numpy`库中的`sum()`函数。下面是一个示例代码： ```python import numpy as np # 创建一个4维矩阵 arr = np.array([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值